RTEMS 4.11Annotated Report
Mon Sep 12 16:49:17 2011
00049140 <IMFS_Set_handlers>:
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
49140: 7206 moveq #6,%d1
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
49142: 4e56 0000 linkw %fp,#0
49146: 206e 0008 moveal %fp@(8),%a0
4914a: 2f0a movel %a2,%sp@-
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
4914c: 2450 moveal %a0@,%a2
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
4914e: 2268 0010 moveal %a0@(16),%a1
switch( node->type ) {
49152: 202a 0048 movel %a2@(72),%d0
49156: 5380 subql #1,%d0
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
49158: 2269 0034 moveal %a1@(52),%a1
switch( node->type ) {
4915c: b280 cmpl %d0,%d1
4915e: 6546 bcss 491a6 <IMFS_Set_handlers+0x66> <== NEVER TAKEN
49160: 303b 0a08 movew %pc@(4916a <IMFS_Set_handlers+0x2a>,%d0:l:2),%d0
49164: 48c0 extl %d0
49166: 4efb 0802 jmp %pc@(4916a <IMFS_Set_handlers+0x2a>,%d0:l)
4916a: 000e .short 0x000e <== NOT EXECUTED
4916c: 0016 .short 0x0016 <== NOT EXECUTED
4916e: 0022 .short 0x0022 <== NOT EXECUTED
49170: 0022 .short 0x0022 <== NOT EXECUTED
49172: 002e .short 0x002e <== NOT EXECUTED
49174: 002e .short 0x002e <== NOT EXECUTED
49176: 0036 .short 0x0036 <== NOT EXECUTED
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
49178: 2169 000c 0008 movel %a1@(12),%a0@(8)
break;
4917e: 6026 bras 491a6 <IMFS_Set_handlers+0x66>
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
49180: 203c 0005 c542 movel #378178,%d0
49186: 2140 0008 movel %d0,%a0@(8)
break;
4918a: 601a bras 491a6 <IMFS_Set_handlers+0x66>
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
4918c: 223c 0005 c5b2 movel #378290,%d1
49192: 2141 0008 movel %d1,%a0@(8)
break;
49196: 600e bras 491a6 <IMFS_Set_handlers+0x66>
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
49198: 2169 0008 0008 movel %a1@(8),%a0@(8)
break;
4919e: 6006 bras 491a6 <IMFS_Set_handlers+0x66>
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
491a0: 2169 0010 0008 movel %a1@(16),%a0@(8)
break;
}
return 0;
}
491a6: 245f moveal %sp@+,%a2
491a8: 4280 clrl %d0
491aa: 4e5e unlk %fp <== NOT EXECUTED
00048ec0 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
48ec0: 4e56 ffe8 linkw %fp,#-24
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
48ec4: 206e 0008 moveal %fp@(8),%a0
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
48ec8: 48d7 041c moveml %d2-%d4/%a2,%sp@
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
48ecc: 2450 moveal %a0@,%a2
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
48ece: 4284 clrl %d4
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
48ed0: 362e 000e movew %fp@(14),%d3
48ed4: 342e 0012 movew %fp@(18),%d2
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
48ed8: 4eb9 0004 9e20 jsr 49e20 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
48ede: 4281 clrl %d1
48ee0: 3800 movew %d0,%d4
48ee2: 322a 0038 movew %a2@(56),%d1
48ee6: b284 cmpl %d4,%d1
48ee8: 6714 beqs 48efe <IMFS_chown+0x3e>
48eea: 4a40 tstw %d0
48eec: 6710 beqs 48efe <IMFS_chown+0x3e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
48eee: 4eb9 0004 cd68 jsr 4cd68 <__errno>
48ef4: 2040 moveal %d0,%a0
48ef6: 7001 moveq #1,%d0
48ef8: 2080 movel %d0,%a0@
48efa: 70ff moveq #-1,%d0
48efc: 601e bras 48f1c <IMFS_chown+0x5c>
#endif
jnode->st_uid = owner;
48efe: 3543 0038 movew %d3,%a2@(56)
jnode->st_gid = group;
48f02: 3542 003a movew %d2,%a2@(58)
IMFS_update_ctime( jnode );
48f06: 42a7 clrl %sp@-
48f08: 486e fff8 pea %fp@(-8)
48f0c: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
48f12: 256e fff8 0044 movel %fp@(-8),%a2@(68)
return 0;
48f18: 508f addql #8,%sp
48f1a: 4280 clrl %d0
}
48f1c: 4cee 041c ffe8 moveml %fp@(-24),%d2-%d4/%a2
48f22: 4e5e unlk %fp
...
00048fa6 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
48fa6: 4e56 ffec linkw %fp,#-20
48faa: 206e 0008 moveal %fp@(8),%a0
48fae: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
48fb2: 242e 000c movel %fp@(12),%d2
48fb6: 246e 0018 moveal %fp@(24),%a2
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
48fba: 4a88 tstl %a0
48fbc: 6700 00ee beqw 490ac <IMFS_create_node+0x106>
return NULL;
parent = parent_loc->node_access;
48fc0: 2850 moveal %a0@,%a4
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
48fc2: 7007 moveq #7,%d0
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
48fc4: 2068 0010 moveal %a0@(16),%a0
48fc8: 2668 0034 moveal %a0@(52),%a3
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
48fcc: b082 cmpl %d2,%d0
48fce: 660e bnes 48fde <IMFS_create_node+0x38>
48fd0: 223c 0005 c4d2 movel #378066,%d1
48fd6: b2ab 0010 cmpl %a3@(16),%d1
48fda: 6700 00d0 beqw 490ac <IMFS_create_node+0x106>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
48fde: 2079 0005 d420 moveal 5d420 <rtems_current_user_env>,%a0
48fe4: 2028 002c movel %a0@(44),%d0
48fe8: 4680 notl %d0
48fea: c0ae 0014 andl %fp@(20),%d0
48fee: 2f00 movel %d0,%sp@-
48ff0: 2f2e 0010 movel %fp@(16),%sp@-
48ff4: 2f02 movel %d2,%sp@-
48ff6: 4eb9 0004 8f28 jsr 48f28 <IMFS_allocate_node>
if ( !node )
48ffc: 4fef 000c lea %sp@(12),%sp
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
49000: 2a40 moveal %d0,%a5
if ( !node )
49002: 4a80 tstl %d0
49004: 6700 00a8 beqw 490ae <IMFS_create_node+0x108>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
49008: 7001 moveq #1,%d0
4900a: b082 cmpl %d2,%d0
4900c: 6616 bnes 49024 <IMFS_create_node+0x7e>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4900e: 41ed 0050 lea %a5@(80),%a0
49012: 2b48 004c movel %a0,%a5@(76)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
49016: 41ed 004c lea %a5@(76),%a0
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4901a: 42ad 0050 clrl %a5@(80)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4901e: 2b48 0054 movel %a0,%a5@(84)
49022: 6066 bras 4908a <IMFS_create_node+0xe4>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
49024: 7003 moveq #3,%d0
49026: b082 cmpl %d2,%d0
49028: 6706 beqs 49030 <IMFS_create_node+0x8a>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
4902a: 7204 moveq #4,%d1
4902c: b282 cmpl %d2,%d1
4902e: 6606 bnes 49036 <IMFS_create_node+0x90>
node->info.sym_link.name = info->sym_link.name;
49030: 2b52 004c movel %a2@,%a5@(76)
49034: 6054 bras 4908a <IMFS_create_node+0xe4>
} else if ( type == IMFS_DEVICE ) {
49036: 7002 moveq #2,%d0
49038: b082 cmpl %d2,%d0
4903a: 660c bnes 49048 <IMFS_create_node+0xa2>
node->info.device.major = info->device.major;
4903c: 2b52 004c movel %a2@,%a5@(76)
node->info.device.minor = info->device.minor;
49040: 2b6a 0004 0050 movel %a2@(4),%a5@(80)
49046: 6042 bras 4908a <IMFS_create_node+0xe4>
} else if ( type == IMFS_LINEAR_FILE ) {
49048: 7206 moveq #6,%d1
4904a: b282 cmpl %d2,%d1
4904c: 6612 bnes 49060 <IMFS_create_node+0xba>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
4904e: 42ad 0054 clrl %a5@(84)
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
49052: 4280 clrl %d0
49054: 4281 clrl %d1
49056: 2b40 004c movel %d0,%a5@(76)
4905a: 2b41 0050 movel %d1,%a5@(80)
4905e: 602a bras 4908a <IMFS_create_node+0xe4>
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
49060: 7205 moveq #5,%d1
49062: b282 cmpl %d2,%d1
49064: 661a bnes 49080 <IMFS_create_node+0xda>
node->info.file.size = 0;
node->info.file.indirect = 0;
49066: 42ad 0054 clrl %a5@(84)
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
4906a: 4280 clrl %d0
4906c: 4281 clrl %d1
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
4906e: 42ad 0058 clrl %a5@(88)
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
49072: 2b40 004c movel %d0,%a5@(76)
49076: 2b41 0050 movel %d1,%a5@(80)
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
4907a: 42ad 005c clrl %a5@(92)
4907e: 600a bras 4908a <IMFS_create_node+0xe4>
} else if ( type == IMFS_FIFO ) {
49080: 7207 moveq #7,%d1
49082: b282 cmpl %d2,%d1
49084: 6604 bnes 4908a <IMFS_create_node+0xe4> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
49086: 42ad 004c clrl %a5@(76)
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
4908a: 202b 0004 movel %a3@(4),%d0
4908e: 5280 addql #1,%d0
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
49090: 2b4c 0008 movel %a4,%a5@(8)
node->st_ino = ++fs_info->ino_count;
49094: 2740 0004 movel %d0,%a3@(4)
49098: 2b40 0034 movel %d0,%a5@(52)
4909c: 2f0d movel %a5,%sp@-
4909e: 486c 004c pea %a4@(76)
490a2: 4eb9 0004 63b4 jsr 463b4 <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
490a8: 508f addql #8,%sp
490aa: 6002 bras 490ae <IMFS_create_node+0x108>
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
fs_info->fifo_handlers == &rtems_filesystem_handlers_default )
return NULL;
490ac: 9bcd subal %a5,%a5
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
490ae: 200d movel %a5,%d0
490b0: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
490b6: 4e5e unlk %fp <== NOT EXECUTED
00049268 <IMFS_eval_path>:
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
49268: 70f8 moveq #-8,%d0
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
4926a: 4e56 ffac linkw %fp,#-84
4926e: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
49272: 262e 0010 movel %fp@(16),%d3
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
49276: c083 andl %d3,%d0
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
49278: 286e 0008 moveal %fp@(8),%a4
4927c: 246e 0014 moveal %fp@(20),%a2
int i = 0;
49280: 42ae fff8 clrl %fp@(-8)
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
49284: 4a80 tstl %d0
49286: 6710 beqs 49298 <IMFS_eval_path+0x30> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
49288: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
4928e: 7c05 moveq #5,%d6 <== NOT EXECUTED
49290: 2040 moveal %d0,%a0 <== NOT EXECUTED
49292: 2086 movel %d6,%a0@ <== NOT EXECUTED
49294: 6000 0248 braw 494de <IMFS_eval_path+0x276> <== NOT EXECUTED
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
49298: 280e movel %fp,%d4
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
4929a: 2a0e movel %fp,%d5
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
4929c: 0684 ffff ffd7 addil #-41,%d4
492a2: 2e3c 0004 9984 movel #301444,%d7
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
492a8: 4bf9 0004 91ae lea 491ae <IMFS_evaluate_permission>,%a5
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
492ae: 0685 0000 000c addil #12,%d5
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
492b4: 2652 moveal %a2@,%a3
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
492b6: 486e fffc pea %fp@(-4)
492ba: 200c movel %a4,%d0
492bc: d0ae fff8 addl %fp@(-8),%d0
492c0: 2047 moveal %d7,%a0
492c2: 2f04 movel %d4,%sp@-
492c4: 2f2e 000c movel %fp@(12),%sp@-
492c8: 2f00 movel %d0,%sp@-
492ca: 4e90 jsr %a0@
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
492cc: 4fef 0010 lea %sp@(16),%sp
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
492d0: 2400 movel %d0,%d2
pathnamelen -= len;
492d2: 202e fffc movel %fp@(-4),%d0
492d6: 91ae 000c subl %d0,%fp@(12)
i += len;
492da: d1ae fff8 addl %d0,%fp@(-8)
if ( !pathloc->node_access )
492de: 4a92 tstl %a2@
492e0: 6700 00ea beqw 493cc <IMFS_eval_path+0x164>
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
492e4: 4a82 tstl %d2
492e6: 6718 beqs 49300 <IMFS_eval_path+0x98>
if ( node->type == IMFS_DIRECTORY )
492e8: 7001 moveq #1,%d0
492ea: b0ab 0048 cmpl %a3@(72),%d0
492ee: 6610 bnes 49300 <IMFS_eval_path+0x98>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
492f0: 4878 0001 pea 1 <ADD>
492f4: 2f0a movel %a2,%sp@-
492f6: 4e95 jsr %a5@
492f8: 508f addql #8,%sp
492fa: 4a80 tstl %d0
492fc: 6700 01d4 beqw 494d2 <IMFS_eval_path+0x26a>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
49300: 2652 moveal %a2@,%a3
switch( type ) {
49302: 7003 moveq #3,%d0
49304: b082 cmpl %d2,%d0
49306: 6762 beqs 4936a <IMFS_eval_path+0x102>
49308: 7204 moveq #4,%d1
4930a: b282 cmpl %d2,%d1
4930c: 6700 0144 beqw 49452 <IMFS_eval_path+0x1ea>
49310: 7c02 moveq #2,%d6
49312: bc82 cmpl %d2,%d6
49314: 6600 014a bnew 49460 <IMFS_eval_path+0x1f8>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
49318: 2079 0005 d420 moveal 5d420 <rtems_current_user_env>,%a0
4931e: b7e8 0018 cmpal %a0@(24),%a3
49322: 6792 beqs 492b6 <IMFS_eval_path+0x4e>
static inline bool rtems_filesystem_is_root_location(
const rtems_filesystem_location_info_t *loc
)
{
return loc->mt_entry->mt_fs_root.node_access == loc->node_access;
49324: 206a 0010 moveal %a2@(16),%a0
/*
* Am I at the root of this mounted filesystem?
*/
if ( rtems_filesystem_is_root_location( pathloc ) ) {
49328: b7e8 001c cmpal %a0@(28),%a3
4932c: 6630 bnes 4935e <IMFS_eval_path+0xf6>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
4932e: 4878 0014 pea 14 <OPER2>
49332: 4868 0008 pea %a0@(8)
49336: 2f0a movel %a2,%sp@-
49338: 4eb9 0004 d588 jsr 4d588 <memcpy>
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),
4933e: 206a 000c moveal %a2@(12),%a0
49342: 202e fffc movel %fp@(-4),%d0
49346: 2200 movel %d0,%d1
49348: d2ae 000c addl %fp@(12),%d1
4934c: 2f0a movel %a2,%sp@-
4934e: 2c2e fff8 movel %fp@(-8),%d6
49352: 9c80 subl %d0,%d6
49354: 2006 movel %d6,%d0
49356: 2f03 movel %d3,%sp@-
49358: 2f01 movel %d1,%sp@-
4935a: 6000 014c braw 494a8 <IMFS_eval_path+0x240>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
4935e: 266b 0008 moveal %a3@(8),%a3
49362: 4a8b tstl %a3
49364: 6600 00e6 bnew 4944c <IMFS_eval_path+0x1e4>
49368: 6062 bras 493cc <IMFS_eval_path+0x164>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
4936a: 202b 0048 movel %a3@(72),%d0
4936e: 7203 moveq #3,%d1
49370: b280 cmpl %d0,%d1
49372: 6610 bnes 49384 <IMFS_eval_path+0x11c>
IMFS_evaluate_hard_link( pathloc, 0 );
49374: 42a7 clrl %sp@-
49376: 2f0a movel %a2,%sp@-
49378: 4eb9 0004 9222 jsr 49222 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
4937e: 2652 moveal %a2@,%a3
49380: 508f addql #8,%sp
49382: 601e bras 493a2 <IMFS_eval_path+0x13a>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
49384: 7c04 moveq #4,%d6
49386: bc80 cmpl %d0,%d6
49388: 6618 bnes 493a2 <IMFS_eval_path+0x13a>
result = IMFS_evaluate_sym_link( pathloc, 0 );
4938a: 42a7 clrl %sp@-
4938c: 2f0a movel %a2,%sp@-
4938e: 4eb9 0004 94ec jsr 494ec <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
49394: 2652 moveal %a2@,%a3
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
49396: 2400 movel %d0,%d2
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
if ( result == -1 )
49398: 508f addql #8,%sp
4939a: 70ff moveq #-1,%d0
4939c: b082 cmpl %d2,%d0
4939e: 6700 0140 beqw 494e0 <IMFS_eval_path+0x278>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
493a2: 7201 moveq #1,%d1
493a4: b2ab 0048 cmpl %a3@(72),%d1
493a8: 6710 beqs 493ba <IMFS_eval_path+0x152>
rtems_set_errno_and_return_minus_one( ENOTDIR );
493aa: 4eb9 0004 cd68 jsr 4cd68 <__errno>
493b0: 7a14 moveq #20,%d5
493b2: 2040 moveal %d0,%a0
493b4: 2085 movel %d5,%a0@
493b6: 6000 0126 braw 494de <IMFS_eval_path+0x276>
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
493ba: 2f04 movel %d4,%sp@-
493bc: 2f0b movel %a3,%sp@-
493be: 4eb9 0004 9918 jsr 49918 <IMFS_find_match_in_dir>
if ( !node )
493c4: 508f addql #8,%sp
rtems_set_errno_and_return_minus_one( ENOTDIR );
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
493c6: 2640 moveal %d0,%a3
if ( !node )
493c8: 4a80 tstl %d0
493ca: 6610 bnes 493dc <IMFS_eval_path+0x174>
rtems_set_errno_and_return_minus_one( ENOENT );
493cc: 4eb9 0004 cd68 jsr 4cd68 <__errno>
493d2: 7802 moveq #2,%d4
493d4: 2040 moveal %d0,%a0
493d6: 2084 movel %d4,%a0@
493d8: 6000 0104 braw 494de <IMFS_eval_path+0x276>
* file system and not the IMFS. For example the IMFS length is
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
493dc: 7001 moveq #1,%d0
493de: b0ab 0048 cmpl %a3@(72),%d0
493e2: 6668 bnes 4944c <IMFS_eval_path+0x1e4>
493e4: 4aab 0058 tstl %a3@(88)
493e8: 6762 beqs 4944c <IMFS_eval_path+0x1e4>
IMFS_skip_separator( pathname, &pathnamelen, &i);
493ea: 486e fff8 pea %fp@(-8)
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
493ee: 240c movel %a4,%d2
493f0: 7c2e moveq #46,%d6
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
493f2: 2f05 movel %d5,%sp@-
493f4: 2f0c movel %a4,%sp@-
493f6: 4eba fcfc jsr %pc@(490f4 <IMFS_skip_separator>)
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
493fa: 202e fff8 movel %fp@(-8),%d0
493fe: d480 addl %d0,%d2
49400: 2042 moveal %d2,%a0
49402: 4fef 000c lea %sp@(12),%sp
49406: 1210 moveb %a0@,%d1
49408: 49c1 extbl %d1
4940a: bc81 cmpl %d1,%d6
4940c: 660a bnes 49418 <IMFS_eval_path+0x1b0>
4940e: 1234 0801 moveb %a4@(00000001,%d0:l),%d1
49412: 49c1 extbl %d1
49414: bc81 cmpl %d1,%d6
49416: 6726 beqs 4943e <IMFS_eval_path+0x1d6>
*pathloc = node->info.directory.mt_fs->mt_fs_root;
49418: 4878 0014 pea 14 <OPER2>
4941c: 266b 0058 moveal %a3@(88),%a3
49420: 47eb 001c lea %a3@(28),%a3
49424: 2f0b movel %a3,%sp@-
49426: 2f0a movel %a2,%sp@-
49428: 4eb9 0004 d588 jsr 4d588 <memcpy>
return (*pathloc->ops->evalpath_h)( &pathname[i],
4942e: 206a 000c moveal %a2@(12),%a0
49432: 2f0a movel %a2,%sp@-
49434: 2f03 movel %d3,%sp@-
49436: 2f2e 000c movel %fp@(12),%sp@-
4943a: 2f02 movel %d2,%sp@-
4943c: 606e bras 494ac <IMFS_eval_path+0x244>
pathnamelen,
flags, pathloc );
}
i += 2;
4943e: 5480 addql #2,%d0
pathnamelen -= 2;
49440: 55ae 000c subql #2,%fp@(12)
node = node->Parent;
49444: 266b 0008 moveal %a3@(8),%a3
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
49448: 2d40 fff8 movel %d0,%fp@(-8)
}
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
4944c: 248b movel %a3,%a2@
break;
4944e: 6000 fe66 braw 492b6 <IMFS_eval_path+0x4e>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
49452: 4eb9 0004 cd68 jsr 4cd68 <__errno>
49458: 765b moveq #91,%d3
4945a: 2040 moveal %d0,%a0
4945c: 2083 movel %d3,%a0@
4945e: 607e bras 494de <IMFS_eval_path+0x276>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
49460: 4a82 tstl %d2
49462: 6708 beqs 4946c <IMFS_eval_path+0x204>
49464: 7004 moveq #4,%d0
49466: b082 cmpl %d2,%d0
49468: 6600 fe4c bnew 492b6 <IMFS_eval_path+0x4e>
* new fs root node and let let the mounted filesystem set the handlers.
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
4946c: 7201 moveq #1,%d1
4946e: b2ab 0048 cmpl %a3@(72),%d1
49472: 6644 bnes 494b8 <IMFS_eval_path+0x250>
if ( node->info.directory.mt_fs != NULL ) {
49474: 206b 0058 moveal %a3@(88),%a0
49478: 4a88 tstl %a0
4947a: 673c beqs 494b8 <IMFS_eval_path+0x250> <== ALWAYS TAKEN
*pathloc = node->info.directory.mt_fs->mt_fs_root;
4947c: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
49480: 4868 001c pea %a0@(28) <== NOT EXECUTED
49484: 2f0a movel %a2,%sp@- <== NOT EXECUTED
49486: 4eb9 0004 d588 jsr 4d588 <memcpy> <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
4948c: 206a 000c moveal %a2@(12),%a0 <== NOT EXECUTED
49490: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
49494: 2c00 movel %d0,%d6 <== NOT EXECUTED
49496: dcae 000c addl %fp@(12),%d6 <== NOT EXECUTED
4949a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4949c: 222e fff8 movel %fp@(-8),%d1 <== NOT EXECUTED
494a0: 9280 subl %d0,%d1 <== NOT EXECUTED
494a2: 2001 movel %d1,%d0 <== NOT EXECUTED
494a4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
494a6: 2f06 movel %d6,%sp@- <== NOT EXECUTED
494a8: 4874 0800 pea %a4@(00000000,%d0:l)
494ac: 2050 moveal %a0@,%a0
494ae: 4e90 jsr %a0@
494b0: 4fef 001c lea %sp@(28),%sp
494b4: 2400 movel %d0,%d2
494b6: 6028 bras 494e0 <IMFS_eval_path+0x278>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
494b8: 2f0a movel %a2,%sp@-
494ba: 4eb9 0004 9140 jsr 49140 <IMFS_Set_handlers>
494c0: 2400 movel %d0,%d2
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
494c2: 2e83 movel %d3,%sp@
494c4: 2f0a movel %a2,%sp@-
494c6: 4eb9 0004 91ae jsr 491ae <IMFS_evaluate_permission>
494cc: 508f addql #8,%sp
494ce: 4a80 tstl %d0
494d0: 660e bnes 494e0 <IMFS_eval_path+0x278>
rtems_set_errno_and_return_minus_one( EACCES );
494d2: 4eb9 0004 cd68 jsr 4cd68 <__errno>
494d8: 740d moveq #13,%d2
494da: 2040 moveal %d0,%a0
494dc: 2082 movel %d2,%a0@
494de: 74ff moveq #-1,%d2
return result;
}
494e0: 2002 movel %d2,%d0
494e2: 4cee 3cfc ffac moveml %fp@(-84),%d2-%d7/%a2-%a5
494e8: 4e5e unlk %fp <== NOT EXECUTED
00049600 <IMFS_evaluate_for_make>:
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
49600: 4e56 ffa8 linkw %fp,#-88
49604: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
49608: 246e 000c moveal %fp@(12),%a2
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
4960c: 260e movel %fp,%d3
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
4960e: 2a0e movel %fp,%d5
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
49610: 0683 ffff ffd3 addil #-45,%d3
49616: 2e3c 0004 9984 movel #301444,%d7
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
4961c: 2c3c 0004 91ae movel #299438,%d6
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
49622: 0685 ffff fff4 addil #-12,%d5
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
49628: 286e 0008 moveal %fp@(8),%a4
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
4962c: 2652 moveal %a2@,%a3
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
4962e: 42ae fff4 clrl %fp@(-12)
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
49632: 2a6e 0010 moveal %fp@(16),%a5
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
49636: 2f0c movel %a4,%sp@-
49638: 4eb9 0004 e0d4 jsr 4e0d4 <strlen>
4963e: 588f addql #4,%sp
49640: 2d40 fffc movel %d0,%fp@(-4)
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
49644: 486e fff8 pea %fp@(-8)
49648: 200c movel %a4,%d0
4964a: d0ae fff4 addl %fp@(-12),%d0
4964e: 2047 moveal %d7,%a0
49650: 2f03 movel %d3,%sp@-
49652: 2f2e fffc movel %fp@(-4),%sp@-
49656: 2f00 movel %d0,%sp@-
49658: 4e90 jsr %a0@
pathlen -= len;
i += len;
if ( !pathloc->node_access )
4965a: 4fef 0010 lea %sp@(16),%sp
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
4965e: 2400 movel %d0,%d2
pathlen -= len;
49660: 202e fff8 movel %fp@(-8),%d0
49664: 91ae fffc subl %d0,%fp@(-4)
i += len;
49668: d1ae fff4 addl %d0,%fp@(-12)
if ( !pathloc->node_access )
4966c: 4a92 tstl %a2@
4966e: 6700 0198 beqw 49808 <IMFS_evaluate_for_make+0x208>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
49672: 4a82 tstl %d2
49674: 671a beqs 49690 <IMFS_evaluate_for_make+0x90>
if ( node->type == IMFS_DIRECTORY )
49676: 7001 moveq #1,%d0
49678: b0ab 0048 cmpl %a3@(72),%d0
4967c: 6612 bnes 49690 <IMFS_evaluate_for_make+0x90>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
4967e: 4878 0001 pea 1 <ADD>
49682: 2046 moveal %d6,%a0
49684: 2f0a movel %a2,%sp@-
49686: 4e90 jsr %a0@
49688: 508f addql #8,%sp
4968a: 4a80 tstl %d0
4968c: 6700 01cc beqw 4985a <IMFS_evaluate_for_make+0x25a>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
49690: 2652 moveal %a2@,%a3
switch( type ) {
49692: 7002 moveq #2,%d0
49694: b082 cmpl %d2,%d0
49696: 671a beqs 496b2 <IMFS_evaluate_for_make+0xb2>
49698: 6508 bcss 496a2 <IMFS_evaluate_for_make+0xa2>
4969a: 4a82 tstl %d2
4969c: 6700 012c beqw 497ca <IMFS_evaluate_for_make+0x1ca>
496a0: 60a2 bras 49644 <IMFS_evaluate_for_make+0x44>
496a2: 7203 moveq #3,%d1
496a4: b282 cmpl %d2,%d1
496a6: 6756 beqs 496fe <IMFS_evaluate_for_make+0xfe>
496a8: 7804 moveq #4,%d4
496aa: b882 cmpl %d2,%d4
496ac: 6696 bnes 49644 <IMFS_evaluate_for_make+0x44> <== NEVER TAKEN
496ae: 6000 012a braw 497da <IMFS_evaluate_for_make+0x1da>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
496b2: 2079 0005 d420 moveal 5d420 <rtems_current_user_env>,%a0
496b8: b7e8 0018 cmpal %a0@(24),%a3
496bc: 6786 beqs 49644 <IMFS_evaluate_for_make+0x44>
496be: 206a 0010 moveal %a2@(16),%a0
/*
* Am I at the root of this mounted filesystem?
*/
if ( rtems_filesystem_is_root_location( pathloc ) ) {
496c2: b7e8 001c cmpal %a0@(28),%a3
496c6: 6628 bnes 496f0 <IMFS_evaluate_for_make+0xf0>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
496c8: 4878 0014 pea 14 <OPER2>
496cc: 4868 0008 pea %a0@(8)
496d0: 2f0a movel %a2,%sp@-
496d2: 4eb9 0004 d588 jsr 4d588 <memcpy>
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
496d8: 206a 000c moveal %a2@(12),%a0
496dc: 202e fff4 movel %fp@(-12),%d0
496e0: 90ae fff8 subl %fp@(-8),%d0
496e4: 2f0d movel %a5,%sp@-
496e6: 2f0a movel %a2,%sp@-
496e8: 4874 0800 pea %a4@(00000000,%d0:l)
496ec: 6000 00b8 braw 497a6 <IMFS_evaluate_for_make+0x1a6>
}
} else {
if ( !node->Parent )
496f0: 266b 0008 moveal %a3@(8),%a3
496f4: 4a8b tstl %a3
496f6: 6600 00cc bnew 497c4 <IMFS_evaluate_for_make+0x1c4>
496fa: 6000 010c braw 49808 <IMFS_evaluate_for_make+0x208>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
496fe: 202b 0048 movel %a3@(72),%d0
49702: 7203 moveq #3,%d1
49704: b280 cmpl %d0,%d1
49706: 6706 beqs 4970e <IMFS_evaluate_for_make+0x10e>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
49708: 7204 moveq #4,%d1
4970a: b280 cmpl %d0,%d1
4970c: 6616 bnes 49724 <IMFS_evaluate_for_make+0x124>
result = IMFS_evaluate_link( pathloc, 0 );
4970e: 42a7 clrl %sp@-
if ( result == -1 )
49710: 78ff moveq #-1,%d4
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
49712: 2f0a movel %a2,%sp@-
49714: 4eb9 0004 9568 jsr 49568 <IMFS_evaluate_link>
if ( result == -1 )
4971a: 508f addql #8,%sp
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
4971c: 2400 movel %d0,%d2
if ( result == -1 )
4971e: b880 cmpl %d0,%d4
49720: 6700 0146 beqw 49868 <IMFS_evaluate_for_make+0x268>
return -1;
}
node = pathloc->node_access;
49724: 2052 moveal %a2@,%a0
if ( !node )
49726: 4a88 tstl %a0
49728: 6700 0110 beqw 4983a <IMFS_evaluate_for_make+0x23a>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
4972c: 7001 moveq #1,%d0
4972e: b0a8 0048 cmpl %a0@(72),%d0
49732: 6600 0106 bnew 4983a <IMFS_evaluate_for_make+0x23a>
/*
* Find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
49736: 2f03 movel %d3,%sp@-
49738: 2f08 movel %a0,%sp@-
4973a: 4eb9 0004 9918 jsr 49918 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
49740: 508f addql #8,%sp
/*
* Find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
49742: 2640 moveal %d0,%a3
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
49744: 4a80 tstl %d0
49746: 6700 00a0 beqw 497e8 <IMFS_evaluate_for_make+0x1e8>
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
4974a: 7001 moveq #1,%d0
4974c: b0ab 0048 cmpl %a3@(72),%d0
49750: 6672 bnes 497c4 <IMFS_evaluate_for_make+0x1c4>
49752: 4aab 0058 tstl %a3@(88)
49756: 676c beqs 497c4 <IMFS_evaluate_for_make+0x1c4>
IMFS_skip_separator( path, &pathlen, &i);
49758: 2f05 movel %d5,%sp@-
4975a: 486e fffc pea %fp@(-4)
if ((path[i] != '.') || (path[i + 1] != '.')) {
4975e: 240c movel %a4,%d2
49760: 782e moveq #46,%d4
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
49762: 2f0c movel %a4,%sp@-
49764: 4eba f98e jsr %pc@(490f4 <IMFS_skip_separator>)
if ((path[i] != '.') || (path[i + 1] != '.')) {
49768: 202e fff4 movel %fp@(-12),%d0
4976c: d480 addl %d0,%d2
4976e: 2042 moveal %d2,%a0
49770: 4fef 000c lea %sp@(12),%sp
49774: 1210 moveb %a0@,%d1
49776: 49c1 extbl %d1
49778: b881 cmpl %d1,%d4
4977a: 660a bnes 49786 <IMFS_evaluate_for_make+0x186>
4977c: 1234 0801 moveb %a4@(00000001,%d0:l),%d1
49780: 49c1 extbl %d1
49782: b881 cmpl %d1,%d4
49784: 6730 beqs 497b6 <IMFS_evaluate_for_make+0x1b6> <== ALWAYS TAKEN
*pathloc = node->info.directory.mt_fs->mt_fs_root;
49786: 4878 0014 pea 14 <OPER2>
4978a: 266b 0058 moveal %a3@(88),%a3
4978e: 47eb 001c lea %a3@(28),%a3
49792: 2f0b movel %a3,%sp@-
49794: 2f0a movel %a2,%sp@-
49796: 4eb9 0004 d588 jsr 4d588 <memcpy>
return (*pathloc->ops->evalformake_h)( &path[i],
4979c: 206a 000c moveal %a2@(12),%a0
497a0: 2f0d movel %a5,%sp@-
497a2: 2f0a movel %a2,%sp@-
497a4: 2f02 movel %d2,%sp@-
497a6: 2068 0004 moveal %a0@(4),%a0
497aa: 4e90 jsr %a0@
497ac: 4fef 0018 lea %sp@(24),%sp
497b0: 2400 movel %d0,%d2
497b2: 6000 00b4 braw 49868 <IMFS_evaluate_for_make+0x268>
pathloc,
name );
}
i += 2;
497b6: 5480 addql #2,%d0
pathlen -= 2;
497b8: 55ae fffc subql #2,%fp@(-4)
node = node->Parent;
497bc: 266b 0008 moveal %a3@(8),%a3
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalformake_h)( &path[i],
pathloc,
name );
}
i += 2;
497c0: 2d40 fff4 movel %d0,%fp@(-12)
pathlen -= 2;
node = node->Parent;
}
pathloc->node_access = node;
497c4: 248b movel %a3,%a2@
497c6: 6000 fe7c braw 49644 <IMFS_evaluate_for_make+0x44>
}
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
497ca: 4eb9 0004 cd68 jsr 4cd68 <__errno>
497d0: 7c11 moveq #17,%d6
497d2: 2040 moveal %d0,%a0
497d4: 2086 movel %d6,%a0@
497d6: 6000 008e braw 49866 <IMFS_evaluate_for_make+0x266>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
497da: 4eb9 0004 cd68 jsr 4cd68 <__errno>
497e0: 7a5b moveq #91,%d5
497e2: 2040 moveal %d0,%a0
497e4: 2085 movel %d5,%a0@
497e6: 607e bras 49866 <IMFS_evaluate_for_make+0x266>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
497e8: 202e fff4 movel %fp@(-12),%d0
497ec: 90ae fff8 subl %fp@(-8),%d0
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
if ( !IMFS_is_separator( path[ i ] ) )
497f0: 47f9 0004 38a4 lea 438a4 <rtems_filesystem_is_separator>,%a3
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
497f6: d08c addl %a4,%d0
497f8: 2a80 movel %d0,%a5@
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
497fa: 601e bras 4981a <IMFS_evaluate_for_make+0x21a>
if ( !IMFS_is_separator( path[ i ] ) )
497fc: 49c0 extbl %d0
497fe: 2f00 movel %d0,%sp@-
49800: 4e93 jsr %a3@
49802: 588f addql #4,%sp
49804: 4a80 tstl %d0
49806: 660e bnes 49816 <IMFS_evaluate_for_make+0x216>
rtems_set_errno_and_return_minus_one( ENOENT );
49808: 4eb9 0004 cd68 jsr 4cd68 <__errno>
4980e: 7802 moveq #2,%d4
49810: 2040 moveal %d0,%a0
49812: 2084 movel %d4,%a0@
49814: 6050 bras 49866 <IMFS_evaluate_for_make+0x266>
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
49816: 52ae fff4 addql #1,%fp@(-12)
4981a: 202e fff4 movel %fp@(-12),%d0
4981e: 1034 0800 moveb %a4@(00000000,%d0:l),%d0
49822: 66d8 bnes 497fc <IMFS_evaluate_for_make+0x1fc>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
49824: 2f0a movel %a2,%sp@-
49826: 4eb9 0004 9140 jsr 49140 <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
4982c: 2052 moveal %a2@,%a0
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
4982e: 2400 movel %d0,%d2
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
49830: 588f addql #4,%sp
49832: 7001 moveq #1,%d0
49834: b0a8 0048 cmpl %a0@(72),%d0
49838: 670e beqs 49848 <IMFS_evaluate_for_make+0x248> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
4983a: 4eb9 0004 cd68 jsr 4cd68 <__errno>
49840: 7614 moveq #20,%d3
49842: 2040 moveal %d0,%a0
49844: 2083 movel %d3,%a0@
49846: 601e bras 49866 <IMFS_evaluate_for_make+0x266>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
49848: 4878 0003 pea 3 <DIVIDE>
4984c: 2f0a movel %a2,%sp@-
4984e: 4eb9 0004 91ae jsr 491ae <IMFS_evaluate_permission>
49854: 508f addql #8,%sp
49856: 4a80 tstl %d0
49858: 660e bnes 49868 <IMFS_evaluate_for_make+0x268>
rtems_set_errno_and_return_minus_one( EACCES );
4985a: 4eb9 0004 cd68 jsr 4cd68 <__errno>
49860: 740d moveq #13,%d2
49862: 2040 moveal %d0,%a0
49864: 2082 movel %d2,%a0@
49866: 74ff moveq #-1,%d2
return result;
}
49868: 2002 movel %d2,%d0
4986a: 4cee 3cfc ffa8 moveml %fp@(-88),%d2-%d7/%a2-%a5
49870: 4e5e unlk %fp <== NOT EXECUTED
000491ae <IMFS_evaluate_permission>:
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
491ae: 70f8 moveq #-8,%d0
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
491b0: 4e56 fff4 linkw %fp,#-12
491b4: 48d7 040c moveml %d2-%d3/%a2,%sp@
491b8: 242e 000c movel %fp@(12),%d2
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
491bc: c082 andl %d2,%d0
491be: 6710 beqs 491d0 <IMFS_evaluate_permission+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
491c0: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
491c6: 2040 moveal %d0,%a0 <== NOT EXECUTED
491c8: 7001 moveq #1,%d0 <== NOT EXECUTED
491ca: 2080 movel %d0,%a0@ <== NOT EXECUTED
491cc: 70ff moveq #-1,%d0 <== NOT EXECUTED
491ce: 6048 bras 49218 <IMFS_evaluate_permission+0x6a> <== NOT EXECUTED
jnode = node->node_access;
491d0: 206e 0008 moveal %fp@(8),%a0
491d4: 2450 moveal %a0@,%a2
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
491d6: 4eb9 0004 9e20 jsr 49e20 <geteuid>
491dc: 3600 movew %d0,%d3
st_gid = getegid();
491de: 4eb9 0004 9e0c jsr 49e0c <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
491e4: 4281 clrl %d1
491e6: 0283 0000 ffff andil #65535,%d3
491ec: 322a 0038 movew %a2@(56),%d1
491f0: b283 cmpl %d3,%d1
491f2: 6604 bnes 491f8 <IMFS_evaluate_permission+0x4a>
flags_to_test <<= 6;
491f4: ed8a lsll #6,%d2
491f6: 6012 bras 4920a <IMFS_evaluate_permission+0x5c>
else if ( st_gid == jnode->st_gid )
491f8: 4281 clrl %d1
491fa: 0280 0000 ffff andil #65535,%d0
49200: 322a 003a movew %a2@(58),%d1
49204: b280 cmpl %d0,%d1
49206: 6602 bnes 4920a <IMFS_evaluate_permission+0x5c>
flags_to_test <<= 3;
49208: e78a lsll #3,%d2
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
4920a: 2002 movel %d2,%d0
4920c: c0aa 002e andl %a2@(46),%d0
return 1;
49210: b480 cmpl %d0,%d2
49212: 57c0 seq %d0
49214: 49c0 extbl %d0
49216: 4480 negl %d0
return 0;
}
49218: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
4921e: 4e5e unlk %fp <== NOT EXECUTED
0004c468 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4c468: 4e56 fff8 linkw %fp,#-8
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
4c46c: 206e 0008 moveal %fp@(8),%a0
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4c470: 2f0a movel %a2,%sp@-
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
4c472: 2450 moveal %a0@,%a2
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4c474: 2f02 movel %d2,%sp@-
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4c476: 4282 clrl %d2
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
4c478: 4eb9 0004 9e20 jsr 49e20 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4c47e: 4281 clrl %d1
4c480: 3400 movew %d0,%d2
4c482: 322a 0038 movew %a2@(56),%d1
4c486: b282 cmpl %d2,%d1
4c488: 6714 beqs 4c49e <IMFS_fchmod+0x36>
4c48a: 4a40 tstw %d0
4c48c: 6710 beqs 4c49e <IMFS_fchmod+0x36> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
4c48e: 4eb9 0004 cd68 jsr 4cd68 <__errno>
4c494: 2040 moveal %d0,%a0
4c496: 7001 moveq #1,%d0
4c498: 2080 movel %d0,%a0@
4c49a: 70ff moveq #-1,%d0
4c49c: 6030 bras 4c4ce <IMFS_fchmod+0x66>
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4c49e: 202a 002e movel %a2@(46),%d0
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4c4a2: 222e 000c movel %fp@(12),%d1
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4c4a6: 0280 ffff f000 andil #-4096,%d0
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4c4ac: 0281 0000 0fff andil #4095,%d1
4c4b2: 8280 orl %d0,%d1
4c4b4: 2541 002e movel %d1,%a2@(46)
IMFS_update_ctime( jnode );
4c4b8: 42a7 clrl %sp@-
4c4ba: 486e fff8 pea %fp@(-8)
4c4be: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4c4c4: 256e fff8 0044 movel %fp@(-8),%a2@(68)
return 0;
4c4ca: 508f addql #8,%sp
4c4cc: 4280 clrl %d0
}
4c4ce: 242e fff0 movel %fp@(-16),%d2
4c4d2: 246e fff4 moveal %fp@(-12),%a2
4c4d6: 4e5e unlk %fp
...
000432e6 <IMFS_fifo_ioctl>:
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
432e6: 4e56 0000 linkw %fp,#0
432ea: 206e 0008 moveal %fp@(8),%a0
432ee: 202e 000c movel %fp@(12),%d0
432f2: 226e 0010 moveal %fp@(16),%a1
432f6: 2f02 movel %d2,%sp@-
int err;
if (command == FIONBIO) {
432f8: 0c80 8004 667e cmpil #-2147195266,%d0
432fe: 661a bnes 4331a <IMFS_fifo_ioctl+0x34>
if (buffer == NULL)
43300: 4a89 tstl %a1
43302: 6734 beqs 43338 <IMFS_fifo_ioctl+0x52> <== NEVER TAKEN
err = -EFAULT;
else {
if (*(int *)buffer)
43304: 4a91 tstl %a1@
43306: 6708 beqs 43310 <IMFS_fifo_ioctl+0x2a>
iop->flags |= LIBIO_FLAGS_NO_DELAY;
43308: 7001 moveq #1,%d0
4330a: 81a8 0014 orl %d0,%a0@(20)
4330e: 6006 bras 43316 <IMFS_fifo_ioctl+0x30>
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
43310: 70fe moveq #-2,%d0
43312: c1a8 0014 andl %d0,%a0@(20)
43316: 4282 clrl %d2
43318: 602e bras 43348 <IMFS_fifo_ioctl+0x62>
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
4331a: 2f08 movel %a0,%sp@-
4331c: 2f09 movel %a1,%sp@-
4331e: 2f00 movel %d0,%sp@-
43320: 2068 0018 moveal %a0@(24),%a0
43324: 2f28 004c movel %a0@(76),%sp@-
43328: 4eb9 0004 bdee jsr 4bdee <pipe_ioctl>
IMFS_FIFO_RETURN(err);
4332e: 4fef 0010 lea %sp@(16),%sp
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
43332: 2400 movel %d0,%d2
IMFS_FIFO_RETURN(err);
43334: 6c12 bges 43348 <IMFS_fifo_ioctl+0x62>
43336: 6002 bras 4333a <IMFS_fifo_ioctl+0x54>
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
43338: 74f2 moveq #-14,%d2
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
4333a: 4eb9 0004 eae4 jsr 4eae4 <__errno>
43340: 4482 negl %d2
43342: 2040 moveal %d0,%a0
43344: 2082 movel %d2,%a0@
43346: 74ff moveq #-1,%d2
}
43348: 2002 movel %d2,%d0
4334a: 242e fffc movel %fp@(-4),%d2
4334e: 4e5e unlk %fp
...
00043150 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
43150: 4e56 fff4 linkw %fp,#-12
43154: 206e 0008 moveal %fp@(8),%a0
43158: 48d7 001c moveml %d2-%d4,%sp@
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
4315c: 2f08 movel %a0,%sp@-
4315e: 2f2e 0014 movel %fp@(20),%sp@-
43162: 2f2e 0010 movel %fp@(16),%sp@-
43166: 2f2e 000c movel %fp@(12),%sp@-
4316a: 2068 0018 moveal %a0@(24),%a0
4316e: 2f28 004c movel %a0@(76),%sp@-
43172: 4eb9 0004 be4e jsr 4be4e <pipe_lseek>
IMFS_FIFO_RETURN(err);
43178: 4fef 0014 lea %sp@(20),%sp
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
4317c: 2800 movel %d0,%d4
4317e: 2600 movel %d0,%d3
43180: 5bc2 smi %d2
43182: 49c2 extbl %d2
IMFS_FIFO_RETURN(err);
43184: 4a82 tstl %d2
43186: 6a10 bpls 43198 <IMFS_fifo_lseek+0x48> <== NEVER TAKEN
43188: 4eb9 0004 eae4 jsr 4eae4 <__errno>
4318e: 4484 negl %d4
43190: 2040 moveal %d0,%a0
43192: 74ff moveq #-1,%d2
43194: 76ff moveq #-1,%d3
43196: 2084 movel %d4,%a0@
}
43198: 2002 movel %d2,%d0
4319a: 2203 movel %d3,%d1
4319c: 4cee 001c fff4 moveml %fp@(-12),%d2-%d4
431a2: 4e5e unlk %fp <== NOT EXECUTED
000431a6 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
431a6: 4e56 fff8 linkw %fp,#-8
431aa: 206e 0008 moveal %fp@(8),%a0
431ae: 2f0a movel %a2,%sp@-
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
431b0: 2468 0018 moveal %a0@(24),%a2
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
431b4: 2f02 movel %d2,%sp@-
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
431b6: 2f08 movel %a0,%sp@-
431b8: 2f2e 0010 movel %fp@(16),%sp@-
431bc: 2f2e 000c movel %fp@(12),%sp@-
431c0: 2f2a 004c movel %a2@(76),%sp@-
431c4: 4eb9 0004 bc5c jsr 4bc5c <pipe_write>
if (err > 0) {
431ca: 4fef 0010 lea %sp@(16),%sp
size_t count
)
{
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
431ce: 2400 movel %d0,%d2
if (err > 0) {
431d0: 6f1c bles 431ee <IMFS_fifo_write+0x48>
IMFS_mtime_ctime_update(jnode);
431d2: 42a7 clrl %sp@-
431d4: 486e fff8 pea %fp@(-8)
431d8: 4eb9 0004 438c jsr 4438c <gettimeofday>
431de: 202e fff8 movel %fp@(-8),%d0
431e2: 508f addql #8,%sp
431e4: 2540 0040 movel %d0,%a2@(64)
431e8: 2540 0044 movel %d0,%a2@(68)
431ec: 6012 bras 43200 <IMFS_fifo_write+0x5a>
}
IMFS_FIFO_RETURN(err);
431ee: 4a80 tstl %d0
431f0: 670e beqs 43200 <IMFS_fifo_write+0x5a> <== NEVER TAKEN
431f2: 4eb9 0004 eae4 jsr 4eae4 <__errno>
431f8: 4482 negl %d2
431fa: 2040 moveal %d0,%a0
431fc: 2082 movel %d2,%a0@
431fe: 74ff moveq #-1,%d2
}
43200: 2002 movel %d2,%d0
43202: 242e fff0 movel %fp@(-16),%d2
43206: 246e fff4 moveal %fp@(-12),%a2
4320a: 4e5e unlk %fp <== NOT EXECUTED
00049918 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
49918: 4e56 fff0 linkw %fp,#-16
4991c: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
49920: 4879 0005 c53a pea 5c53a <dotname>
49926: 49f9 0004 db20 lea 4db20 <strcmp>,%a4
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
4992c: 242e 000c movel %fp@(12),%d2
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
49930: 2f02 movel %d2,%sp@-
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
49932: 246e 0008 moveal %fp@(8),%a2
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
49936: 4e94 jsr %a4@
49938: 508f addql #8,%sp
4993a: 4a80 tstl %d0
4993c: 673a beqs 49978 <IMFS_find_match_in_dir+0x60> <== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
4993e: 4879 0005 c53c pea 5c53c <dotdotname>
49944: 2f02 movel %d2,%sp@-
49946: 4e94 jsr %a4@
49948: 508f addql #8,%sp
4994a: 4a80 tstl %d0
4994c: 6606 bnes 49954 <IMFS_find_match_in_dir+0x3c> <== ALWAYS TAKEN
return directory->Parent;
4994e: 246a 0008 moveal %a2@(8),%a2 <== NOT EXECUTED
49952: 6024 bras 49978 <IMFS_find_match_in_dir+0x60> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
49954: 266a 004c moveal %a2@(76),%a3
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
49958: 45ea 0050 lea %a2@(80),%a2
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
4995c: 6010 bras 4996e <IMFS_find_match_in_dir+0x56>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
4995e: 486b 000c pea %a3@(12)
49962: 2f02 movel %d2,%sp@-
49964: 4e94 jsr %a4@
49966: 508f addql #8,%sp
49968: 4a80 tstl %d0
4996a: 670a beqs 49976 <IMFS_find_match_in_dir+0x5e>
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
4996c: 2653 moveal %a3@,%a3
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
4996e: b5cb cmpal %a3,%a2
49970: 66ec bnes 4995e <IMFS_find_match_in_dir+0x46>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
49972: 95ca subal %a2,%a2
49974: 6002 bras 49978 <IMFS_find_match_in_dir+0x60>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
49976: 244b moveal %a3,%a2
return the_jnode;
}
return 0;
}
49978: 200a movel %a2,%d0
4997a: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
49980: 4e5e unlk %fp <== NOT EXECUTED
00049874 <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
49874: 4e56 ffd8 linkw %fp,#-40
49878: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@
4987c: 266e 0008 moveal %fp@(8),%a3
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
49880: 240e movel %fp,%d2
49882: 0682 ffff ffec addil #-20,%d2
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
49888: 49f9 0004 9140 lea 49140 <IMFS_Set_handlers>,%a4
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
4988e: 246b 001c moveal %a3@(28),%a2
loc = temp_mt_entry->mt_fs_root;
49892: 4878 0014 pea 14 <OPER2>
49896: 486b 001c pea %a3@(28)
4989a: 2f02 movel %d2,%sp@-
4989c: 4eb9 0004 d588 jsr 4d588 <memcpy>
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
498a2: 4fef 000c lea %sp@(12),%sp
498a6: 42ab 001c clrl %a3@(28)
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( jnode->type != IMFS_DIRECTORY ) {
result = IMFS_unlink( NULL, &loc );
498aa: 47f9 0004 24e8 lea 424e8 <IMFS_unlink>,%a3
498b0: 6002 bras 498b4 <IMFS_fsunmount+0x40>
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
498b2: 2440 moveal %d0,%a2
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
498b4: 262a 0008 movel %a2@(8),%d3
loc.node_access = (void *)jnode;
498b8: 2d4a ffec movel %a2,%fp@(-20)
IMFS_Set_handlers( &loc );
498bc: 2f02 movel %d2,%sp@-
498be: 4e94 jsr %a4@
if ( jnode->type != IMFS_DIRECTORY ) {
498c0: 588f addql #4,%sp
498c2: 7001 moveq #1,%d0
498c4: b0aa 0048 cmpl %a2@(72),%d0
498c8: 660e bnes 498d8 <IMFS_fsunmount+0x64>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
498ca: 200a movel %a2,%d0
498cc: 0680 0000 0050 addil #80,%d0
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
498d2: b0aa 004c cmpl %a2@(76),%d0
498d6: 660e bnes 498e6 <IMFS_fsunmount+0x72>
result = IMFS_unlink( NULL, &loc );
498d8: 2f02 movel %d2,%sp@-
498da: 42a7 clrl %sp@-
498dc: 4e93 jsr %a3@
if (result != 0)
498de: 508f addql #8,%sp
498e0: 4a80 tstl %d0
498e2: 6624 bnes 49908 <IMFS_fsunmount+0x94> <== NEVER TAKEN
return -1;
jnode = next;
498e4: 2443 moveal %d3,%a2
}
if ( jnode != NULL ) {
498e6: 4a8a tstl %a2
498e8: 6722 beqs 4990c <IMFS_fsunmount+0x98>
if ( jnode->type == IMFS_DIRECTORY ) {
498ea: 7001 moveq #1,%d0
498ec: b0aa 0048 cmpl %a2@(72),%d0
498f0: 66c2 bnes 498b4 <IMFS_fsunmount+0x40> <== NEVER TAKEN
498f2: 220a movel %a2,%d1
498f4: 0681 0000 0050 addil #80,%d1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
498fa: 202a 004c movel %a2@(76),%d0
if ( jnode_has_children( jnode ) )
498fe: b280 cmpl %d0,%d1
49900: 67b2 beqs 498b4 <IMFS_fsunmount+0x40>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
49902: 4a80 tstl %d0
49904: 66ac bnes 498b2 <IMFS_fsunmount+0x3e> <== ALWAYS TAKEN
49906: 6006 bras 4990e <IMFS_fsunmount+0x9a> <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
49908: 70ff moveq #-1,%d0 <== NOT EXECUTED
4990a: 6002 bras 4990e <IMFS_fsunmount+0x9a> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
4990c: 4280 clrl %d0
}
4990e: 4cee 1c0c ffd8 moveml %fp@(-40),%d2-%d3/%a2-%a4
49914: 4e5e unlk %fp <== NOT EXECUTED
00049984 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
49984: 4e56 ffe4 linkw %fp,#-28
49988: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
4998c: 2a6e 0008 moveal %fp@(8),%a5
register int i = 0;
49990: 4282 clrl %d2
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
49992: 283c 0004 38a4 movel #276644,%d4
const char *path,
int pathlen,
char *token,
int *token_len
)
{
49998: 246e 0010 moveal %fp@(16),%a2
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
4999c: 284a moveal %a2,%a4
const char *path,
int pathlen,
char *token,
int *token_len
)
{
4999e: 266e 000c moveal %fp@(12),%a3
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
499a2: 1615 moveb %a5@,%d3
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
499a4: 600e bras 499b4 <IMFS_get_token+0x30>
token[i] = c;
if ( i == IMFS_NAME_MAX )
499a6: 7020 moveq #32,%d0
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
499a8: 18c3 moveb %d3,%a4@+
if ( i == IMFS_NAME_MAX )
499aa: b082 cmpl %d2,%d0
499ac: 6776 beqs 49a24 <IMFS_get_token+0xa0>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
499ae: 5282 addql #1,%d2
499b0: 1635 2800 moveb %a5@(00000000,%d2:l),%d3
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
499b4: 2044 moveal %d4,%a0
499b6: 1003 moveb %d3,%d0
499b8: 49c0 extbl %d0
499ba: 2f00 movel %d0,%sp@-
499bc: 4e90 jsr %a0@
499be: 588f addql #4,%sp
499c0: 4a80 tstl %d0
499c2: 6604 bnes 499c8 <IMFS_get_token+0x44>
499c4: b7c2 cmpal %d2,%a3
499c6: 6ede bgts 499a6 <IMFS_get_token+0x22>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
499c8: 4a82 tstl %d2
499ca: 660a bnes 499d6 <IMFS_get_token+0x52>
token[i] = c;
499cc: 1483 moveb %d3,%a2@
if ( (token[i] != '\0') && pathlen ) {
499ce: 6714 beqs 499e4 <IMFS_get_token+0x60>
499d0: 4a8b tstl %a3
499d2: 6614 bnes 499e8 <IMFS_get_token+0x64>
499d4: 600e bras 499e4 <IMFS_get_token+0x60>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
499d6: 4a32 28ff tstb %a2@(ffffffff,%d2:l)
499da: 6712 beqs 499ee <IMFS_get_token+0x6a> <== NEVER TAKEN
token[i] = '\0';
499dc: 4200 clrb %d0
499de: 1580 2800 moveb %d0,%a2@(00000000,%d2:l)
499e2: 600a bras 499ee <IMFS_get_token+0x6a>
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
499e4: 4283 clrl %d3
499e6: 6008 bras 499f0 <IMFS_get_token+0x6c>
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
499e8: 7601 moveq #1,%d3
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
499ea: 7401 moveq #1,%d2
499ec: 6002 bras 499f0 <IMFS_get_token+0x6c>
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
499ee: 7603 moveq #3,%d3
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
499f0: 206e 0014 moveal %fp@(20),%a0
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
499f4: 7003 moveq #3,%d0
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
499f6: 2082 movel %d2,%a0@
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
499f8: b083 cmpl %d3,%d0
499fa: 6632 bnes 49a2e <IMFS_get_token+0xaa>
if ( strcmp( token, "..") == 0 )
499fc: 4879 0005 c53f pea 5c53f <dotdotname+0x3>
49a02: 47f9 0004 db20 lea 4db20 <strcmp>,%a3
49a08: 2f0a movel %a2,%sp@-
49a0a: 4e93 jsr %a3@
49a0c: 508f addql #8,%sp
49a0e: 4a80 tstl %d0
49a10: 6716 beqs 49a28 <IMFS_get_token+0xa4>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
49a12: 4879 0005 c540 pea 5c540 <dotdotname+0x4>
49a18: 2f0a movel %a2,%sp@-
49a1a: 4e93 jsr %a3@
49a1c: 508f addql #8,%sp
49a1e: 4a80 tstl %d0
49a20: 670a beqs 49a2c <IMFS_get_token+0xa8>
49a22: 600a bras 49a2e <IMFS_get_token+0xaa>
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
return IMFS_INVALID_TOKEN;
49a24: 7604 moveq #4,%d3
49a26: 6006 bras 49a2e <IMFS_get_token+0xaa>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
49a28: 7602 moveq #2,%d3
49a2a: 6002 bras 49a2e <IMFS_get_token+0xaa>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
49a2c: 7601 moveq #1,%d3
}
return type;
}
49a2e: 2003 movel %d3,%d0
49a30: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
49a36: 4e5e unlk %fp
...
000420fc <IMFS_initialize_support>:
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
420fc: 307c 0006 moveaw #6,%a0
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
42100: 7210 moveq #16,%d1
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
42102: 4e56 fff4 linkw %fp,#-12
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
42106: 2039 0005 d2de movel 5d2de <imfs_rq_memfile_bytes_per_block>,%d0
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
4210c: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
42110: 246e 0008 moveal %fp@(8),%a2
42114: 242e 0014 movel %fp@(20),%d2
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
42118: b081 cmpl %d1,%d0
4211a: 6710 beqs 4212c <IMFS_initialize_support+0x30>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
4211c: 6d08 blts 42126 <IMFS_initialize_support+0x2a>
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
4211e: 5388 subql #1,%a0
42120: d281 addl %d1,%d1
42122: 4a88 tstl %a0
42124: 66f2 bnes 42118 <IMFS_initialize_support+0x1c> <== ALWAYS TAKEN
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
42126: 203c 0000 0080 movel #128,%d0
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
4212c: 23c0 0005 e244 movel %d0,5e244 <imfs_memfile_bytes_per_block>
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
42132: 4eb9 0004 90ba jsr 490ba <IMFS_create_root_node>
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
42138: 256e 000c 0028 movel %fp@(12),%a2@(40)
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
4213e: 2640 moveal %d0,%a3
42140: 2540 001c movel %d0,%a2@(28)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
42144: 2542 0024 movel %d2,%a2@(36)
temp_mt_entry->mt_fs_root.ops = op_table;
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
42148: 4878 0030 pea 30 <OPER2+0x1c>
4214c: 4879 0005 c50a pea 5c50a <IMFS_LIMITS_AND_OPTIONS>
42152: 486a 0038 pea %a2@(56)
42156: 4eb9 0004 d588 jsr 4d588 <memcpy>
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
4215c: 4878 0014 pea 14 <OPER2>
42160: 4878 0001 pea 1 <ADD>
42164: 4eb9 0004 27cc jsr 427cc <calloc>
if ( !fs_info ) {
4216a: 4fef 0014 lea %sp@(20),%sp
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
4216e: 2040 moveal %d0,%a0
if ( !fs_info ) {
42170: 4a80 tstl %d0
42172: 661a bnes 4218e <IMFS_initialize_support+0x92>
free(temp_mt_entry->mt_fs_root.node_access);
42174: 2f0b movel %a3,%sp@-
42176: 4eb9 0004 2b68 jsr 42b68 <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
4217c: 4eb9 0004 cd68 jsr 4cd68 <__errno>
42182: 588f addql #4,%sp
42184: 2040 moveal %d0,%a0
42186: 700c moveq #12,%d0
42188: 2080 movel %d0,%a0@
4218a: 70ff moveq #-1,%d0
4218c: 6030 bras 421be <IMFS_initialize_support+0xc2>
}
temp_mt_entry->fs_info = fs_info;
4218e: 2540 0034 movel %d0,%a2@(52)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
42192: 2039 0005 e248 movel 5e248 <imfs_instance.5997>,%d0
42198: 2080 movel %d0,%a0@
4219a: 5280 addql #1,%d0
4219c: 23c0 0005 e248 movel %d0,5e248 <imfs_instance.5997>
fs_info->ino_count = 1;
421a2: 7001 moveq #1,%d0
fs_info->memfile_handlers = memfile_handlers;
421a4: 216e 0010 0008 movel %fp@(16),%a0@(8)
fs_info->directory_handlers = directory_handlers;
fs_info->fifo_handlers = fifo_handlers;
421aa: 216e 0018 0010 movel %fp@(24),%a0@(16)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
421b0: 2140 0004 movel %d0,%a0@(4)
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
421b4: 2142 000c movel %d2,%a0@(12)
fs_info->fifo_handlers = fifo_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
421b8: 2740 0034 movel %d0,%a3@(52)
return 0;
421bc: 4200 clrb %d0
}
421be: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
421c4: 4e5e unlk %fp <== NOT EXECUTED
0004b668 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4b668: 4e56 fff0 linkw %fp,#-16
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
4b66c: 2039 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d0
4b672: e488 lsrl #2,%d0
4b674: 2200 movel %d0,%d1
4b676: 5381 subql #1,%d1
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4b678: 48d7 041c moveml %d2-%d4/%a2,%sp@
4b67c: 246e 0008 moveal %fp@(8),%a2
4b680: 242e 000c movel %fp@(12),%d2
4b684: 206e 0010 moveal %fp@(16),%a0
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
4b688: b282 cmpl %d2,%d1
4b68a: 6536 bcss 4b6c2 <IMFS_memfile_get_block_pointer+0x5a>
p = info->indirect;
4b68c: 226a 0054 moveal %a2@(84),%a1
if ( malloc_it ) {
4b690: 4a88 tstl %a0
4b692: 6720 beqs 4b6b4 <IMFS_memfile_get_block_pointer+0x4c>
if ( !p ) {
4b694: 4a89 tstl %a1
4b696: 6610 bnes 4b6a8 <IMFS_memfile_get_block_pointer+0x40>
p = memfile_alloc_block();
4b698: 4eb9 0004 b644 jsr 4b644 <memfile_alloc_block>
if ( !p )
4b69e: 4a80 tstl %d0
4b6a0: 6700 00f8 beqw 4b79a <IMFS_memfile_get_block_pointer+0x132>
return 0;
info->indirect = p;
4b6a4: 2540 0054 movel %d0,%a2@(84)
}
return &info->indirect[ my_block ];
4b6a8: 206a 0054 moveal %a2@(84),%a0
4b6ac: e58a lsll #2,%d2
4b6ae: d1c2 addal %d2,%a0
4b6b0: 6000 00ea braw 4b79c <IMFS_memfile_get_block_pointer+0x134>
}
if ( !p )
4b6b4: 4a89 tstl %a1
4b6b6: 6700 00e2 beqw 4b79a <IMFS_memfile_get_block_pointer+0x132>
return 0;
return &info->indirect[ my_block ];
4b6ba: 41f1 2c00 lea %a1@(00000000,%d2:l:4),%a0
4b6be: 6000 00dc braw 4b79c <IMFS_memfile_get_block_pointer+0x134>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
4b6c2: 2200 movel %d0,%d1
4b6c4: 5281 addql #1,%d1
4b6c6: 4c00 1800 mulsl %d0,%d1
4b6ca: 2241 moveal %d1,%a1
4b6cc: 5389 subql #1,%a1
4b6ce: b3c2 cmpal %d2,%a1
4b6d0: 653e bcss 4b710 <IMFS_memfile_get_block_pointer+0xa8>
my_block -= FIRST_DOUBLY_INDIRECT;
4b6d2: 9480 subl %d0,%d2
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4b6d4: 4c40 2003 remul %d0,%d3,%d2
4b6d8: 4c40 2002 remul %d0,%d2,%d2
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
4b6dc: 202a 0058 movel %a2@(88),%d0
if ( malloc_it ) {
4b6e0: 4a88 tstl %a0
4b6e2: 671c beqs 4b700 <IMFS_memfile_get_block_pointer+0x98>
if ( !p ) {
4b6e4: 4a80 tstl %d0
4b6e6: 6610 bnes 4b6f8 <IMFS_memfile_get_block_pointer+0x90>
p = memfile_alloc_block();
4b6e8: 4eb9 0004 b644 jsr 4b644 <memfile_alloc_block>
if ( !p )
4b6ee: 4a80 tstl %d0
4b6f0: 6700 00a8 beqw 4b79a <IMFS_memfile_get_block_pointer+0x132>
return 0;
info->doubly_indirect = p;
4b6f4: 2540 0058 movel %d0,%a2@(88)
}
p1 = (block_p *)p[ doubly ];
4b6f8: 2040 moveal %d0,%a0
4b6fa: 45f0 2c00 lea %a0@(00000000,%d2:l:4),%a2
4b6fe: 6066 bras 4b766 <IMFS_memfile_get_block_pointer+0xfe>
}
return (block_p *)&p1[ singly ];
}
if ( !p )
4b700: 4a80 tstl %d0
4b702: 6700 0096 beqw 4b79a <IMFS_memfile_get_block_pointer+0x132>
return 0;
p = (block_p *)p[ doubly ];
4b706: 2240 moveal %d0,%a1
4b708: 2071 2c00 moveal %a1@(00000000,%d2:l:4),%a0
4b70c: 6000 0082 braw 4b790 <IMFS_memfile_get_block_pointer+0x128>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
4b710: 2601 movel %d1,%d3
4b712: 5283 addql #1,%d3
4b714: 4c00 3800 mulsl %d0,%d3
4b718: 5383 subql #1,%d3
4b71a: b682 cmpl %d2,%d3
4b71c: 657c bcss 4b79a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
4b71e: 9481 subl %d1,%d2
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4b720: 4c40 2003 remul %d0,%d3,%d2
4b724: 4c40 2002 remul %d0,%d2,%d2
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
4b728: 4c40 2004 remul %d0,%d4,%d2
4b72c: 4c40 2002 remul %d0,%d2,%d2
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
4b730: 202a 005c movel %a2@(92),%d0
if ( malloc_it ) {
4b734: 4a88 tstl %a0
4b736: 6746 beqs 4b77e <IMFS_memfile_get_block_pointer+0x116>
if ( !p ) {
4b738: 4a80 tstl %d0
4b73a: 660e bnes 4b74a <IMFS_memfile_get_block_pointer+0xe2>
p = memfile_alloc_block();
4b73c: 4eb9 0004 b644 jsr 4b644 <memfile_alloc_block>
if ( !p )
4b742: 4a80 tstl %d0
4b744: 6754 beqs 4b79a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->triply_indirect = p;
4b746: 2540 005c movel %d0,%a2@(92)
}
p1 = (block_p *) p[ triply ];
4b74a: 2040 moveal %d0,%a0
4b74c: 45f0 2c00 lea %a0@(00000000,%d2:l:4),%a2
4b750: 2012 movel %a2@,%d0
if ( !p1 ) {
4b752: 660c bnes 4b760 <IMFS_memfile_get_block_pointer+0xf8>
p1 = memfile_alloc_block();
4b754: 4eb9 0004 b644 jsr 4b644 <memfile_alloc_block>
if ( !p1 )
4b75a: 4a80 tstl %d0
4b75c: 673c beqs 4b79a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
4b75e: 2480 movel %d0,%a2@
}
p2 = (block_p *)p1[ doubly ];
4b760: 2240 moveal %d0,%a1
4b762: 45f1 4c00 lea %a1@(00000000,%d4:l:4),%a2
4b766: 2012 movel %a2@,%d0
if ( !p2 ) {
4b768: 660c bnes 4b776 <IMFS_memfile_get_block_pointer+0x10e>
p2 = memfile_alloc_block();
4b76a: 4eb9 0004 b644 jsr 4b644 <memfile_alloc_block>
if ( !p2 )
4b770: 4a80 tstl %d0
4b772: 6726 beqs 4b79a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
4b774: 2480 movel %d0,%a2@
}
return (block_p *)&p2[ singly ];
4b776: 2240 moveal %d0,%a1
4b778: 41f1 3c00 lea %a1@(00000000,%d3:l:4),%a0
4b77c: 601e bras 4b79c <IMFS_memfile_get_block_pointer+0x134>
}
if ( !p )
4b77e: 4a80 tstl %d0
4b780: 6718 beqs 4b79a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
4b782: 2240 moveal %d0,%a1
4b784: 2071 2c00 moveal %a1@(00000000,%d2:l:4),%a0
if ( !p1 )
4b788: 4a88 tstl %a0
4b78a: 670e beqs 4b79a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
4b78c: 2070 4c00 moveal %a0@(00000000,%d4:l:4),%a0
if ( !p2 )
4b790: 4a88 tstl %a0
4b792: 6706 beqs 4b79a <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
4b794: 41f0 3c00 lea %a0@(00000000,%d3:l:4),%a0
4b798: 6002 bras 4b79c <IMFS_memfile_get_block_pointer+0x134>
}
return &info->indirect[ my_block ];
}
if ( !p )
return 0;
4b79a: 91c8 subal %a0,%a0 <== NOT EXECUTED
/*
* This means the requested block number is out of range.
*/
return 0;
}
4b79c: 2008 movel %a0,%d0
4b79e: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4b7a4: 4e5e unlk %fp <== NOT EXECUTED
0004b7a8 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4b7a8: 4e56 ffc8 linkw %fp,#-56
4b7ac: 206e 0018 moveal %fp@(24),%a0
4b7b0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4b7b4: 246e 0008 moveal %fp@(8),%a2
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
4b7b8: 7406 moveq #6,%d2
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4b7ba: 2a2e 0014 movel %fp@(20),%d5
4b7be: 286e 000c moveal %fp@(12),%a4
4b7c2: 2a6e 0010 moveal %fp@(16),%a5
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
4b7c6: b4aa 0048 cmpl %a2@(72),%d2
4b7ca: 665c bnes 4b828 <IMFS_memfile_read+0x80>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
4b7cc: 97cb subal %a3,%a3
4b7ce: 242a 004c movel %a2@(76),%d2
4b7d2: 262a 0050 movel %a2@(80),%d3
4b7d6: 2d48 fff4 movel %a0,%fp@(-12)
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
4b7da: 226a 0054 moveal %a2@(84),%a1
if (my_length > (the_jnode->info.linearfile.size - start))
4b7de: 2002 movel %d2,%d0
4b7e0: 2203 movel %d3,%d1
4b7e2: 2d4b fff0 movel %a3,%fp@(-16)
4b7e6: 280c movel %a4,%d4
4b7e8: 928d subl %a5,%d1
4b7ea: 9184 subxl %d4,%d0
4b7ec: 2c2e fff0 movel %fp@(-16),%d6
4b7f0: 2e2e fff4 movel %fp@(-12),%d7
4b7f4: 9e81 subl %d1,%d7
4b7f6: 9d80 subxl %d0,%d6
4b7f8: 6f04 bles 4b7fe <IMFS_memfile_read+0x56> <== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
4b7fa: 968d subl %a5,%d3
4b7fc: 6002 bras 4b800 <IMFS_memfile_read+0x58>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
4b7fe: 2608 movel %a0,%d3 <== NOT EXECUTED
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
4b800: 2f03 movel %d3,%sp@-
4b802: 4871 d800 pea %a1@(00000000,%a5:l)
4b806: 2f05 movel %d5,%sp@-
4b808: 4eb9 0004 d588 jsr 4d588 <memcpy>
IMFS_update_atime( the_jnode );
4b80e: 42a7 clrl %sp@-
4b810: 486e fff8 pea %fp@(-8)
4b814: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4b81a: 256e fff8 003c movel %fp@(-8),%a2@(60)
return my_length;
4b820: 4fef 0014 lea %sp@(20),%sp
4b824: 6000 0122 braw 4b948 <IMFS_memfile_read+0x1a0>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
4b828: 2808 movel %a0,%d4
4b82a: d88d addl %a5,%d4
if ( last_byte > the_jnode->info.file.size )
4b82c: 2204 movel %d4,%d1
4b82e: 4280 clrl %d0
4b830: 242a 004c movel %a2@(76),%d2
4b834: 262a 0050 movel %a2@(80),%d3
4b838: 2c00 movel %d0,%d6
4b83a: 2e01 movel %d1,%d7
4b83c: 9e83 subl %d3,%d7
4b83e: 9d82 subxl %d2,%d6
4b840: 6f06 bles 4b848 <IMFS_memfile_read+0xa0>
my_length = the_jnode->info.file.size - start;
4b842: 2403 movel %d3,%d2
4b844: 948d subl %a5,%d2
4b846: 6002 bras 4b84a <IMFS_memfile_read+0xa2>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
4b848: 2408 movel %a0,%d2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4b84a: 2639 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d3
4b850: 2e03 movel %d3,%d7
4b852: 5bc6 smi %d6
4b854: 49c6 extbl %d6
4b856: 2f07 movel %d7,%sp@-
4b858: 2f06 movel %d6,%sp@-
4b85a: 2f0d movel %a5,%sp@-
4b85c: 2f0c movel %a4,%sp@-
4b85e: 4eb9 0005 9744 jsr 59744 <__moddi3>
4b864: 4fef 0010 lea %sp@(16),%sp
4b868: 2801 movel %d1,%d4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4b86a: 2f07 movel %d7,%sp@-
4b86c: 2f06 movel %d6,%sp@-
4b86e: 2f0d movel %a5,%sp@-
4b870: 2f0c movel %a4,%sp@-
4b872: 4eb9 0005 92fc jsr 592fc <__divdi3>
4b878: 4fef 0010 lea %sp@(16),%sp
4b87c: 2c01 movel %d1,%d6
if ( start_offset ) {
4b87e: 4a84 tstl %d4
4b880: 673e beqs 4b8c0 <IMFS_memfile_read+0x118>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b882: 42a7 clrl %sp@-
4b884: 2f01 movel %d1,%sp@-
4b886: 2f0a movel %a2,%sp@-
4b888: 4eb9 0004 b668 jsr 4b668 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4b88e: 4fef 000c lea %sp@(12),%sp
4b892: 4a80 tstl %d0
4b894: 6700 00b0 beqw 4b946 <IMFS_memfile_read+0x19e>
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4b898: 2203 movel %d3,%d1
4b89a: 9284 subl %d4,%d1
4b89c: 2602 movel %d2,%d3
4b89e: b282 cmpl %d2,%d1
4b8a0: 6402 bccs 4b8a4 <IMFS_memfile_read+0xfc>
4b8a2: 2601 movel %d1,%d3
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4b8a4: 2f03 movel %d3,%sp@-
4b8a6: 2040 moveal %d0,%a0
4b8a8: d890 addl %a0@,%d4
dest += to_copy;
block++;
4b8aa: 5286 addql #1,%d6
my_length -= to_copy;
4b8ac: 9483 subl %d3,%d2
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4b8ae: 2f04 movel %d4,%sp@-
4b8b0: 2f05 movel %d5,%sp@-
dest += to_copy;
4b8b2: da83 addl %d3,%d5
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4b8b4: 4eb9 0004 d588 jsr 4d588 <memcpy>
dest += to_copy;
block++;
my_length -= to_copy;
4b8ba: 4fef 000c lea %sp@(12),%sp
4b8be: 6002 bras 4b8c2 <IMFS_memfile_read+0x11a>
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
4b8c0: 4283 clrl %d3
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4b8c2: 2839 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d4
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b8c8: 47f9 0004 b668 lea 4b668 <IMFS_memfile_get_block_pointer>,%a3
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b8ce: 49f9 0004 d588 lea 4d588 <memcpy>,%a4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4b8d4: 6026 bras 4b8fc <IMFS_memfile_read+0x154>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b8d6: 42a7 clrl %sp@-
4b8d8: 2f06 movel %d6,%sp@-
4b8da: 2f0a movel %a2,%sp@-
4b8dc: 4e93 jsr %a3@
if ( !block_ptr )
4b8de: 4fef 000c lea %sp@(12),%sp
4b8e2: 4a80 tstl %d0
4b8e4: 6762 beqs 4b948 <IMFS_memfile_read+0x1a0> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b8e6: 2040 moveal %d0,%a0
dest += to_copy;
block++;
4b8e8: 5286 addql #1,%d6
my_length -= to_copy;
4b8ea: 9484 subl %d4,%d2
copied += to_copy;
4b8ec: d684 addl %d4,%d3
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b8ee: 2f04 movel %d4,%sp@-
4b8f0: 2f10 movel %a0@,%sp@-
4b8f2: 2f05 movel %d5,%sp@-
dest += to_copy;
4b8f4: da84 addl %d4,%d5
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b8f6: 4e94 jsr %a4@
dest += to_copy;
block++;
my_length -= to_copy;
copied += to_copy;
4b8f8: 4fef 000c lea %sp@(12),%sp
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4b8fc: b4b9 0005 e244 cmpl 5e244 <imfs_memfile_bytes_per_block>,%d2
4b902: 64d2 bccs 4b8d6 <IMFS_memfile_read+0x12e>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
4b904: 4a82 tstl %d2
4b906: 6728 beqs 4b930 <IMFS_memfile_read+0x188>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b908: 42a7 clrl %sp@-
4b90a: 2f06 movel %d6,%sp@-
4b90c: 2f0a movel %a2,%sp@-
4b90e: 4eb9 0004 b668 jsr 4b668 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4b914: 4fef 000c lea %sp@(12),%sp
4b918: 4a80 tstl %d0
4b91a: 672c beqs 4b948 <IMFS_memfile_read+0x1a0> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4b91c: 2640 moveal %d0,%a3
copied += my_length;
4b91e: d682 addl %d2,%d3
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4b920: 2f02 movel %d2,%sp@-
4b922: 2f13 movel %a3@,%sp@-
4b924: 2f05 movel %d5,%sp@-
4b926: 4eb9 0004 d588 jsr 4d588 <memcpy>
copied += my_length;
4b92c: 4fef 000c lea %sp@(12),%sp
}
IMFS_update_atime( the_jnode );
4b930: 42a7 clrl %sp@-
4b932: 486e fff8 pea %fp@(-8)
4b936: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4b93c: 256e fff8 003c movel %fp@(-8),%a2@(60)
return copied;
4b942: 508f addql #8,%sp
4b944: 6002 bras 4b948 <IMFS_memfile_read+0x1a0>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
4b946: 4283 clrl %d3 <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
4b948: 2003 movel %d3,%d0
4b94a: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4b950: 4e5e unlk %fp <== NOT EXECUTED
0004ba16 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4ba16: 4e56 ffe4 linkw %fp,#-28
4ba1a: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
4ba1e: 2439 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d2
4ba24: e48a lsrl #2,%d2
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4ba26: 246e 0008 moveal %fp@(8),%a2
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4ba2a: 4aaa 0054 tstl %a2@(84)
4ba2e: 670e beqs 4ba3e <IMFS_memfile_remove+0x28>
memfile_free_blocks_in_table( &info->indirect, to_free );
4ba30: 2f02 movel %d2,%sp@-
4ba32: 486a 0054 pea %a2@(84)
4ba36: 4eb9 0004 b9d0 jsr 4b9d0 <memfile_free_blocks_in_table>
4ba3c: 508f addql #8,%sp
}
if ( info->doubly_indirect ) {
4ba3e: 4aaa 0058 tstl %a2@(88)
4ba42: 661c bnes 4ba60 <IMFS_memfile_remove+0x4a>
4ba44: 603c bras 4ba82 <IMFS_memfile_remove+0x6c>
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
4ba46: 2003 movel %d3,%d0
4ba48: e588 lsll #2,%d0
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
4ba4a: 206a 0058 moveal %a2@(88),%a0
4ba4e: d1c0 addal %d0,%a0
4ba50: 4a90 tstl %a0@
4ba52: 6708 beqs 4ba5c <IMFS_memfile_remove+0x46> <== NEVER TAKEN
memfile_free_blocks_in_table(
4ba54: 2f02 movel %d2,%sp@-
4ba56: 2f08 movel %a0,%sp@-
4ba58: 4e93 jsr %a3@
4ba5a: 508f addql #8,%sp
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4ba5c: 5283 addql #1,%d3
4ba5e: 6008 bras 4ba68 <IMFS_memfile_remove+0x52>
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
4ba60: 4283 clrl %d3
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
4ba62: 47f9 0004 b9d0 lea 4b9d0 <memfile_free_blocks_in_table>,%a3
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4ba68: 2039 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d0
4ba6e: e488 lsrl #2,%d0
4ba70: b083 cmpl %d3,%d0
4ba72: 62d2 bhis 4ba46 <IMFS_memfile_remove+0x30>
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
4ba74: 2f02 movel %d2,%sp@-
4ba76: 486a 0058 pea %a2@(88)
4ba7a: 4eb9 0004 b9d0 jsr 4b9d0 <memfile_free_blocks_in_table>
4ba80: 508f addql #8,%sp
}
if ( info->triply_indirect ) {
4ba82: 4aaa 005c tstl %a2@(92)
4ba86: 6642 bnes 4baca <IMFS_memfile_remove+0xb4>
4ba88: 6062 bras 4baec <IMFS_memfile_remove+0xd6>
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
4ba8a: 2c03 movel %d3,%d6
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4ba8c: 206a 005c moveal %a2@(92),%a0
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
4ba90: e58e lsll #2,%d6
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4ba92: 2a30 6800 movel %a0@(00000000,%d6:l),%d5
if ( !p ) /* ensure we have a valid pointer */
4ba96: 6746 beqs 4bade <IMFS_memfile_remove+0xc8> <== NEVER TAKEN
4ba98: 4284 clrl %d4
4ba9a: 6012 bras 4baae <IMFS_memfile_remove+0x98>
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
4ba9c: 2045 moveal %d5,%a0
4ba9e: 5885 addql #4,%d5
4baa0: 4a90 tstl %a0@
4baa2: 6708 beqs 4baac <IMFS_memfile_remove+0x96> <== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
4baa4: 2f02 movel %d2,%sp@-
4baa6: 2f08 movel %a0,%sp@-
4baa8: 4e93 jsr %a3@
4baaa: 508f addql #8,%sp
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
4baac: 5284 addql #1,%d4
4baae: 2039 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d0
4bab4: e488 lsrl #2,%d0
4bab6: b084 cmpl %d4,%d0
4bab8: 62e2 bhis 4ba9c <IMFS_memfile_remove+0x86>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
4baba: 2f02 movel %d2,%sp@-
4babc: dcaa 005c addl %a2@(92),%d6
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4bac0: 5283 addql #1,%d3
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
4bac2: 2f06 movel %d6,%sp@-
4bac4: 4e93 jsr %a3@
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4bac6: 508f addql #8,%sp
4bac8: 6008 bras 4bad2 <IMFS_memfile_remove+0xbc>
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
4baca: 4283 clrl %d3
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
4bacc: 47f9 0004 b9d0 lea 4b9d0 <memfile_free_blocks_in_table>,%a3
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4bad2: 2039 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d0
4bad8: e488 lsrl #2,%d0
4bada: b083 cmpl %d3,%d0
4badc: 62ac bhis 4ba8a <IMFS_memfile_remove+0x74>
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
4bade: 2f02 movel %d2,%sp@-
4bae0: 486a 005c pea %a2@(92)
4bae4: 4eb9 0004 b9d0 jsr 4b9d0 <memfile_free_blocks_in_table>
4baea: 508f addql #8,%sp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
4baec: 4280 clrl %d0
4baee: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
4baf4: 4e5e unlk %fp <== NOT EXECUTED
0004bc30 <IMFS_memfile_write>:
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
4bc30: 4280 clrl %d0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4bc32: 4e56 ffd0 linkw %fp,#-48
4bc36: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4bc3a: 286e 000c moveal %fp@(12),%a4
4bc3e: 2a6e 0010 moveal %fp@(16),%a5
4bc42: 246e 0008 moveal %fp@(8),%a2
4bc46: 242e 0018 movel %fp@(24),%d2
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
4bc4a: 41f5 2800 lea %a5@(00000000,%d2:l),%a0
if ( last_byte > the_jnode->info.file.size ) {
4bc4e: 2208 movel %a0,%d1
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4bc50: 262e 0014 movel %fp@(20),%d3
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
4bc54: 282a 004c movel %a2@(76),%d4
4bc58: 2a2a 0050 movel %a2@(80),%d5
4bc5c: 9a81 subl %d1,%d5
4bc5e: 9980 subxl %d0,%d4
4bc60: 6c26 bges 4bc88 <IMFS_memfile_write+0x58>
status = IMFS_memfile_extend( the_jnode, last_byte );
4bc62: 2f08 movel %a0,%sp@-
4bc64: 2f00 movel %d0,%sp@-
4bc66: 2f0a movel %a2,%sp@-
4bc68: 4eb9 0004 bb20 jsr 4bb20 <IMFS_memfile_extend>
if ( status )
4bc6e: 4fef 000c lea %sp@(12),%sp
4bc72: 4a80 tstl %d0
4bc74: 6712 beqs 4bc88 <IMFS_memfile_write+0x58>
rtems_set_errno_and_return_minus_one( ENOSPC );
4bc76: 4eb9 0004 cd68 jsr 4cd68 <__errno>
4bc7c: 741c moveq #28,%d2
4bc7e: 7aff moveq #-1,%d5
4bc80: 2040 moveal %d0,%a0
4bc82: 2082 movel %d2,%a0@
4bc84: 6000 0102 braw 4bd88 <IMFS_memfile_write+0x158>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4bc88: 2a39 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d5
4bc8e: 2e05 movel %d5,%d7
4bc90: 5bc6 smi %d6
4bc92: 49c6 extbl %d6
4bc94: 2f07 movel %d7,%sp@-
4bc96: 2f06 movel %d6,%sp@-
4bc98: 2f0d movel %a5,%sp@-
4bc9a: 2f0c movel %a4,%sp@-
4bc9c: 4eb9 0005 9744 jsr 59744 <__moddi3>
4bca2: 4fef 0010 lea %sp@(16),%sp
4bca6: 2801 movel %d1,%d4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4bca8: 2f07 movel %d7,%sp@-
4bcaa: 2f06 movel %d6,%sp@-
4bcac: 2f0d movel %a5,%sp@-
4bcae: 2f0c movel %a4,%sp@-
4bcb0: 4eb9 0005 92fc jsr 592fc <__divdi3>
4bcb6: 4fef 0010 lea %sp@(16),%sp
4bcba: 2c01 movel %d1,%d6
if ( start_offset ) {
4bcbc: 4a84 tstl %d4
4bcbe: 673a beqs 4bcfa <IMFS_memfile_write+0xca>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4bcc0: 42a7 clrl %sp@-
4bcc2: 2f01 movel %d1,%sp@-
4bcc4: 2f0a movel %a2,%sp@-
4bcc6: 4eb9 0004 b668 jsr 4b668 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4bccc: 4fef 000c lea %sp@(12),%sp
4bcd0: 4a80 tstl %d0
4bcd2: 6700 00b2 beqw 4bd86 <IMFS_memfile_write+0x156>
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4bcd6: 9a84 subl %d4,%d5
4bcd8: b485 cmpl %d5,%d2
4bcda: 6402 bccs 4bcde <IMFS_memfile_write+0xae>
4bcdc: 2a02 movel %d2,%d5
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4bcde: 2f05 movel %d5,%sp@-
4bce0: 2040 moveal %d0,%a0
src += to_copy;
block++;
4bce2: 5286 addql #1,%d6
my_length -= to_copy;
4bce4: 9485 subl %d5,%d2
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4bce6: 2f03 movel %d3,%sp@-
4bce8: d890 addl %a0@,%d4
src += to_copy;
4bcea: d685 addl %d5,%d3
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4bcec: 2f04 movel %d4,%sp@-
4bcee: 4eb9 0004 d588 jsr 4d588 <memcpy>
src += to_copy;
block++;
my_length -= to_copy;
copied += to_copy;
4bcf4: 4fef 000c lea %sp@(12),%sp
4bcf8: 6002 bras 4bcfc <IMFS_memfile_write+0xcc>
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
4bcfa: 4285 clrl %d5
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4bcfc: 2839 0005 e244 movel 5e244 <imfs_memfile_bytes_per_block>,%d4
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4bd02: 47f9 0004 b668 lea 4b668 <IMFS_memfile_get_block_pointer>,%a3
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4bd08: 49f9 0004 d588 lea 4d588 <memcpy>,%a4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4bd0e: 6026 bras 4bd36 <IMFS_memfile_write+0x106>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4bd10: 42a7 clrl %sp@-
4bd12: 2f06 movel %d6,%sp@-
4bd14: 2f0a movel %a2,%sp@-
4bd16: 4e93 jsr %a3@
if ( !block_ptr )
4bd18: 4fef 000c lea %sp@(12),%sp
4bd1c: 4a80 tstl %d0
4bd1e: 6768 beqs 4bd88 <IMFS_memfile_write+0x158> <== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4bd20: 2f04 movel %d4,%sp@-
4bd22: 2040 moveal %d0,%a0
src += to_copy;
block++;
4bd24: 5286 addql #1,%d6
my_length -= to_copy;
4bd26: 9484 subl %d4,%d2
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
4bd28: da84 addl %d4,%d5
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4bd2a: 2f03 movel %d3,%sp@-
4bd2c: 2f10 movel %a0@,%sp@-
src += to_copy;
4bd2e: d684 addl %d4,%d3
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4bd30: 4e94 jsr %a4@
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
4bd32: 4fef 000c lea %sp@(12),%sp
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4bd36: b4b9 0005 e244 cmpl 5e244 <imfs_memfile_bytes_per_block>,%d2
4bd3c: 64d2 bccs 4bd10 <IMFS_memfile_write+0xe0>
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
4bd3e: 4a82 tstl %d2
4bd40: 6728 beqs 4bd6a <IMFS_memfile_write+0x13a>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4bd42: 42a7 clrl %sp@-
4bd44: 2f06 movel %d6,%sp@-
4bd46: 2f0a movel %a2,%sp@-
4bd48: 4eb9 0004 b668 jsr 4b668 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4bd4e: 4fef 000c lea %sp@(12),%sp
4bd52: 4a80 tstl %d0
4bd54: 6732 beqs 4bd88 <IMFS_memfile_write+0x158> <== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
4bd56: 2f02 movel %d2,%sp@-
4bd58: 2040 moveal %d0,%a0
my_length = 0;
copied += to_copy;
4bd5a: da82 addl %d2,%d5
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
4bd5c: 2f03 movel %d3,%sp@-
4bd5e: 2f10 movel %a0@,%sp@-
4bd60: 4eb9 0004 d588 jsr 4d588 <memcpy>
my_length = 0;
copied += to_copy;
4bd66: 4fef 000c lea %sp@(12),%sp
}
IMFS_mtime_ctime_update( the_jnode );
4bd6a: 42a7 clrl %sp@-
4bd6c: 486e fff8 pea %fp@(-8)
4bd70: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4bd76: 202e fff8 movel %fp@(-8),%d0
return copied;
4bd7a: 508f addql #8,%sp
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
4bd7c: 2540 0040 movel %d0,%a2@(64)
4bd80: 2540 0044 movel %d0,%a2@(68)
return copied;
4bd84: 6002 bras 4bd88 <IMFS_memfile_write+0x158>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
4bd86: 4285 clrl %d5 <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4bd88: 2005 movel %d5,%d0
4bd8a: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
4bd90: 4e5e unlk %fp <== NOT EXECUTED
00042280 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
42280: 4e56 ffac linkw %fp,#-84
42284: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
42288: 246e 0008 moveal %fp@(8),%a2
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
4228c: 2f0a movel %a2,%sp@-
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
4228e: 242e 000c movel %fp@(12),%d2
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
42292: 4eb9 0004 e0d4 jsr 4e0d4 <strlen>
42298: 588f addql #4,%sp
4229a: 486e fffc pea %fp@(-4)
4229e: 486e ffbf pea %fp@(-65)
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
422a2: 262e 0010 movel %fp@(16),%d3
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
422a6: 2f00 movel %d0,%sp@-
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
422a8: 266e 0014 moveal %fp@(20),%a3
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
422ac: 2f0a movel %a2,%sp@-
422ae: 4eb9 0004 9984 jsr 49984 <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
422b4: 4fef 0010 lea %sp@(16),%sp
422b8: 2002 movel %d2,%d0
422ba: 0280 0000 f000 andil #61440,%d0
422c0: 0c80 0000 4000 cmpil #16384,%d0
422c6: 6730 beqs 422f8 <IMFS_mknod+0x78>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
422c8: 0c80 0000 8000 cmpil #32768,%d0
422ce: 672c beqs 422fc <IMFS_mknod+0x7c>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
422d0: 0c80 0000 6000 cmpil #24576,%d0
422d6: 6708 beqs 422e0 <IMFS_mknod+0x60>
422d8: 0c80 0000 2000 cmpil #8192,%d0
422de: 660c bnes 422ec <IMFS_mknod+0x6c>
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
422e0: 2d43 ffe0 movel %d3,%fp@(-32)
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
422e4: 7002 moveq #2,%d0
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
422e6: 2d4b ffe4 movel %a3,%fp@(-28)
422ea: 6016 bras 42302 <IMFS_mknod+0x82>
} else if (S_ISFIFO(mode))
422ec: 0c80 0000 1000 cmpil #4096,%d0
422f2: 670c beqs 42300 <IMFS_mknod+0x80> <== ALWAYS TAKEN
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
IMFS_token_types type = 0;
422f4: 4280 clrl %d0 <== NOT EXECUTED
422f6: 600a bras 42302 <IMFS_mknod+0x82> <== NOT EXECUTED
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
422f8: 7001 moveq #1,%d0
422fa: 6006 bras 42302 <IMFS_mknod+0x82>
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
422fc: 7005 moveq #5,%d0
422fe: 6002 bras 42302 <IMFS_mknod+0x82>
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
} else if (S_ISFIFO(mode))
type = IMFS_FIFO;
42300: 7007 moveq #7,%d0
* was ONLY passed a NULL when we created the root node. We
* added a new IMFS_create_root_node() so this path no longer
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
42302: 486e ffe0 pea %fp@(-32)
42306: 2f02 movel %d2,%sp@-
42308: 486e ffbf pea %fp@(-65)
4230c: 2f00 movel %d0,%sp@-
4230e: 2f2e 0018 movel %fp@(24),%sp@-
42312: 4eb9 0004 8fa6 jsr 48fa6 <IMFS_create_node>
if ( !new_node )
42318: 4fef 0014 lea %sp@(20),%sp
* was ONLY passed a NULL when we created the root node. We
* added a new IMFS_create_root_node() so this path no longer
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
4231c: 2440 moveal %d0,%a2
if ( !new_node )
4231e: 4a80 tstl %d0
42320: 6610 bnes 42332 <IMFS_mknod+0xb2>
rtems_set_errno_and_return_minus_one( ENOMEM );
42322: 4eb9 0004 cd68 jsr 4cd68 <__errno>
42328: 2040 moveal %d0,%a0
4232a: 700c moveq #12,%d0
4232c: 2080 movel %d0,%a0@
4232e: 70ff moveq #-1,%d0
42330: 6034 bras 42366 <IMFS_mknod+0xe6>
IMFS_update_ctime(new_node->Parent);
42332: 42a7 clrl %sp@-
42334: 240e movel %fp,%d2
42336: 0682 ffff fff4 addil #-12,%d2
4233c: 47f9 0004 2bf0 lea 42bf0 <gettimeofday>,%a3
42342: 2f02 movel %d2,%sp@-
42344: 4e93 jsr %a3@
42346: 206a 0008 moveal %a2@(8),%a0
4234a: 216e fff4 0044 movel %fp@(-12),%a0@(68)
IMFS_update_mtime(new_node->Parent);
42350: 42a7 clrl %sp@-
42352: 2f02 movel %d2,%sp@-
42354: 4e93 jsr %a3@
42356: 206a 0008 moveal %a2@(8),%a0
return 0;
4235a: 4fef 0010 lea %sp@(16),%sp
4235e: 4280 clrl %d0
new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
IMFS_update_ctime(new_node->Parent);
IMFS_update_mtime(new_node->Parent);
42360: 216e fff4 0040 movel %fp@(-12),%a0@(64)
return 0;
}
42366: 4cee 0c0c ffac moveml %fp@(-84),%d2-%d3/%a2-%a3
4236c: 4e5e unlk %fp <== NOT EXECUTED
00042370 <IMFS_mount>:
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
42370: 7001 moveq #1,%d0
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
42372: 4e56 0000 linkw %fp,#0
42376: 226e 0008 moveal %fp@(8),%a1
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
4237a: 2069 0008 moveal %a1@(8),%a0
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
4237e: b0a8 0048 cmpl %a0@(72),%d0
42382: 6710 beqs 42394 <IMFS_mount+0x24> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
42384: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
4238a: 2040 moveal %d0,%a0 <== NOT EXECUTED
4238c: 7014 moveq #20,%d0 <== NOT EXECUTED
4238e: 2080 movel %d0,%a0@ <== NOT EXECUTED
42390: 70ff moveq #-1,%d0 <== NOT EXECUTED
42392: 6006 bras 4239a <IMFS_mount+0x2a> <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
42394: 2149 0058 movel %a1,%a0@(88)
return 0;
42398: 4280 clrl %d0
}
4239a: 4e5e unlk %fp
...
00044998 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
44998: 4e56 0000 linkw %fp,#0
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4499c: 2079 0006 2f88 moveal 62f88 <_impure_ptr>,%a0
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
449a2: 2f0a movel %a2,%sp@-
449a4: 246e 0008 moveal %fp@(8),%a2
449a8: 2f02 movel %d2,%sp@-
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
449aa: 2f28 0008 movel %a0@(8),%sp@-
switch( the_jnode->type ) {
449ae: 7406 moveq #6,%d2
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
449b0: 486a 000c pea %a2@(12)
449b4: 4eb9 0005 0fd0 jsr 50fd0 <fputs>
switch( the_jnode->type ) {
449ba: 202a 0048 movel %a2@(72),%d0
449be: 2200 movel %d0,%d1
449c0: 508f addql #8,%sp
449c2: 5381 subql #1,%d1
449c4: 2079 0006 2f88 moveal 62f88 <_impure_ptr>,%a0
449ca: b481 cmpl %d1,%d2
449cc: 6500 0096 bcsw 44a64 <IMFS_print_jnode+0xcc>
449d0: 303b 1a08 movew %pc@(449da <IMFS_print_jnode+0x42>,%d1:l:2),%d0
449d4: 48c0 extl %d0
449d6: 4efb 0802 jmp %pc@(449da <IMFS_print_jnode+0x42>,%d0:l)
449da: 000e .short 0x000e <== NOT EXECUTED
449dc: 0022 .short 0x0022 <== NOT EXECUTED
449de: 006a .short 0x006a <== NOT EXECUTED
449e0: 006a .short 0x006a <== NOT EXECUTED
449e2: 0050 .short 0x0050 <== NOT EXECUTED
449e4: 0032 .short 0x0032 <== NOT EXECUTED
449e6: 0076 .short 0x0076 <== NOT EXECUTED
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
449e8: 2f28 0008 movel %a0@(8),%sp@-
449ec: 4878 002f pea 2f <OPER2+0x1b>
449f0: 4eb9 0005 0f00 jsr 50f00 <fputc>
break;
449f6: 508f addql #8,%sp
449f8: 6000 0082 braw 44a7c <IMFS_print_jnode+0xe4>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
449fc: 2f2a 0050 movel %a2@(80),%sp@-
44a00: 2f2a 004c movel %a2@(76),%sp@-
44a04: 4879 0006 15e5 pea 615e5 <map.6435+0x11>
44a0a: 600e bras 44a1a <IMFS_print_jnode+0x82>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
44a0c: 2f2a 0054 movel %a2@(84),%sp@-
44a10: 2f2a 0050 movel %a2@(80),%sp@-
44a14: 4879 0006 15f8 pea 615f8 <map.6435+0x24>
44a1a: 2f28 0008 movel %a0@(8),%sp@-
44a1e: 4eb9 0005 0e82 jsr 50e82 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
44a24: 4fef 0010 lea %sp@(16),%sp
44a28: 6052 bras 44a7c <IMFS_print_jnode+0xe4>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
44a2a: 2f2a 0050 movel %a2@(80),%sp@-
44a2e: 4879 0006 1607 pea 61607 <map.6435+0x33>
44a34: 2f28 0008 movel %a0@(8),%sp@-
44a38: 4eb9 0005 0e82 jsr 50e82 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
44a3e: 4fef 000c lea %sp@(12),%sp
44a42: 6038 bras 44a7c <IMFS_print_jnode+0xe4>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
44a44: 2f28 0008 movel %a0@(8),%sp@-
44a48: 4879 0006 1613 pea 61613 <map.6435+0x3f>
44a4e: 600a bras 44a5a <IMFS_print_jnode+0xc2>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
44a50: 2f28 0008 movel %a0@(8),%sp@-
44a54: 4879 0006 1627 pea 61627 <map.6435+0x53>
44a5a: 4eb9 0005 0fd0 jsr 50fd0 <fputs>
return;
44a60: 508f addql #8,%sp
44a62: 6032 bras 44a96 <IMFS_print_jnode+0xfe>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
44a64: 2f00 movel %d0,%sp@- <== NOT EXECUTED
44a66: 4879 0006 163a pea 6163a <map.6435+0x66> <== NOT EXECUTED
44a6c: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
44a70: 4eb9 0005 0e82 jsr 50e82 <fprintf> <== NOT EXECUTED
return;
44a76: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44a7a: 601a bras 44a96 <IMFS_print_jnode+0xfe> <== NOT EXECUTED
}
puts("");
}
44a7c: 242e fff8 movel %fp@(-8),%d2
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44a80: 203c 0006 1cee movel #400622,%d0
}
44a86: 246e fffc moveal %fp@(-4),%a2
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44a8a: 2d40 0008 movel %d0,%fp@(8)
}
44a8e: 4e5e unlk %fp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44a90: 4ef9 0005 2752 jmp 52752 <puts>
}
44a96: 242e fff8 movel %fp@(-8),%d2
44a9a: 246e fffc moveal %fp@(-4),%a2
44a9e: 4e5e unlk %fp <== NOT EXECUTED
000423e8 <IMFS_rename>:
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
423e8: 4e56 fff8 linkw %fp,#-8
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
423ec: 206e 000c moveal %fp@(12),%a0
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
423f0: 2f0a movel %a2,%sp@-
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
423f2: 2450 moveal %a0@,%a2
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
423f4: 4878 0020 pea 20 <OPER2+0xc>
423f8: 2f2e 0014 movel %fp@(20),%sp@-
423fc: 486a 000c pea %a2@(12)
42400: 4eb9 0004 e0f0 jsr 4e0f0 <strncpy>
if ( the_jnode->Parent != NULL )
42406: 4fef 000c lea %sp@(12),%sp
4240a: 4aaa 0008 tstl %a2@(8)
4240e: 670a beqs 4241a <IMFS_rename+0x32> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
42410: 2f0a movel %a2,%sp@-
42412: 4eb9 0004 63ec jsr 463ec <_Chain_Extract>
42418: 588f addql #4,%sp
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
4241a: 206e 0010 moveal %fp@(16),%a0
4241e: 2050 moveal %a0@,%a0
the_jnode->Parent = new_parent;
42420: 2548 0008 movel %a0,%a2@(8)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
42424: 2f0a movel %a2,%sp@-
42426: 4868 004c pea %a0@(76)
4242a: 4eb9 0004 63b4 jsr 463b4 <_Chain_Append>
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
42430: 42a7 clrl %sp@-
42432: 486e fff8 pea %fp@(-8)
42436: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4243c: 256e fff8 0044 movel %fp@(-8),%a2@(68)
return 0;
}
42442: 4280 clrl %d0
42444: 246e fff4 moveal %fp@(-12),%a2
42448: 4e5e unlk %fp <== NOT EXECUTED
000490f4 <IMFS_skip_separator>:
static void IMFS_skip_separator (
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
490f4: 4e56 fff0 linkw %fp,#-16
490f8: 48d7 3c00 moveml %a2-%a5,%sp@
490fc: 286e 0008 moveal %fp@(8),%a4
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
49100: 4bf9 0004 38a4 lea 438a4 <rtems_filesystem_is_separator>,%a5
static void IMFS_skip_separator (
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
49106: 266e 000c moveal %fp@(12),%a3
4910a: 246e 0010 moveal %fp@(16),%a2
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
4910e: 6008 bras 49118 <IMFS_skip_separator+0x24>
++(*index);
49110: 5281 addql #1,%d1
--(*len);
49112: 5380 subql #1,%d0
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
++(*index);
49114: 2481 movel %d1,%a2@
--(*len);
49116: 2680 movel %d0,%a3@
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
49118: 2012 movel %a2@,%d0
4911a: 1034 0800 moveb %a4@(00000000,%d0:l),%d0
4911e: 49c0 extbl %d0
49120: 2f00 movel %d0,%sp@-
49122: 4e95 jsr %a5@
49124: 588f addql #4,%sp
49126: 4a80 tstl %d0
49128: 670c beqs 49136 <IMFS_skip_separator+0x42>
4912a: 2212 movel %a2@,%d1
4912c: 4a34 1800 tstb %a4@(00000000,%d1:l)
49130: 6704 beqs 49136 <IMFS_skip_separator+0x42>
49132: 2013 movel %a3@,%d0
49134: 66da bnes 49110 <IMFS_skip_separator+0x1c> <== ALWAYS TAKEN
++(*index);
--(*len);
}
}
49136: 4cee 3c00 fff0 moveml %fp@(-16),%a2-%a5
4913c: 4e5e unlk %fp <== NOT EXECUTED
00049b14 <IMFS_stat>:
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
49b14: 7205 moveq #5,%d1
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
49b16: 4e56 0000 linkw %fp,#0
49b1a: 206e 000c moveal %fp@(12),%a0
49b1e: 2f0a movel %a2,%sp@-
49b20: 246e 0008 moveal %fp@(8),%a2
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
49b24: 2252 moveal %a2@,%a1
switch ( the_jnode->type ) {
49b26: 2029 0048 movel %a1@(72),%d0
49b2a: 5580 subql #2,%d0
49b2c: b280 cmpl %d0,%d1
49b2e: 653e bcss 49b6e <IMFS_stat+0x5a> <== NEVER TAKEN
49b30: 303b 0a08 movew %pc@(49b3a <IMFS_stat+0x26>,%d0:l:2),%d0
49b34: 48c0 extl %d0
49b36: 4efb 0802 jmp %pc@(49b3a <IMFS_stat+0x26>,%d0:l)
49b3a: 000c .short 0x000c <== NOT EXECUTED
49b3c: 0034 .short 0x0034 <== NOT EXECUTED
49b3e: 0026 .short 0x0026 <== NOT EXECUTED
49b40: 001c .short 0x001c <== NOT EXECUTED
49b42: 001c .short 0x001c <== NOT EXECUTED
49b44: 0026 .short 0x0026 <== NOT EXECUTED
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
49b46: 2029 0050 movel %a1@(80),%d0
49b4a: 2169 004c 0016 movel %a1@(76),%a0@(22)
49b50: 2140 001a movel %d0,%a0@(26)
break;
49b54: 602a bras 49b80 <IMFS_stat+0x6c>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
49b56: 2029 004c movel %a1@(76),%d0
49b5a: 2229 0050 movel %a1@(80),%d1
49b5e: 6004 bras 49b64 <IMFS_stat+0x50>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
49b60: 4280 clrl %d0
49b62: 4281 clrl %d1
49b64: 2140 001e movel %d0,%a0@(30)
49b68: 2141 0022 movel %d1,%a0@(34)
break;
49b6c: 6012 bras 49b80 <IMFS_stat+0x6c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
49b6e: 4eb9 0004 cd68 jsr 4cd68 <__errno>
49b74: 2040 moveal %d0,%a0
49b76: 70ff moveq #-1,%d0
49b78: 20bc 0000 0086 movel #134,%a0@
49b7e: 6050 bras 49bd0 <IMFS_stat+0xbc>
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
49b80: 246a 0010 moveal %a2@(16),%a2
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
49b84: 246a 0034 moveal %a2@(52),%a2
49b88: 2012 movel %a2@,%d0
buf->st_mode = the_jnode->st_mode;
49b8a: 2169 002e 000c movel %a1@(46),%a0@(12)
buf->st_nlink = the_jnode->st_nlink;
49b90: 3169 0032 0010 movew %a1@(50),%a0@(16)
buf->st_ino = the_jnode->st_ino;
49b96: 2169 0034 0008 movel %a1@(52),%a0@(8)
buf->st_uid = the_jnode->st_uid;
49b9c: 3169 0038 0012 movew %a1@(56),%a0@(18)
buf->st_gid = the_jnode->st_gid;
49ba2: 3169 003a 0014 movew %a1@(58),%a0@(20)
buf->st_atime = the_jnode->stat_atime;
49ba8: 2169 003c 0026 movel %a1@(60),%a0@(38)
buf->st_mtime = the_jnode->stat_mtime;
49bae: 2169 0040 002e movel %a1@(64),%a0@(46)
buf->st_ctime = the_jnode->stat_ctime;
49bb4: 2169 0044 0036 movel %a1@(68),%a0@(54)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
49bba: 43f9 0005 d2de lea 5d2de <imfs_rq_memfile_bytes_per_block>,%a1
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
49bc0: 2140 0004 movel %d0,%a0@(4)
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
49bc4: 2151 003e movel %a1@,%a0@(62)
return 0;
49bc8: 4280 clrl %d0
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
49bca: 20bc 0000 fffe movel #65534,%a0@
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
return 0;
}
49bd0: 246e fffc moveal %fp@(-4),%a2
49bd4: 4e5e unlk %fp <== NOT EXECUTED
000424e8 <IMFS_unlink>:
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
424e8: 7003 moveq #3,%d0
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
424ea: 4e56 ffd0 linkw %fp,#-48
424ee: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
424f2: 246e 000c moveal %fp@(12),%a2
424f6: 262e 0008 movel %fp@(8),%d3
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
424fa: 2652 moveal %a2@,%a3
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
424fc: b0ab 0048 cmpl %a3@(72),%d0
42500: 6600 0082 bnew 42584 <IMFS_unlink+0x9c>
if ( !node->info.hard_link.link_node )
42504: 282b 004c movel %a3@(76),%d4
42508: 660e bnes 42518 <IMFS_unlink+0x30> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
4250a: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
42510: 2040 moveal %d0,%a0 <== NOT EXECUTED
42512: 7016 moveq #22,%d0 <== NOT EXECUTED
42514: 2080 movel %d0,%a0@ <== NOT EXECUTED
42516: 607e bras 42596 <IMFS_unlink+0xae> <== NOT EXECUTED
the_link = *loc;
42518: 4878 0014 pea 14 <OPER2>
4251c: 240e movel %fp,%d2
4251e: 0682 ffff ffe4 addil #-28,%d2
42524: 2f0a movel %a2,%sp@-
42526: 2f02 movel %d2,%sp@-
42528: 4eb9 0004 d588 jsr 4d588 <memcpy>
the_link.node_access = node->info.hard_link.link_node;
4252e: 2d44 ffe4 movel %d4,%fp@(-28)
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
42532: 7801 moveq #1,%d4
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
42534: 2f02 movel %d2,%sp@-
42536: 4eb9 0004 9140 jsr 49140 <IMFS_Set_handlers>
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
4253c: 206b 004c moveal %a3@(76),%a0
42540: 4281 clrl %d1
42542: 4fef 0010 lea %sp@(16),%sp
42546: 3028 0032 movew %a0@(50),%d0
4254a: 3200 movew %d0,%d1
4254c: b881 cmpl %d1,%d4
4254e: 6616 bnes 42566 <IMFS_unlink+0x7e>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
42550: 2f02 movel %d2,%sp@-
42552: 206e ffec moveal %fp@(-20),%a0
42556: 2f03 movel %d3,%sp@-
42558: 2068 0034 moveal %a0@(52),%a0
4255c: 4e90 jsr %a0@
if ( result != 0 )
4255e: 508f addql #8,%sp
42560: 4a80 tstl %d0
42562: 6720 beqs 42584 <IMFS_unlink+0x9c>
42564: 6030 bras 42596 <IMFS_unlink+0xae>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
42566: 5380 subql #1,%d0
42568: 3140 0032 movew %d0,%a0@(50)
IMFS_update_ctime( node->info.hard_link.link_node );
4256c: 42a7 clrl %sp@-
4256e: 486e fff8 pea %fp@(-8)
42572: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
42578: 206b 004c moveal %a3@(76),%a0
4257c: 508f addql #8,%sp
4257e: 216e fff8 0044 movel %fp@(-8),%a0@(68)
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
42584: 206a 0008 moveal %a2@(8),%a0
42588: 2f0a movel %a2,%sp@-
4258a: 2f03 movel %d3,%sp@-
4258c: 2068 0034 moveal %a0@(52),%a0
42590: 4e90 jsr %a0@
return result;
42592: 508f addql #8,%sp
42594: 6002 bras 42598 <IMFS_unlink+0xb0>
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
if ( result != 0 )
return -1;
42596: 70ff moveq #-1,%d0
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
return result;
}
42598: 4cee 0c1c ffd0 moveml %fp@(-48),%d2-%d4/%a2-%a3
4259e: 4e5e unlk %fp
...
000425a4 <IMFS_unmount>:
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
425a4: 7001 moveq #1,%d0
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
425a6: 4e56 0000 linkw %fp,#0
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
425aa: 206e 0008 moveal %fp@(8),%a0
425ae: 2068 0008 moveal %a0@(8),%a0
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
425b2: b0a8 0048 cmpl %a0@(72),%d0
425b6: 670e beqs 425c6 <IMFS_unmount+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
425b8: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
425be: 7214 moveq #20,%d1 <== NOT EXECUTED
425c0: 2040 moveal %d0,%a0 <== NOT EXECUTED
425c2: 2081 movel %d1,%a0@ <== NOT EXECUTED
425c4: 6012 bras 425d8 <IMFS_unmount+0x34> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
425c6: 4aa8 0058 tstl %a0@(88)
425ca: 6610 bnes 425dc <IMFS_unmount+0x38> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
425cc: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
425d2: 2040 moveal %d0,%a0 <== NOT EXECUTED
425d4: 7016 moveq #22,%d0 <== NOT EXECUTED
425d6: 2080 movel %d0,%a0@ <== NOT EXECUTED
425d8: 70ff moveq #-1,%d0 <== NOT EXECUTED
425da: 6006 bras 425e2 <IMFS_unmount+0x3e> <== NOT EXECUTED
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
425dc: 42a8 0058 clrl %a0@(88)
return 0;
425e0: 4280 clrl %d0
}
425e2: 4e5e unlk %fp
...
000424a0 <Stack_check_Dump_threads_usage>:
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
424a0: 70ff moveq #-1,%d0 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
424a2: 4e56 ffe0 linkw %fp,#-32 <== NOT EXECUTED
424a6: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@ <== NOT EXECUTED
424aa: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
424ae: b08a cmpl %a2,%d0 <== NOT EXECUTED
424b0: 6616 bnes 424c8 <Stack_check_Dump_threads_usage+0x28><== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
424b2: 4ab9 0006 1228 tstl 61228 <Stack_check_Interrupt_stack+0x4><== NOT EXECUTED
424b8: 6700 00f8 beqw 425b2 <Stack_check_Dump_threads_usage+0x112><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
424bc: 49f9 0006 1224 lea 61224 <Stack_check_Interrupt_stack>,%a4 <== NOT EXECUTED
the_thread = 0;
current = 0;
424c2: 4283 clrl %d3 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
424c4: 95ca subal %a2,%a2 <== NOT EXECUTED
424c6: 6008 bras 424d0 <Stack_check_Dump_threads_usage+0x30><== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
424c8: 262a 00f2 movel %a2@(242),%d3 <== NOT EXECUTED
the_thread = 0;
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
424cc: 49ea 00b2 lea %a2@(178),%a4 <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
424d0: 2414 movel %a4@,%d2 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
424d2: 70fc moveq #-4,%d0 <== NOT EXECUTED
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
424d4: 0682 ffff fff0 addil #-16,%d2 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
424da: 226c 0004 moveal %a4@(4),%a1 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
424de: 41e9 0020 lea %a1@(32),%a0 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
424e2: c082 andl %d2,%d0 <== NOT EXECUTED
424e4: d088 addl %a0,%d0 <== NOT EXECUTED
424e6: 600c bras 424f4 <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
if (*base != U32_PATTERN)
424e8: 223c a5a5 a5a5 movel #-1515870811,%d1 <== NOT EXECUTED
424ee: b290 cmpl %a0@,%d1 <== NOT EXECUTED
424f0: 6608 bnes 424fa <Stack_check_Dump_threads_usage+0x5a><== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
424f2: 5888 addql #4,%a0 <== NOT EXECUTED
424f4: b088 cmpl %a0,%d0 <== NOT EXECUTED
424f6: 62f0 bhis 424e8 <Stack_check_Dump_threads_usage+0x48><== NOT EXECUTED
424f8: 600c bras 42506 <Stack_check_Dump_threads_usage+0x66><== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
424fa: 4a88 tstl %a0 <== NOT EXECUTED
424fc: 6708 beqs 42506 <Stack_check_Dump_threads_usage+0x66><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
424fe: 47f1 2810 lea %a1@(00000010,%d2:l),%a3 <== NOT EXECUTED
42502: 97c8 subal %a0,%a3 <== NOT EXECUTED
42504: 6002 bras 42508 <Stack_check_Dump_threads_usage+0x68><== NOT EXECUTED
else
used = 0;
42506: 97cb subal %a3,%a3 <== NOT EXECUTED
42508: 2a79 0006 0a0c moveal 60a0c <print_handler>,%a5 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
4250e: 4a8a tstl %a2 <== NOT EXECUTED
42510: 672c beqs 4253e <Stack_check_Dump_threads_usage+0x9e><== NOT EXECUTED
#endif
{
(*print_handler)(
42512: 486e fffb pea %fp@(-5) <== NOT EXECUTED
42516: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
4251a: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4251e: 4eb9 0004 7cd0 jsr 47cd0 <rtems_object_get_name> <== NOT EXECUTED
42524: 2f00 movel %d0,%sp@- <== NOT EXECUTED
42526: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4252a: 4879 0005 e381 pea 5e381 <map.6435+0x11> <== NOT EXECUTED
42530: 2f39 0006 0a10 movel 60a10 <print_context>,%sp@- <== NOT EXECUTED
42536: 4e95 jsr %a5@ <== NOT EXECUTED
42538: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4253c: 6016 bras 42554 <Stack_check_Dump_threads_usage+0xb4><== NOT EXECUTED
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
}
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
4253e: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
42542: 4879 0005 e38e pea 5e38e <map.6435+0x1e> <== NOT EXECUTED
42548: 2f39 0006 0a10 movel 60a10 <print_context>,%sp@- <== NOT EXECUTED
4254e: 4e95 jsr %a5@ <== NOT EXECUTED
42550: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
42554: 206c 0004 moveal %a4@(4),%a0 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
42558: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4255a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
4255c: 2014 movel %a4@,%d0 <== NOT EXECUTED
4255e: 5380 subql #1,%d0 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
42560: 4870 0800 pea %a0@(00000000,%d0:l) <== NOT EXECUTED
42564: 2f08 movel %a0,%sp@- <== NOT EXECUTED
42566: 4879 0005 e39c pea 5e39c <map.6435+0x2c> <== NOT EXECUTED
4256c: 2f39 0006 0a10 movel 60a10 <print_context>,%sp@- <== NOT EXECUTED
42572: 2079 0006 0a0c moveal 60a0c <print_handler>,%a0 <== NOT EXECUTED
42578: 4e90 jsr %a0@ <== NOT EXECUTED
4257a: 2079 0006 0a0c moveal 60a0c <print_handler>,%a0 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
42580: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
42584: 4ab9 0006 0a08 tstl 60a08 <Stack_check_Initialized> <== NOT EXECUTED
4258a: 6612 bnes 4259e <Stack_check_Dump_threads_usage+0xfe><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
4258c: 4879 0005 e3ba pea 5e3ba <map.6435+0x4a> <== NOT EXECUTED
42592: 2f39 0006 0a10 movel 60a10 <print_context>,%sp@- <== NOT EXECUTED
42598: 4e90 jsr %a0@ <== NOT EXECUTED
4259a: 508f addql #8,%sp <== NOT EXECUTED
4259c: 6014 bras 425b2 <Stack_check_Dump_threads_usage+0x112><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
4259e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
425a0: 4879 0005 e3c7 pea 5e3c7 <map.6435+0x57> <== NOT EXECUTED
425a6: 2f39 0006 0a10 movel 60a10 <print_context>,%sp@- <== NOT EXECUTED
425ac: 4e90 jsr %a0@ <== NOT EXECUTED
425ae: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
}
425b2: 4cee 3c0c ffe0 moveml %fp@(-32),%d2-%d3/%a2-%a5 <== NOT EXECUTED
425b8: 4e5e unlk %fp <== NOT EXECUTED
000425bc <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
425bc: 4e56 0000 linkw %fp,#0
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
425c0: 4ab9 0006 0a08 tstl 60a08 <Stack_check_Initialized>
425c6: 6668 bnes 42630 <Stack_check_Initialize+0x74>
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
425c8: 203c feed f00d movel #-17960947,%d0
425ce: 23c0 0006 1214 movel %d0,61214 <Stack_check_Pattern>
425d4: 203c 0bad 0d06 movel #195890438,%d0
425da: 23c0 0006 1218 movel %d0,61218 <Stack_check_Pattern+0x4>
425e0: 203c dead f00d movel #-559026163,%d0
425e6: 23c0 0006 121c movel %d0,6121c <Stack_check_Pattern+0x8>
425ec: 203c 600d 0d06 movel #1611468038,%d0
425f2: 23c0 0006 1220 movel %d0,61220 <Stack_check_Pattern+0xc>
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
425f8: 2039 0006 1846 movel 61846 <_Per_CPU_Information>,%d0
425fe: 6728 beqs 42628 <Stack_check_Initialize+0x6c> <== NEVER TAKEN
42600: 2239 0006 184a movel 6184a <_Per_CPU_Information+0x4>,%d1
42606: 6720 beqs 42628 <Stack_check_Initialize+0x6c> <== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
42608: 9280 subl %d0,%d1
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
4260a: 2f01 movel %d1,%sp@-
4260c: 4878 00a5 pea a5 <DBL_MANT_DIG+0x70>
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
42610: 23c0 0006 1228 movel %d0,61228 <Stack_check_Interrupt_stack+0x4>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
42616: 2f00 movel %d0,%sp@-
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
42618: 23c1 0006 1224 movel %d1,61224 <Stack_check_Interrupt_stack>
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
4261e: 4eb9 0004 fad4 jsr 4fad4 <memset>
42624: 4fef 000c lea %sp@(12),%sp
}
#endif
Stack_check_Initialized = 1;
42628: 7001 moveq #1,%d0
4262a: 23c0 0006 0a08 movel %d0,60a08 <Stack_check_Initialized>
}
42630: 4e5e unlk %fp <== NOT EXECUTED
00042696 <Stack_check_report_blown_task>:
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
42696: 4e56 ffd0 linkw %fp,#-48 <== NOT EXECUTED
4269a: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED
4269e: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
426a2: 45f9 0004 4384 lea 44384 <printk>,%a2 <== NOT EXECUTED
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
426a8: 286b 00b6 moveal %a3@(182),%a4 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
426ac: 4879 0005 e3cd pea 5e3cd <map.6435+0x5d> <== NOT EXECUTED
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
426b2: 142e 000f moveb %fp@(15),%d2 <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
426b6: 4e92 jsr %a2@ <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
426b8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
426ba: 4879 0005 e3dd pea 5e3dd <map.6435+0x6d> <== NOT EXECUTED
426c0: 4e92 jsr %a2@ <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
426c2: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
426c6: 4879 0005 e3fa pea 5e3fa <map.6435+0x8a> <== NOT EXECUTED
426cc: 4e92 jsr %a2@ <== NOT EXECUTED
printk(
426ce: 2f2b 000c movel %a3@(12),%sp@- <== NOT EXECUTED
426d2: 4879 0005 e40c pea 5e40c <map.6435+0x9c> <== NOT EXECUTED
426d8: 4e92 jsr %a2@ <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
426da: 486e ffe0 pea %fp@(-32) <== NOT EXECUTED
426de: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
426e2: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
426e6: 4eb9 0004 7cd0 jsr 47cd0 <rtems_object_get_name> <== NOT EXECUTED
426ec: 4fef 0024 lea %sp@(36),%sp <== NOT EXECUTED
426f0: 2e80 movel %d0,%sp@ <== NOT EXECUTED
426f2: 4879 0005 e420 pea 5e420 <map.6435+0xb0> <== NOT EXECUTED
426f8: 4e92 jsr %a2@ <== NOT EXECUTED
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
426fa: 206b 00b6 moveal %a3@(182),%a0 <== NOT EXECUTED
426fe: 202b 00b2 movel %a3@(178),%d0 <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
42702: 4870 0800 pea %a0@(00000000,%d0:l) <== NOT EXECUTED
42706: 2f08 movel %a0,%sp@- <== NOT EXECUTED
42708: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4270a: 4879 0005 e436 pea 5e436 <map.6435+0xc6> <== NOT EXECUTED
42710: 4e92 jsr %a2@ <== NOT EXECUTED
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
42712: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
42716: 4a02 tstb %d2 <== NOT EXECUTED
42718: 6618 bnes 42732 <Stack_check_report_blown_task+0x9c><== NOT EXECUTED
printk(
4271a: 486c 0018 pea %a4@(24) <== NOT EXECUTED
4271e: 486c 0008 pea %a4@(8) <== NOT EXECUTED
42722: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
42726: 4879 0005 e467 pea 5e467 <map.6435+0xf7> <== NOT EXECUTED
4272c: 4e92 jsr %a2@ <== NOT EXECUTED
4272e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
42732: 4878 0081 pea 81 <DBL_MANT_DIG+0x4c> <== NOT EXECUTED
42736: 4eb9 0004 850c jsr 4850c <rtems_fatal_error_occurred> <== NOT EXECUTED
0004af78 <TOD_MICROSECONDS_TO_TICKS>:
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
microseconds_per_tick = rtems_configuration_get_microseconds_per_tick();
ticks = microseconds / microseconds_per_tick;
4af78: 41f9 0006 1df8 lea 61df8 <Configuration+0xc>,%a0
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
4af7e: 4e56 0000 linkw %fp,#0
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
microseconds_per_tick = rtems_configuration_get_microseconds_per_tick();
ticks = microseconds / microseconds_per_tick;
4af82: 202e 0008 movel %fp@(8),%d0
4af86: 4c50 0001 remul %a0@,%d1,%d0
4af8a: 4c50 0000 remul %a0@,%d0,%d0
if ( (microseconds % microseconds_per_tick) != 0 )
4af8e: 4a81 tstl %d1
4af90: 6702 beqs 4af94 <TOD_MICROSECONDS_TO_TICKS+0x1c> <== ALWAYS TAKEN
ticks += 1;
4af92: 5280 addql #1,%d0 <== NOT EXECUTED
return ticks;
}
4af94: 4e5e unlk %fp <== NOT EXECUTED
00046e08 <TOD_MILLISECONDS_TO_TICKS>:
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
46e08: 4e56 0000 linkw %fp,#0
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick();
46e0c: 2039 0005 e0d8 movel 5e0d8 <Configuration+0xc>,%d0
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
46e12: 2f02 movel %d2,%sp@-
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick();
46e14: 243c 0000 03e8 movel #1000,%d2
46e1a: 4c42 0000 remul %d2,%d0,%d0
ticks = milliseconds / milliseconds_per_tick;
46e1e: 242e 0008 movel %fp@(8),%d2
46e22: 4c40 2001 remul %d0,%d1,%d2
46e26: 4c40 2002 remul %d0,%d2,%d2
46e2a: 2002 movel %d2,%d0
if ( (milliseconds % milliseconds_per_tick) != 0 )
46e2c: 4a81 tstl %d1
46e2e: 6702 beqs 46e32 <TOD_MILLISECONDS_TO_TICKS+0x2a> <== ALWAYS TAKEN
ticks += 1;
46e30: 5280 addql #1,%d0 <== NOT EXECUTED
return ticks;
}
46e32: 241f movel %sp@+,%d2
46e34: 4e5e unlk %fp <== NOT EXECUTED
000484ac <_CORE_RWLock_Release>:
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
484ac: 223c 0000 0700 movel #1792,%d1
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
484b2: 4e56 fff0 linkw %fp,#-16
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
484b6: 2079 0006 19ce moveal 619ce <_Per_CPU_Information+0xc>,%a0
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
484bc: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
484c0: 246e 0008 moveal %fp@(8),%a2
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
484c4: 40c0 movew %sr,%d0
484c6: 8280 orl %d0,%d1
484c8: 46c1 movew %d1,%sr
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
484ca: 222a 0044 movel %a2@(68),%d1
484ce: 660a bnes 484da <_CORE_RWLock_Release+0x2e>
_ISR_Enable( level );
484d0: 46c0 movew %d0,%sr
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
484d2: 7002 moveq #2,%d0
484d4: 2140 0034 movel %d0,%a0@(52)
return CORE_RWLOCK_SUCCESSFUL;
484d8: 6078 bras 48552 <_CORE_RWLock_Release+0xa6>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
484da: 7401 moveq #1,%d2
484dc: b481 cmpl %d1,%d2
484de: 6610 bnes 484f0 <_CORE_RWLock_Release+0x44>
the_rwlock->number_of_readers -= 1;
484e0: 222a 0048 movel %a2@(72),%d1
484e4: 5381 subql #1,%d1
484e6: 2541 0048 movel %d1,%a2@(72)
if ( the_rwlock->number_of_readers != 0 ) {
484ea: 6704 beqs 484f0 <_CORE_RWLock_Release+0x44>
/* must be unlocked again */
_ISR_Enable( level );
484ec: 46c0 movew %d0,%sr
return CORE_RWLOCK_SUCCESSFUL;
484ee: 6062 bras 48552 <_CORE_RWLock_Release+0xa6>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
484f0: 42a8 0034 clrl %a0@(52)
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
484f4: 42aa 0044 clrl %a2@(68)
_ISR_Enable( level );
484f8: 46c0 movew %d0,%sr
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
484fa: 2f0a movel %a2,%sp@-
484fc: 4eb9 0004 9ec4 jsr 49ec4 <_Thread_queue_Dequeue>
if ( next ) {
48502: 588f addql #4,%sp
48504: 4a80 tstl %d0
48506: 674a beqs 48552 <_CORE_RWLock_Release+0xa6>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
48508: 7201 moveq #1,%d1
4850a: 2040 moveal %d0,%a0
4850c: b2a8 0030 cmpl %a0@(48),%d1
48510: 6608 bnes 4851a <_CORE_RWLock_Release+0x6e>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
48512: 7002 moveq #2,%d0
48514: 2540 0044 movel %d0,%a2@(68)
return CORE_RWLOCK_SUCCESSFUL;
48518: 6038 bras 48552 <_CORE_RWLock_Release+0xa6>
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
4851a: 7201 moveq #1,%d1
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
4851c: 52aa 0048 addql #1,%a2@(72)
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
48520: 49f9 0004 a2f8 lea 4a2f8 <_Thread_queue_First>,%a4
if ( !next ||
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
48526: 47f9 0004 a1d0 lea 4a1d0 <_Thread_queue_Extract>,%a3
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
4852c: 2541 0044 movel %d1,%a2@(68)
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
48530: 2f0a movel %a2,%sp@-
48532: 4e94 jsr %a4@
if ( !next ||
48534: 588f addql #4,%sp
48536: 4a80 tstl %d0
48538: 6718 beqs 48552 <_CORE_RWLock_Release+0xa6>
4853a: 7401 moveq #1,%d2
4853c: 2040 moveal %d0,%a0
4853e: b4a8 0030 cmpl %a0@(48),%d2
48542: 670e beqs 48552 <_CORE_RWLock_Release+0xa6> <== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
48544: 52aa 0048 addql #1,%a2@(72)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
48548: 2f00 movel %d0,%sp@-
4854a: 2f0a movel %a2,%sp@-
4854c: 4e93 jsr %a3@
}
4854e: 508f addql #8,%sp
48550: 60de bras 48530 <_CORE_RWLock_Release+0x84>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
48552: 4280 clrl %d0
48554: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
4855a: 4e5e unlk %fp
...
00048560 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
48560: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
48564: 486e fffc pea %fp@(-4)
48568: 2f2e 0008 movel %fp@(8),%sp@-
4856c: 4eb9 0004 9bf0 jsr 49bf0 <_Thread_Get>
switch ( location ) {
48572: 508f addql #8,%sp
48574: 4aae fffc tstl %fp@(-4)
48578: 661e bnes 48598 <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4857a: 2f00 movel %d0,%sp@-
4857c: 4eb9 0004 a3e4 jsr 4a3e4 <_Thread_queue_Process_timeout>
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
return _Thread_Dispatch_disable_level;
48582: 588f addql #4,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
48584: 2039 0006 156c movel 6156c <_Thread_Dispatch_disable_level>,%d0
4858a: 5380 subql #1,%d0
4858c: 23c0 0006 156c movel %d0,6156c <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
48592: 2039 0006 156c movel 6156c <_Thread_Dispatch_disable_level>,%d0
_Thread_Unnest_dispatch();
break;
}
}
48598: 4e5e unlk %fp <== NOT EXECUTED
00047244 <_CORE_barrier_Wait>:
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
47244: 203c 0000 0700 movel #1792,%d0
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4724a: 4e56 fff4 linkw %fp,#-12
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
4724e: 2279 0006 03ae moveal 603ae <_Per_CPU_Information+0xc>,%a1
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
47254: 48d7 001c moveml %d2-%d4,%sp@
47258: 206e 0008 moveal %fp@(8),%a0
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
4725c: 42a9 0034 clrl %a1@(52)
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
47260: 242e 000c movel %fp@(12),%d2
47264: 262e 0014 movel %fp@(20),%d3
47268: 282e 0018 movel %fp@(24),%d4
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4726c: 40c1 movew %sr,%d1
4726e: 8081 orl %d1,%d0
47270: 46c0 movew %d0,%sr
the_barrier->number_of_waiting_threads++;
47272: 2028 0048 movel %a0@(72),%d0
47276: 5280 addql #1,%d0
47278: 2140 0048 movel %d0,%a0@(72)
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
4727c: 4aa8 0040 tstl %a0@(64)
47280: 6626 bnes 472a8 <_CORE_barrier_Wait+0x64>
if ( the_barrier->number_of_waiting_threads ==
47282: b0a8 0044 cmpl %a0@(68),%d0
47286: 6620 bnes 472a8 <_CORE_barrier_Wait+0x64>
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
47288: 7001 moveq #1,%d0
4728a: 2340 0034 movel %d0,%a1@(52)
_ISR_Enable( level );
4728e: 46c1 movew %d1,%sr
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
47290: 2d44 0010 movel %d4,%fp@(16)
47294: 2d42 000c movel %d2,%fp@(12)
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
47298: 4cd7 001c moveml %sp@,%d2-%d4
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
4729c: 2d48 0008 movel %a0,%fp@(8)
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
472a0: 4e5e unlk %fp
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
472a2: 4ef9 0004 bd0c jmp 4bd0c <_CORE_barrier_Release>
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
472a8: 7001 moveq #1,%d0
472aa: 2140 0030 movel %d0,%a0@(48)
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
472ae: 2348 0044 movel %a0,%a1@(68)
executing->Wait.id = id;
472b2: 2342 0020 movel %d2,%a1@(32)
_ISR_Enable( level );
472b6: 46c1 movew %d1,%sr
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
472b8: 2d43 000c movel %d3,%fp@(12)
472bc: 203c 0004 92cc movel #299724,%d0
472c2: 2d48 0008 movel %a0,%fp@(8)
}
472c6: 4cd7 001c moveml %sp@,%d2-%d4
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
472ca: 2d40 0010 movel %d0,%fp@(16)
}
472ce: 4e5e unlk %fp
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
472d0: 4ef9 0004 8fd4 jmp 48fd4 <_Thread_queue_Enqueue_with_handler>
...
0004675c <_CORE_semaphore_Surrender>:
CORE_semaphore_Status _CORE_semaphore_Surrender(
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
CORE_semaphore_API_mp_support_callout api_semaphore_mp_support
)
{
4675c: 4e56 0000 linkw %fp,#0
46760: 2f0a movel %a2,%sp@-
46762: 246e 0008 moveal %fp@(8),%a2
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
46766: 2f0a movel %a2,%sp@-
46768: 4eb9 0004 807c jsr 4807c <_Thread_queue_Dequeue>
4676e: 588f addql #4,%sp
46770: 4a80 tstl %d0
46772: 6624 bnes 46798 <_CORE_semaphore_Surrender+0x3c>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
46774: 303c 0700 movew #1792,%d0
46778: 40c1 movew %sr,%d1
4677a: 8081 orl %d1,%d0
4677c: 46c0 movew %d0,%sr
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
4677e: 202a 0048 movel %a2@(72),%d0
46782: b0aa 0040 cmpl %a2@(64),%d0
46786: 640a bccs 46792 <_CORE_semaphore_Surrender+0x36> <== NEVER TAKEN
the_semaphore->count += 1;
46788: 5280 addql #1,%d0
4678a: 2540 0048 movel %d0,%a2@(72)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
4678e: 4280 clrl %d0
46790: 6002 bras 46794 <_CORE_semaphore_Surrender+0x38>
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
46792: 7004 moveq #4,%d0 <== NOT EXECUTED
_ISR_Enable( level );
46794: 46c1 movew %d1,%sr
46796: 6002 bras 4679a <_CORE_semaphore_Surrender+0x3e>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
46798: 4280 clrl %d0
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
4679a: 246e fffc moveal %fp@(-4),%a2
4679e: 4e5e unlk %fp
...
000455d8 <_Event_Surrender>:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
455d8: 203c 0000 0700 movel #1792,%d0
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
455de: 4e56 ffec linkw %fp,#-20
455e2: 48d7 043c moveml %d2-%d5/%a2,%sp@
455e6: 246e 0008 moveal %fp@(8),%a2
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
455ea: 206a 00fe moveal %a2@(254),%a0
option_set = (rtems_option) the_thread->Wait.option;
455ee: 282a 0030 movel %a2@(48),%d4
_ISR_Disable( level );
455f2: 40c1 movew %sr,%d1
455f4: 8081 orl %d1,%d0
455f6: 46c0 movew %d0,%sr
pending_events = api->pending_events;
event_condition = (rtems_event_set) the_thread->Wait.count;
455f8: 262a 0024 movel %a2@(36),%d3
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Get(
rtems_event_set the_event_set,
rtems_event_set the_event_condition
)
{
return ( the_event_set & the_event_condition );
455fc: 2003 movel %d3,%d0
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
pending_events = api->pending_events;
455fe: 2410 movel %a0@,%d2
45600: c082 andl %d2,%d0
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
45602: 6700 00ca beqw 456ce <_Event_Surrender+0xf6>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
45606: 4ab9 0005 eff6 tstl 5eff6 <_Per_CPU_Information+0x8>
4560c: 674a beqs 45658 <_Event_Surrender+0x80>
4560e: b5f9 0005 effa cmpal 5effa <_Per_CPU_Information+0xc>,%a2
45614: 6642 bnes 45658 <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
45616: 2279 0005 f3d4 moveal 5f3d4 <_Event_Sync_state>,%a1
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
4561c: 7a02 moveq #2,%d5
4561e: ba89 cmpl %a1,%d5
45620: 670e beqs 45630 <_Event_Surrender+0x58> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
45622: 2279 0005 f3d4 moveal 5f3d4 <_Event_Sync_state>,%a1
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
45628: 1a3c 0001 moveb #1,%d5
4562c: ba89 cmpl %a1,%d5
4562e: 6628 bnes 45658 <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
45630: b680 cmpl %d0,%d3
45632: 6708 beqs 4563c <_Event_Surrender+0x64>
45634: 0804 0001 btst #1,%d4
45638: 6700 0094 beqw 456ce <_Event_Surrender+0xf6>
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
4563c: 2600 movel %d0,%d3
4563e: 4683 notl %d3
45640: c682 andl %d2,%d3
45642: 2083 movel %d3,%a0@
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
45644: 206a 0028 moveal %a2@(40),%a0
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
45648: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
4564c: 2080 movel %d0,%a0@
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
4564e: 7003 moveq #3,%d0
45650: 23c0 0005 f3d4 movel %d0,5f3d4 <_Event_Sync_state>
45656: 6076 bras 456ce <_Event_Surrender+0xf6>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
45658: 2a2a 0010 movel %a2@(16),%d5
4565c: 0285 0000 0100 andil #256,%d5
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
45662: 676a beqs 456ce <_Event_Surrender+0xf6>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
45664: b680 cmpl %d0,%d3
45666: 6706 beqs 4566e <_Event_Surrender+0x96>
45668: 0804 0001 btst #1,%d4
4566c: 6760 beqs 456ce <_Event_Surrender+0xf6> <== NEVER TAKEN
4566e: 2600 movel %d0,%d3
45670: 4683 notl %d3
45672: c682 andl %d2,%d3
45674: 2083 movel %d3,%a0@
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
45676: 206a 0028 moveal %a2@(40),%a0
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
4567a: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
4567e: 2080 movel %d0,%a0@
_ISR_Flash( level );
45680: 203c 0000 0700 movel #1792,%d0
45686: 46c1 movew %d1,%sr
45688: 8081 orl %d1,%d0
4568a: 46c0 movew %d0,%sr
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4568c: 7a02 moveq #2,%d5
4568e: baaa 0050 cmpl %a2@(80),%d5
45692: 6714 beqs 456a8 <_Event_Surrender+0xd0>
_ISR_Enable( level );
45694: 46c1 movew %d1,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
45696: 2f3c 1003 fff8 movel #268697592,%sp@-
4569c: 2f0a movel %a2,%sp@-
4569e: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state>
456a4: 508f addql #8,%sp
456a6: 6028 bras 456d0 <_Event_Surrender+0xf8>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
456a8: 7003 moveq #3,%d0
456aa: 2540 0050 movel %d0,%a2@(80)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
456ae: 46c1 movew %d1,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
456b0: 486a 0048 pea %a2@(72)
456b4: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove>
456ba: 2f3c 1003 fff8 movel #268697592,%sp@-
456c0: 2f0a movel %a2,%sp@-
456c2: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state>
456c8: 4fef 000c lea %sp@(12),%sp
456cc: 6002 bras 456d0 <_Event_Surrender+0xf8>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
456ce: 46c1 movew %d1,%sr
}
456d0: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
456d6: 4e5e unlk %fp
...
000456dc <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
456dc: 4e56 fffc linkw %fp,#-4
456e0: 2f03 movel %d3,%sp@-
456e2: 2f02 movel %d2,%sp@-
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
456e4: 486e fffc pea %fp@(-4)
456e8: 2f2e 0008 movel %fp@(8),%sp@-
456ec: 4eb9 0004 7da8 jsr 47da8 <_Thread_Get>
switch ( location ) {
456f2: 508f addql #8,%sp
456f4: 4aae fffc tstl %fp@(-4)
456f8: 665c bnes 45756 <_Event_Timeout+0x7a> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
456fa: 223c 0000 0700 movel #1792,%d1
45700: 40c2 movew %sr,%d2
45702: 8282 orl %d2,%d1
45704: 46c1 movew %d1,%sr
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
45706: 2040 moveal %d0,%a0
45708: 42a8 0024 clrl %a0@(36)
if ( _Thread_Is_executing( the_thread ) ) {
4570c: b0b9 0005 effa cmpl 5effa <_Per_CPU_Information+0xc>,%d0
45712: 6614 bnes 45728 <_Event_Timeout+0x4c>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
45714: 2239 0005 f3d4 movel 5f3d4 <_Event_Sync_state>,%d1
4571a: 7601 moveq #1,%d3
4571c: b681 cmpl %d1,%d3
4571e: 6608 bnes 45728 <_Event_Timeout+0x4c>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
45720: 7202 moveq #2,%d1
45722: 23c1 0005 f3d4 movel %d1,5f3d4 <_Event_Sync_state>
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
45728: 7606 moveq #6,%d3
4572a: 2040 moveal %d0,%a0
4572c: 2143 0034 movel %d3,%a0@(52)
_ISR_Enable( level );
45730: 46c2 movew %d2,%sr
45732: 2f3c 1003 fff8 movel #268697592,%sp@-
45738: 2f00 movel %d0,%sp@-
4573a: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state>
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
return _Thread_Dispatch_disable_level;
45740: 508f addql #8,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
45742: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
45748: 5380 subql #1,%d0
4574a: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45750: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
45756: 242e fff4 movel %fp@(-12),%d2
4575a: 262e fff8 movel %fp@(-8),%d3
4575e: 4e5e unlk %fp
...
0004b168 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
4b168: 4e56 ffcc linkw %fp,#-52
4b16c: 202e 0010 movel %fp@(16),%d0
4b170: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4b174: 246e 0008 moveal %fp@(8),%a2
4b178: 262e 000c movel %fp@(12),%d3
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
4b17c: 2403 movel %d3,%d2
4b17e: d480 addl %d0,%d2
uintptr_t const free_size = stats->free_size;
4b180: 206a 0030 moveal %a2@(48),%a0
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
4b184: 282a 0020 movel %a2@(32),%d4
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
uintptr_t const page_size = heap->page_size;
4b188: 2a2a 0010 movel %a2@(16),%d5
uintptr_t const min_block_size = heap->min_block_size;
4b18c: 222a 0014 movel %a2@(20),%d1
Heap_Block *start_block = first_block;
Heap_Block *merge_below_block = NULL;
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
4b190: 42ae fff8 clrl %fp@(-8)
Heap_Block *extend_last_block = NULL;
4b194: 42ae fffc clrl %fp@(-4)
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
uintptr_t const free_size = stats->free_size;
4b198: 2d48 fff4 movel %a0,%fp@(-12)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
4b19c: b682 cmpl %d2,%d3
4b19e: 6200 01a6 bhiw 4b346 <_Heap_Extend+0x1de>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
4b1a2: 486e fffc pea %fp@(-4)
4b1a6: 486e fff8 pea %fp@(-8)
4b1aa: 2f01 movel %d1,%sp@-
4b1ac: 2f05 movel %d5,%sp@-
4b1ae: 2f00 movel %d0,%sp@-
4b1b0: 2f03 movel %d3,%sp@-
4b1b2: 4eb9 0004 69e6 jsr 469e6 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
4b1b8: 4fef 0018 lea %sp@(24),%sp
4b1bc: 4a00 tstb %d0
4b1be: 6700 0186 beqw 4b346 <_Heap_Extend+0x1de>
4b1c2: 2044 moveal %d4,%a0
4b1c4: 9bcd subal %a5,%a5
4b1c6: 4281 clrl %d1
4b1c8: 97cb subal %a3,%a3
4b1ca: 99cc subal %a4,%a4
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
4b1cc: b888 cmpl %a0,%d4
4b1ce: 6704 beqs 4b1d4 <_Heap_Extend+0x6c>
4b1d0: 2248 moveal %a0,%a1
4b1d2: 6004 bras 4b1d8 <_Heap_Extend+0x70>
4b1d4: 226a 0018 moveal %a2@(24),%a1
uintptr_t const sub_area_end = start_block->prev_size;
4b1d8: 2010 movel %a0@,%d0
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4b1da: b680 cmpl %d0,%d3
4b1dc: 6406 bccs 4b1e4 <_Heap_Extend+0x7c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
4b1de: b3c2 cmpal %d2,%a1
4b1e0: 6500 0164 bcsw 4b346 <_Heap_Extend+0x1de>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4b1e4: b3c2 cmpal %d2,%a1
4b1e6: 6706 beqs 4b1ee <_Heap_Extend+0x86>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4b1e8: b082 cmpl %d2,%d0
4b1ea: 6206 bhis 4b1f2 <_Heap_Extend+0x8a>
4b1ec: 6006 bras 4b1f4 <_Heap_Extend+0x8c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4b1ee: 2848 moveal %a0,%a4
4b1f0: 6002 bras 4b1f4 <_Heap_Extend+0x8c>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4b1f2: 2208 movel %a0,%d1
4b1f4: 2e00 movel %d0,%d7
4b1f6: 2240 moveal %d0,%a1
4b1f8: 5189 subql #8,%a1
4b1fa: 4c45 7006 remul %d5,%d6,%d7
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
4b1fe: 93c6 subal %d6,%a1
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4b200: b680 cmpl %d0,%d3
4b202: 6606 bnes 4b20a <_Heap_Extend+0xa2>
start_block->prev_size = extend_area_end;
4b204: 2082 movel %d2,%a0@
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
4b206: 2649 moveal %a1,%a3
4b208: 6006 bras 4b210 <_Heap_Extend+0xa8>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
4b20a: b680 cmpl %d0,%d3
4b20c: 6302 blss 4b210 <_Heap_Extend+0xa8>
4b20e: 2a49 moveal %a1,%a5
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4b210: 70fe moveq #-2,%d0
4b212: c0a9 0004 andl %a1@(4),%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4b216: 41f1 0800 lea %a1@(00000000,%d0:l),%a0
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
4b21a: b888 cmpl %a0,%d4
4b21c: 66ae bnes 4b1cc <_Heap_Extend+0x64>
if ( extend_area_begin < heap->area_begin ) {
4b21e: b6aa 0018 cmpl %a2@(24),%d3
4b222: 6406 bccs 4b22a <_Heap_Extend+0xc2>
heap->area_begin = extend_area_begin;
4b224: 2543 0018 movel %d3,%a2@(24)
4b228: 600a bras 4b234 <_Heap_Extend+0xcc>
} else if ( heap->area_end < extend_area_end ) {
4b22a: b4aa 001c cmpl %a2@(28),%d2
4b22e: 6304 blss 4b234 <_Heap_Extend+0xcc>
heap->area_end = extend_area_end;
4b230: 2542 001c movel %d2,%a2@(28)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4b234: 206e fffc moveal %fp@(-4),%a0
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4b238: 2008 movel %a0,%d0
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4b23a: 7801 moveq #1,%d4
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4b23c: 226e fff8 moveal %fp@(-8),%a1
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4b240: 9089 subl %a1,%d0
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4b242: 8880 orl %d0,%d4
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
4b244: 2282 movel %d2,%a1@
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4b246: 2344 0004 movel %d4,%a1@(4)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
4b24a: 2080 movel %d0,%a0@
extend_last_block->size_and_flag = 0;
4b24c: 42a8 0004 clrl %a0@(4)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4b250: b3ea 0020 cmpal %a2@(32),%a1
4b254: 6406 bccs 4b25c <_Heap_Extend+0xf4>
heap->first_block = extend_first_block;
4b256: 2549 0020 movel %a1,%a2@(32)
4b25a: 600a bras 4b266 <_Heap_Extend+0xfe>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4b25c: b1ea 0024 cmpal %a2@(36),%a0
4b260: 6304 blss 4b266 <_Heap_Extend+0xfe>
heap->last_block = extend_last_block;
4b262: 2548 0024 movel %a0,%a2@(36)
}
if ( merge_below_block != NULL ) {
4b266: 4a8c tstl %a4
4b268: 6732 beqs 4b29c <_Heap_Extend+0x134>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
4b26a: 202a 0010 movel %a2@(16),%d0
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
4b26e: 5083 addql #8,%d3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
4b270: 2803 movel %d3,%d4
4b272: 4c40 4001 remul %d0,%d1,%d4
if ( remainder != 0 ) {
4b276: 4a81 tstl %d1
4b278: 6704 beqs 4b27e <_Heap_Extend+0x116>
return value - remainder + alignment;
4b27a: d680 addl %d0,%d3
4b27c: 9681 subl %d1,%d3
uintptr_t const new_first_block_begin =
4b27e: 2043 moveal %d3,%a0
4b280: 5188 subql #8,%a0
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
4b282: 200c movel %a4,%d0
4b284: 9088 subl %a0,%d0
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4b286: 7201 moveq #1,%d1
4b288: 8280 orl %d0,%d1
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
4b28a: 2094 movel %a4@,%a0@
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4b28c: 2141 0004 movel %d1,%a0@(4)
_Heap_Free_block( heap, new_first_block );
4b290: 2f08 movel %a0,%sp@-
4b292: 2f0a movel %a2,%sp@-
4b294: 4eba feb6 jsr %pc@(4b14c <_Heap_Free_block>)
4b298: 508f addql #8,%sp
4b29a: 600e bras 4b2aa <_Heap_Extend+0x142>
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
4b29c: 4a81 tstl %d1
4b29e: 670a beqs 4b2aa <_Heap_Extend+0x142>
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
4b2a0: 9288 subl %a0,%d1
4b2a2: 7801 moveq #1,%d4
4b2a4: 8881 orl %d1,%d4
4b2a6: 2144 0004 movel %d4,%a0@(4)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
4b2aa: 4a8b tstl %a3
4b2ac: 6734 beqs 4b2e2 <_Heap_Extend+0x17a>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
4b2ae: 5182 subql #8,%d2
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
4b2b0: 948b subl %a3,%d2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4b2b2: 2202 movel %d2,%d1
4b2b4: 4c6a 1000 0010 remul %a2@(16),%d0,%d1
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
4b2ba: 7201 moveq #1,%d1
4b2bc: 9480 subl %d0,%d2
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
4b2be: 202b 0004 movel %a3@(4),%d0
4b2c2: 9082 subl %d2,%d0
| HEAP_PREV_BLOCK_USED;
4b2c4: 8280 orl %d0,%d1
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4b2c6: 7001 moveq #1,%d0
4b2c8: 2781 2804 movel %d1,%a3@(00000004,%d2:l)
4b2cc: c0ab 0004 andl %a3@(4),%d0
block->size_and_flag = size | flag;
4b2d0: 8480 orl %d0,%d2
4b2d2: 2742 0004 movel %d2,%a3@(4)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
4b2d6: 2f0b movel %a3,%sp@-
4b2d8: 2f0a movel %a2,%sp@-
4b2da: 4eba fe70 jsr %pc@(4b14c <_Heap_Free_block>)
4b2de: 508f addql #8,%sp
4b2e0: 6020 bras 4b302 <_Heap_Extend+0x19a>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
4b2e2: 4a8d tstl %a5
4b2e4: 671c beqs 4b302 <_Heap_Extend+0x19a>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4b2e6: 7201 moveq #1,%d1
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4b2e8: 7801 moveq #1,%d4
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
4b2ea: 202e fff8 movel %fp@(-8),%d0
4b2ee: 908d subl %a5,%d0
4b2f0: c2ad 0004 andl %a5@(4),%d1
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
4b2f4: 206e fffc moveal %fp@(-4),%a0
block->size_and_flag = size | flag;
4b2f8: 8280 orl %d0,%d1
4b2fa: 2b41 0004 movel %d1,%a5@(4)
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4b2fe: 89a8 0004 orl %d4,%a0@(4)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4b302: 4a8c tstl %a4
4b304: 6610 bnes 4b316 <_Heap_Extend+0x1ae>
4b306: 4a8b tstl %a3
4b308: 660c bnes 4b316 <_Heap_Extend+0x1ae>
_Heap_Free_block( heap, extend_first_block );
4b30a: 2f2e fff8 movel %fp@(-8),%sp@-
4b30e: 2f0a movel %a2,%sp@-
4b310: 4eba fe3a jsr %pc@(4b14c <_Heap_Free_block>)
4b314: 508f addql #8,%sp
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
4b316: 206a 0024 moveal %a2@(36),%a0
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4b31a: 7201 moveq #1,%d1
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
4b31c: 202a 0020 movel %a2@(32),%d0
4b320: 9088 subl %a0,%d0
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4b322: c2a8 0004 andl %a0@(4),%d1
block->size_and_flag = size | flag;
4b326: 8280 orl %d0,%d1
4b328: 2141 0004 movel %d1,%a0@(4)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
4b32c: 202a 0030 movel %a2@(48),%d0
4b330: 90ae fff4 subl %fp@(-12),%d0
/* Statistics */
stats->size += extended_size;
4b334: d1aa 002c addl %d0,%a2@(44)
if ( extended_size_ptr != NULL )
4b338: 4aae 0014 tstl %fp@(20)
4b33c: 670c beqs 4b34a <_Heap_Extend+0x1e2> <== NEVER TAKEN
*extended_size_ptr = extended_size;
4b33e: 206e 0014 moveal %fp@(20),%a0
4b342: 2080 movel %d0,%a0@
4b344: 6004 bras 4b34a <_Heap_Extend+0x1e2>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
4b346: 4200 clrb %d0
4b348: 6002 bras 4b34c <_Heap_Extend+0x1e4>
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
4b34a: 7001 moveq #1,%d0
}
4b34c: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5
4b352: 4e5e unlk %fp
...
0004b118 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4b118: 4e56 ffe8 linkw %fp,#-24
4b11c: 206e 0008 moveal %fp@(8),%a0
4b120: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
4b124: 202e 000c movel %fp@(12),%d0
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
4b128: 6700 014e beqw 4b278 <_Heap_Free+0x160>
4b12c: 2240 moveal %d0,%a1
4b12e: 5189 subql #8,%a1
4b130: 4c68 0001 0010 remul %a0@(16),%d1,%d0
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
4b136: 2828 0020 movel %a0@(32),%d4
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
4b13a: 93c1 subal %d1,%a1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4b13c: b889 cmpl %a1,%d4
4b13e: 620c bhis 4b14c <_Heap_Free+0x34>
4b140: b3e8 0024 cmpal %a0@(36),%a1
4b144: 53c0 sls %d0
4b146: 49c0 extbl %d0
4b148: 4480 negl %d0
4b14a: 6002 bras 4b14e <_Heap_Free+0x36>
4b14c: 4280 clrl %d0
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
4b14e: 4a00 tstb %d0
4b150: 6700 012a beqw 4b27c <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4b154: 2629 0004 movel %a1@(4),%d3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4b158: 70fe moveq #-2,%d0
4b15a: c083 andl %d3,%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4b15c: 45f1 0800 lea %a1@(00000000,%d0:l),%a2
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4b160: b88a cmpl %a2,%d4
4b162: 620c bhis 4b170 <_Heap_Free+0x58> <== NEVER TAKEN
4b164: b5e8 0024 cmpal %a0@(36),%a2
4b168: 53c1 sls %d1
4b16a: 49c1 extbl %d1
4b16c: 4481 negl %d1
4b16e: 6002 bras 4b172 <_Heap_Free+0x5a>
4b170: 4281 clrl %d1 <== NOT EXECUTED
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
4b172: 4a01 tstb %d1
4b174: 6700 0106 beqw 4b27c <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4b178: 242a 0004 movel %a2@(4),%d2
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4b17c: 0802 0000 btst #0,%d2
4b180: 6700 00fa beqw 4b27c <_Heap_Free+0x164>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4b184: 72fe moveq #-2,%d1
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
4b186: 2668 0024 moveal %a0@(36),%a3
4b18a: c481 andl %d1,%d2
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4b18c: b7ca cmpal %a2,%a3
4b18e: 670c beqs 4b19c <_Heap_Free+0x84>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4b190: 7201 moveq #1,%d1
4b192: c2b2 2804 andl %a2@(00000004,%d2:l),%d1
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
4b196: 5381 subql #1,%d1
4b198: 4481 negl %d1
4b19a: 6002 bras 4b19e <_Heap_Free+0x86>
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4b19c: 4281 clrl %d1
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
4b19e: 1a01 moveb %d1,%d5
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
4b1a0: 0803 0000 btst #0,%d3
4b1a4: 6660 bnes 4b206 <_Heap_Free+0xee>
uintptr_t const prev_size = block->prev_size;
4b1a6: 2611 movel %a1@,%d3
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4b1a8: 93c3 subal %d3,%a1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4b1aa: b889 cmpl %a1,%d4
4b1ac: 620a bhis 4b1b8 <_Heap_Free+0xa0> <== NEVER TAKEN
4b1ae: b3cb cmpal %a3,%a1
4b1b0: 53c1 sls %d1
4b1b2: 49c1 extbl %d1
4b1b4: 4481 negl %d1
4b1b6: 6002 bras 4b1ba <_Heap_Free+0xa2>
4b1b8: 4281 clrl %d1 <== NOT EXECUTED
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
4b1ba: 4a01 tstb %d1
4b1bc: 6700 00be beqw 4b27c <_Heap_Free+0x164>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4b1c0: 7201 moveq #1,%d1
4b1c2: c2a9 0004 andl %a1@(4),%d1
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
4b1c6: 6700 00b4 beqw 4b27c <_Heap_Free+0x164>
4b1ca: d680 addl %d0,%d3
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4b1cc: 4a05 tstb %d5
4b1ce: 6724 beqs 4b1f4 <_Heap_Free+0xdc>
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
4b1d0: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + prev_size + next_block_size;
4b1d4: d483 addl %d3,%d2
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1d6: 7201 moveq #1,%d1
Heap_Block *prev = block->prev;
4b1d8: 246a 000c moveal %a2@(12),%a2
prev->next = next;
4b1dc: 254b 0008 movel %a3,%a2@(8)
4b1e0: 8282 orl %d2,%d1
next->prev = prev;
4b1e2: 274a 000c movel %a2,%a3@(12)
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
4b1e6: 53a8 0038 subql #1,%a0@(56)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
4b1ea: 2382 2800 movel %d2,%a1@(00000000,%d2:l)
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1ee: 2341 0004 movel %d1,%a1@(4)
4b1f2: 6078 bras 4b26c <_Heap_Free+0x154>
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1f4: 7401 moveq #1,%d2
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b1f6: 72fe moveq #-2,%d1
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1f8: 8483 orl %d3,%d2
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
4b1fa: 2483 movel %d3,%a2@
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1fc: 2342 0004 movel %d2,%a1@(4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b200: c3aa 0004 andl %d1,%a2@(4)
4b204: 6066 bras 4b26c <_Heap_Free+0x154>
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
4b206: 4a01 tstb %d1
4b208: 672a beqs 4b234 <_Heap_Free+0x11c>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
4b20a: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + next_block_size;
4b20e: 2202 movel %d2,%d1
4b210: d280 addl %d0,%d1
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b212: 7401 moveq #1,%d2
Heap_Block *prev = old_block->prev;
4b214: 246a 000c moveal %a2@(12),%a2
new_block->next = next;
4b218: 234b 0008 movel %a3,%a1@(8)
4b21c: 8481 orl %d1,%d2
new_block->prev = prev;
4b21e: 234a 000c movel %a2,%a1@(12)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4b222: 2381 1800 movel %d1,%a1@(00000000,%d1:l)
next->prev = new_block;
4b226: 2749 000c movel %a1,%a3@(12)
prev->next = new_block;
4b22a: 2549 0008 movel %a1,%a2@(8)
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b22e: 2342 0004 movel %d2,%a1@(4)
4b232: 6038 bras 4b26c <_Heap_Free+0x154>
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4b234: 7201 moveq #1,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b236: 74fe moveq #-2,%d2
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4b238: 8280 orl %d0,%d1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
4b23a: 2668 0008 moveal %a0@(8),%a3
new_block->next = next;
new_block->prev = block_before;
4b23e: 2348 000c movel %a0,%a1@(12)
4b242: 2341 0004 movel %d1,%a1@(4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4b246: 2228 0038 movel %a0@(56),%d1
4b24a: 5281 addql #1,%d1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4b24c: 234b 0008 movel %a3,%a1@(8)
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b250: c5aa 0004 andl %d2,%a2@(4)
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
4b254: 2749 000c movel %a1,%a3@(12)
next_block->prev_size = block_size;
4b258: 2480 movel %d0,%a2@
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
4b25a: 2149 0008 movel %a1,%a0@(8)
/* Statistics */
++stats->free_blocks;
4b25e: 2141 0038 movel %d1,%a0@(56)
if ( stats->max_free_blocks < stats->free_blocks ) {
4b262: b2a8 003c cmpl %a0@(60),%d1
4b266: 6304 blss 4b26c <_Heap_Free+0x154>
stats->max_free_blocks = stats->free_blocks;
4b268: 2141 003c movel %d1,%a0@(60)
}
}
/* Statistics */
--stats->used_blocks;
4b26c: 53a8 0040 subql #1,%a0@(64)
++stats->frees;
4b270: 52a8 0050 addql #1,%a0@(80)
stats->free_size += block_size;
4b274: d1a8 0030 addl %d0,%a0@(48)
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
4b278: 7001 moveq #1,%d0
4b27a: 6002 bras 4b27e <_Heap_Free+0x166>
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
_HAssert( false );
return( false );
4b27c: 4200 clrb %d0
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4b27e: 4cd7 0c3c moveml %sp@,%d2-%d5/%a2-%a3
4b282: 4e5e unlk %fp
...
0004697e <_Heap_Get_first_and_last_block>:
uintptr_t page_size,
uintptr_t min_block_size,
Heap_Block **first_block_ptr,
Heap_Block **last_block_ptr
)
{
4697e: 4e56 fff4 linkw %fp,#-12
46982: 206e 0008 moveal %fp@(8),%a0
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
46986: 2008 movel %a0,%d0
46988: 5080 addql #8,%d0
uintptr_t page_size,
uintptr_t min_block_size,
Heap_Block **first_block_ptr,
Heap_Block **last_block_ptr
)
{
4698a: 48d7 001c moveml %d2-%d4,%sp@
4698e: 222e 0010 movel %fp@(16),%d1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
46992: 2800 movel %d0,%d4
46994: 242e 000c movel %fp@(12),%d2
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
46998: 43f0 2800 lea %a0@(00000000,%d2:l),%a1
4699c: 4c41 4003 remul %d1,%d3,%d4
if ( remainder != 0 ) {
469a0: 4a83 tstl %d3
469a2: 6704 beqs 469a8 <_Heap_Get_first_and_last_block+0x2a>
return value - remainder + alignment;
469a4: d081 addl %d1,%d0
469a6: 9083 subl %d3,%d0
_Heap_Align_down( heap_area_size - overhead, page_size );
Heap_Block *const first_block = (Heap_Block *) first_block_begin;
Heap_Block *const last_block =
_Heap_Block_at( first_block, first_block_size );
if (
469a8: b1c9 cmpal %a1,%a0
469aa: 622e bhis 469da <_Heap_Get_first_and_last_block+0x5c>
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);
469ac: 2240 moveal %d0,%a1
469ae: 5189 subql #8,%a1
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
469b0: 9088 subl %a0,%d0
Heap_Block *const last_block =
_Heap_Block_at( first_block, first_block_size );
if (
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
469b2: b082 cmpl %d2,%d0
469b4: 6424 bccs 469da <_Heap_Get_first_and_last_block+0x5c>
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);
uintptr_t const first_block_size =
_Heap_Align_down( heap_area_size - overhead, page_size );
469b6: 9480 subl %d0,%d2
469b8: 2002 movel %d2,%d0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
469ba: 2602 movel %d2,%d3
469bc: 4c41 3002 remul %d1,%d2,%d3
469c0: 9082 subl %d2,%d0
_Heap_Block_at( first_block, first_block_size );
if (
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
|| first_block_size < min_block_size
469c2: b0ae 0014 cmpl %fp@(20),%d0
469c6: 6512 bcss 469da <_Heap_Get_first_and_last_block+0x5c><== NEVER TAKEN
) {
/* Invalid area or area too small */
return false;
}
*first_block_ptr = first_block;
469c8: 206e 0018 moveal %fp@(24),%a0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
469cc: d089 addl %a1,%d0
469ce: 2089 movel %a1,%a0@
469d0: 206e 001c moveal %fp@(28),%a0
469d4: 2080 movel %d0,%a0@
*last_block_ptr = last_block;
return true;
469d6: 7001 moveq #1,%d0
469d8: 6002 bras 469dc <_Heap_Get_first_and_last_block+0x5e>
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
|| first_block_size < min_block_size
) {
/* Invalid area or area too small */
return false;
469da: 4200 clrb %d0
*first_block_ptr = first_block;
*last_block_ptr = last_block;
return true;
}
469dc: 4cd7 001c moveml %sp@,%d2-%d4
469e0: 4e5e unlk %fp <== NOT EXECUTED
0005b19c <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
5b19c: 4e56 0000 linkw %fp,#0
5b1a0: 202e 000c movel %fp@(12),%d0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
5b1a4: 2040 moveal %d0,%a0
5b1a6: 5188 subql #8,%a0
5b1a8: 226e 0008 moveal %fp@(8),%a1
5b1ac: 2f02 movel %d2,%sp@-
5b1ae: 2400 movel %d0,%d2
5b1b0: 4c69 2001 0010 remul %a1@(16),%d1,%d2
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
5b1b6: 2429 0020 movel %a1@(32),%d2
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
5b1ba: 91c1 subal %d1,%a0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
5b1bc: b488 cmpl %a0,%d2
5b1be: 620c bhis 5b1cc <_Heap_Size_of_alloc_area+0x30>
5b1c0: b1e9 0024 cmpal %a1@(36),%a0
5b1c4: 53c1 sls %d1
5b1c6: 49c1 extbl %d1
5b1c8: 4481 negl %d1
5b1ca: 6002 bras 5b1ce <_Heap_Size_of_alloc_area+0x32>
5b1cc: 4281 clrl %d1
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
5b1ce: 4a01 tstb %d1
5b1d0: 673a beqs 5b20c <_Heap_Size_of_alloc_area+0x70>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
5b1d2: 72fe moveq #-2,%d1
5b1d4: c2a8 0004 andl %a0@(4),%d1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
5b1d8: 41f0 1800 lea %a0@(00000000,%d1:l),%a0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
5b1dc: b488 cmpl %a0,%d2
5b1de: 620c bhis 5b1ec <_Heap_Size_of_alloc_area+0x50> <== NEVER TAKEN
5b1e0: b1e9 0024 cmpal %a1@(36),%a0
5b1e4: 53c1 sls %d1
5b1e6: 49c1 extbl %d1
5b1e8: 4481 negl %d1
5b1ea: 6002 bras 5b1ee <_Heap_Size_of_alloc_area+0x52>
5b1ec: 4281 clrl %d1 <== NOT EXECUTED
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
5b1ee: 4a01 tstb %d1
5b1f0: 671a beqs 5b20c <_Heap_Size_of_alloc_area+0x70> <== NEVER TAKEN
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
5b1f2: 7201 moveq #1,%d1
5b1f4: c2a8 0004 andl %a0@(4),%d1
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
5b1f8: 6712 beqs 5b20c <_Heap_Size_of_alloc_area+0x70> <== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
5b1fa: 7204 moveq #4,%d1
5b1fc: 9280 subl %d0,%d1
5b1fe: 2001 movel %d1,%d0
5b200: d088 addl %a0,%d0
5b202: 226e 0010 moveal %fp@(16),%a1
5b206: 2280 movel %d0,%a1@
return true;
5b208: 7001 moveq #1,%d0
5b20a: 6002 bras 5b20e <_Heap_Size_of_alloc_area+0x72>
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
5b20c: 4200 clrb %d0
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
5b20e: 241f movel %sp@+,%d2
5b210: 4e5e unlk %fp <== NOT EXECUTED
00047416 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
47416: 4e56 ffd0 linkw %fp,#-48
4741a: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4741e: 266e 0008 moveal %fp@(8),%a3
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
47422: 45fa ffac lea %pc@(473d0 <_Heap_Walk_print_nothing>),%a2
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
47426: 242e 000c movel %fp@(12),%d2
uintptr_t const page_size = heap->page_size;
4742a: 282b 0010 movel %a3@(16),%d4
uintptr_t const min_block_size = heap->min_block_size;
4742e: 2a2b 0014 movel %a3@(20),%d5
Heap_Block *const first_block = heap->first_block;
47432: 2c2b 0020 movel %a3@(32),%d6
Heap_Block *const last_block = heap->last_block;
47436: 2e2b 0024 movel %a3@(36),%d7
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
4743a: 4a2e 0013 tstb %fp@(19)
4743e: 6704 beqs 47444 <_Heap_Walk+0x2e>
47440: 45fa ff96 lea %pc@(473d8 <_Heap_Walk_print>),%a2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
47444: 7003 moveq #3,%d0
47446: b0b9 0006 0e44 cmpl 60e44 <_System_state_Current>,%d0
4744c: 6600 02fc bnew 4774a <_Heap_Walk+0x334>
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
47450: 2f2b 000c movel %a3@(12),%sp@-
47454: 2f2b 0008 movel %a3@(8),%sp@-
47458: 2f07 movel %d7,%sp@-
4745a: 2f06 movel %d6,%sp@-
4745c: 2f2b 001c movel %a3@(28),%sp@-
47460: 2f2b 0018 movel %a3@(24),%sp@-
47464: 2f05 movel %d5,%sp@-
47466: 2f04 movel %d4,%sp@-
47468: 4879 0005 d0cb pea 5d0cb <_Status_Object_name_errors_to_status+0x5d>
4746e: 42a7 clrl %sp@-
47470: 2f02 movel %d2,%sp@-
47472: 4e92 jsr %a2@
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
47474: 4fef 002c lea %sp@(44),%sp
47478: 4a84 tstl %d4
4747a: 6608 bnes 47484 <_Heap_Walk+0x6e>
(*printer)( source, true, "page size is zero\n" );
4747c: 4879 0005 d15c pea 5d15c <_Status_Object_name_errors_to_status+0xee>
47482: 606c bras 474f0 <_Heap_Walk+0xda>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
47484: 7003 moveq #3,%d0
47486: c084 andl %d4,%d0
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
47488: 670c beqs 47496 <_Heap_Walk+0x80>
(*printer)(
4748a: 2f04 movel %d4,%sp@-
4748c: 4879 0005 d16f pea 5d16f <_Status_Object_name_errors_to_status+0x101>
47492: 6000 02ca braw 4775e <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
47496: 2205 movel %d5,%d1
47498: 4c44 1000 remul %d4,%d0,%d1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
4749c: 4a80 tstl %d0
4749e: 670c beqs 474ac <_Heap_Walk+0x96>
(*printer)(
474a0: 2f05 movel %d5,%sp@-
474a2: 4879 0005 d18d pea 5d18d <_Status_Object_name_errors_to_status+0x11f>
474a8: 6000 02b4 braw 4775e <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
474ac: 2006 movel %d6,%d0
474ae: 5080 addql #8,%d0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
474b0: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if (
474b4: 4a81 tstl %d1
474b6: 670c beqs 474c4 <_Heap_Walk+0xae>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
474b8: 2f06 movel %d6,%sp@-
474ba: 4879 0005 d1b1 pea 5d1b1 <_Status_Object_name_errors_to_status+0x143>
474c0: 6000 029c braw 4775e <_Heap_Walk+0x348>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
474c4: 7001 moveq #1,%d0
474c6: 2046 moveal %d6,%a0
474c8: c0a8 0004 andl %a0@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
474cc: 6608 bnes 474d6 <_Heap_Walk+0xc0>
(*printer)(
474ce: 4879 0005 d1e2 pea 5d1e2 <_Status_Object_name_errors_to_status+0x174>
474d4: 601a bras 474f0 <_Heap_Walk+0xda>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
474d6: 70fe moveq #-2,%d0
474d8: 2047 moveal %d7,%a0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
474da: 2847 moveal %d7,%a4
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
474dc: c0a8 0004 andl %a0@(4),%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
474e0: d9c0 addal %d0,%a4
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
474e2: 7001 moveq #1,%d0
474e4: c0ac 0004 andl %a4@(4),%d0
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
474e8: 6616 bnes 47500 <_Heap_Walk+0xea>
(*printer)(
474ea: 4879 0005 d210 pea 5d210 <_Status_Object_name_errors_to_status+0x1a2>
474f0: 4878 0001 pea 1 <ADD>
474f4: 2f02 movel %d2,%sp@-
474f6: 4e92 jsr %a2@
474f8: 4fef 000c lea %sp@(12),%sp
474fc: 6000 009e braw 4759c <_Heap_Walk+0x186>
);
return false;
}
if (
47500: bc8c cmpl %a4,%d6
47502: 6708 beqs 4750c <_Heap_Walk+0xf6>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
47504: 4879 0005 d225 pea 5d225 <_Status_Object_name_errors_to_status+0x1b7>
4750a: 60e4 bras 474f0 <_Heap_Walk+0xda>
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
4750c: 262b 0010 movel %a3@(16),%d3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
47510: 220b movel %a3,%d1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
47512: 206b 0008 moveal %a3@(8),%a0
47516: 2d44 fff8 movel %d4,%fp@(-8)
4751a: 2d43 fffc movel %d3,%fp@(-4)
4751e: 6000 0088 braw 475a8 <_Heap_Walk+0x192>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
47522: b1eb 0020 cmpal %a3@(32),%a0
47526: 650c bcss 47534 <_Heap_Walk+0x11e>
47528: b1eb 0024 cmpal %a3@(36),%a0
4752c: 53c0 sls %d0
4752e: 49c0 extbl %d0
47530: 4480 negl %d0
47532: 6002 bras 47536 <_Heap_Walk+0x120>
47534: 4280 clrl %d0
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
47536: 4a00 tstb %d0
47538: 660c bnes 47546 <_Heap_Walk+0x130>
(*printer)(
4753a: 2f08 movel %a0,%sp@-
4753c: 4879 0005 d254 pea 5d254 <_Status_Object_name_errors_to_status+0x1e6>
47542: 6000 021a braw 4775e <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
47546: 4be8 0008 lea %a0@(8),%a5
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4754a: 200d movel %a5,%d0
4754c: 262e fffc movel %fp@(-4),%d3
47550: 4c43 0004 remul %d3,%d4,%d0
);
return false;
}
if (
47554: 4a84 tstl %d4
47556: 670c beqs 47564 <_Heap_Walk+0x14e>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
47558: 2f08 movel %a0,%sp@-
4755a: 4879 0005 d274 pea 5d274 <_Status_Object_name_errors_to_status+0x206>
47560: 6000 01fc braw 4775e <_Heap_Walk+0x348>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
47564: 70fe moveq #-2,%d0
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
47566: 7601 moveq #1,%d3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
47568: c0a8 0004 andl %a0@(4),%d0
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4756c: c6b0 0804 andl %a0@(00000004,%d0:l),%d3
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
47570: 670c beqs 4757e <_Heap_Walk+0x168>
(*printer)(
47572: 2f08 movel %a0,%sp@-
47574: 4879 0005 d2a4 pea 5d2a4 <_Status_Object_name_errors_to_status+0x236>
4757a: 6000 01e2 braw 4775e <_Heap_Walk+0x348>
);
return false;
}
if ( free_block->prev != prev_block ) {
4757e: 2028 000c movel %a0@(12),%d0
47582: b280 cmpl %d0,%d1
47584: 671c beqs 475a2 <_Heap_Walk+0x18c>
(*printer)(
47586: 2f00 movel %d0,%sp@-
47588: 2f08 movel %a0,%sp@-
4758a: 4879 0005 d2c0 pea 5d2c0 <_Status_Object_name_errors_to_status+0x252>
47590: 4878 0001 pea 1 <ADD>
47594: 2f02 movel %d2,%sp@-
47596: 4e92 jsr %a2@
47598: 4fef 0014 lea %sp@(20),%sp
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4759c: 4200 clrb %d0
4759e: 6000 01ac braw 4774c <_Heap_Walk+0x336>
return false;
}
prev_block = free_block;
free_block = free_block->next;
475a2: 2208 movel %a0,%d1
475a4: 2068 0008 moveal %a0@(8),%a0
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
475a8: b7c8 cmpal %a0,%a3
475aa: 6600 ff76 bnew 47522 <_Heap_Walk+0x10c>
475ae: 282e fff8 movel %fp@(-8),%d4
475b2: 6002 bras 475b6 <_Heap_Walk+0x1a0>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
475b4: 284d moveal %a5,%a4
return true;
}
475b6: 202c 0004 movel %a4@(4),%d0
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
475ba: 76fe moveq #-2,%d3
475bc: c680 andl %d0,%d3
475be: 2d40 fffc movel %d0,%fp@(-4)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
475c2: 4bf4 3800 lea %a4@(00000000,%d3:l),%a5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
475c6: bbeb 0020 cmpal %a3@(32),%a5
475ca: 650c bcss 475d8 <_Heap_Walk+0x1c2> <== NEVER TAKEN
475cc: bbeb 0024 cmpal %a3@(36),%a5
475d0: 53c0 sls %d0
475d2: 49c0 extbl %d0
475d4: 4480 negl %d0
475d6: 6002 bras 475da <_Heap_Walk+0x1c4>
475d8: 4280 clrl %d0 <== NOT EXECUTED
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
475da: 4a00 tstb %d0
475dc: 660c bnes 475ea <_Heap_Walk+0x1d4>
(*printer)(
475de: 2f0d movel %a5,%sp@-
475e0: 2f0c movel %a4,%sp@-
475e2: 4879 0005 d2f2 pea 5d2f2 <_Status_Object_name_errors_to_status+0x284>
475e8: 60a6 bras 47590 <_Heap_Walk+0x17a>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
475ea: be8c cmpl %a4,%d7
475ec: 56c0 sne %d0
475ee: 2200 movel %d0,%d1
475f0: 4481 negl %d1
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
475f2: 2003 movel %d3,%d0
475f4: 1d41 fffb moveb %d1,%fp@(-5)
475f8: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
475fc: 4a81 tstl %d1
475fe: 6714 beqs 47614 <_Heap_Walk+0x1fe>
47600: 4a2e fffb tstb %fp@(-5)
47604: 670e beqs 47614 <_Heap_Walk+0x1fe>
(*printer)(
47606: 2f03 movel %d3,%sp@-
47608: 2f0c movel %a4,%sp@-
4760a: 4879 0005 d31f pea 5d31f <_Status_Object_name_errors_to_status+0x2b1>
47610: 6000 ff7e braw 47590 <_Heap_Walk+0x17a>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
47614: ba83 cmpl %d3,%d5
47616: 6322 blss 4763a <_Heap_Walk+0x224>
47618: 4a2e fffb tstb %fp@(-5)
4761c: 671c beqs 4763a <_Heap_Walk+0x224> <== NEVER TAKEN
(*printer)(
4761e: 2f05 movel %d5,%sp@-
47620: 2f03 movel %d3,%sp@-
47622: 2f0c movel %a4,%sp@-
47624: 4879 0005 d34d pea 5d34d <_Status_Object_name_errors_to_status+0x2df>
4762a: 4878 0001 pea 1 <ADD>
4762e: 2f02 movel %d2,%sp@-
47630: 4e92 jsr %a2@
block,
block_size,
min_block_size
);
return false;
47632: 4fef 0018 lea %sp@(24),%sp
47636: 6000 ff64 braw 4759c <_Heap_Walk+0x186>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
4763a: b9cd cmpal %a5,%a4
4763c: 6514 bcss 47652 <_Heap_Walk+0x23c>
4763e: 4a2e fffb tstb %fp@(-5)
47642: 670e beqs 47652 <_Heap_Walk+0x23c>
(*printer)(
47644: 2f0d movel %a5,%sp@-
47646: 2f0c movel %a4,%sp@-
47648: 4879 0005 d378 pea 5d378 <_Status_Object_name_errors_to_status+0x30a>
4764e: 6000 ff40 braw 47590 <_Heap_Walk+0x17a>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
47652: 7001 moveq #1,%d0
47654: c0ae fffc andl %fp@(-4),%d0
47658: 2d40 fffc movel %d0,%fp@(-4)
4765c: 7001 moveq #1,%d0
4765e: c0ad 0004 andl %a5@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
47662: 6600 00ae bnew 47712 <_Heap_Walk+0x2fc>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
47666: 222b 0008 movel %a3@(8),%d1
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
4766a: 43f9 0005 d098 lea 5d098 <_Status_Object_name_errors_to_status+0x2a>,%a1
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
47670: 206c 0008 moveal %a4@(8),%a0
47674: 2d41 fff8 movel %d1,%fp@(-8)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
47678: b1eb 000c cmpal %a3@(12),%a0
4767c: 6710 beqs 4768e <_Heap_Walk+0x278>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
4767e: 43f9 0005 cfe0 lea 5cfe0 <rtems_filesystem_default_pathconf+0xb4>,%a1
47684: b7c8 cmpal %a0,%a3
47686: 6606 bnes 4768e <_Heap_Walk+0x278>
47688: 43f9 0005 d0a7 lea 5d0a7 <_Status_Object_name_errors_to_status+0x39>,%a1
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
4768e: 202c 000c movel %a4@(12),%d0
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
47692: 223c 0005 d0b1 movel #381105,%d1
47698: b0ae fff8 cmpl %fp@(-8),%d0
4769c: 6710 beqs 476ae <_Heap_Walk+0x298>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
4769e: 223c 0005 cfe0 movel #380896,%d1
476a4: b7c0 cmpal %d0,%a3
476a6: 6606 bnes 476ae <_Heap_Walk+0x298>
476a8: 223c 0005 d0c1 movel #381121,%d1
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
476ae: 2f09 movel %a1,%sp@-
476b0: 2f08 movel %a0,%sp@-
476b2: 2f01 movel %d1,%sp@-
476b4: 2f00 movel %d0,%sp@-
476b6: 2f03 movel %d3,%sp@-
476b8: 2f0c movel %a4,%sp@-
476ba: 4879 0005 d3ac pea 5d3ac <_Status_Object_name_errors_to_status+0x33e>
476c0: 42a7 clrl %sp@-
476c2: 2f02 movel %d2,%sp@-
476c4: 4e92 jsr %a2@
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
476c6: 2015 movel %a5@,%d0
476c8: 4fef 0024 lea %sp@(36),%sp
476cc: b083 cmpl %d3,%d0
476ce: 671e beqs 476ee <_Heap_Walk+0x2d8>
(*printer)(
476d0: 2f0d movel %a5,%sp@-
476d2: 2f00 movel %d0,%sp@-
476d4: 2f03 movel %d3,%sp@-
476d6: 2f0c movel %a4,%sp@-
476d8: 4879 0005 d3e1 pea 5d3e1 <_Status_Object_name_errors_to_status+0x373>
476de: 4878 0001 pea 1 <ADD>
476e2: 2f02 movel %d2,%sp@-
476e4: 4e92 jsr %a2@
476e6: 4fef 001c lea %sp@(28),%sp
476ea: 6000 feb0 braw 4759c <_Heap_Walk+0x186>
);
return false;
}
if ( !prev_used ) {
476ee: 4aae fffc tstl %fp@(-4)
476f2: 660a bnes 476fe <_Heap_Walk+0x2e8>
(*printer)(
476f4: 2f0c movel %a4,%sp@-
476f6: 4879 0005 d41a pea 5d41a <_Status_Object_name_errors_to_status+0x3ac>
476fc: 6060 bras 4775e <_Heap_Walk+0x348>
476fe: 206b 0008 moveal %a3@(8),%a0
47702: 6008 bras 4770c <_Heap_Walk+0x2f6>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
47704: b9c8 cmpal %a0,%a4
47706: 673c beqs 47744 <_Heap_Walk+0x32e>
return true;
}
free_block = free_block->next;
47708: 2068 0008 moveal %a0@(8),%a0
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
4770c: b7c8 cmpal %a0,%a3
4770e: 66f4 bnes 47704 <_Heap_Walk+0x2ee>
47710: 6044 bras 47756 <_Heap_Walk+0x340>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
47712: 4aae fffc tstl %fp@(-4)
47716: 6716 beqs 4772e <_Heap_Walk+0x318>
(*printer)(
47718: 2f03 movel %d3,%sp@-
4771a: 2f0c movel %a4,%sp@-
4771c: 4879 0005 d449 pea 5d449 <_Status_Object_name_errors_to_status+0x3db>
47722: 42a7 clrl %sp@-
47724: 2f02 movel %d2,%sp@-
47726: 4e92 jsr %a2@
47728: 4fef 0014 lea %sp@(20),%sp
4772c: 6016 bras 47744 <_Heap_Walk+0x32e>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4772e: 2f14 movel %a4@,%sp@-
47730: 2f03 movel %d3,%sp@-
47732: 2f0c movel %a4,%sp@-
47734: 4879 0005 d460 pea 5d460 <_Status_Object_name_errors_to_status+0x3f2>
4773a: 42a7 clrl %sp@-
4773c: 2f02 movel %d2,%sp@-
4773e: 4e92 jsr %a2@
47740: 4fef 0018 lea %sp@(24),%sp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
47744: bc8d cmpl %a5,%d6
47746: 6600 fe6c bnew 475b4 <_Heap_Walk+0x19e>
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
4774a: 7001 moveq #1,%d0
block = next_block;
} while ( block != first_block );
return true;
}
4774c: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
47752: 4e5e unlk %fp
47754: 4e75 rts
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
47756: 2f0c movel %a4,%sp@-
47758: 4879 0005 d485 pea 5d485 <_Status_Object_name_errors_to_status+0x417>
4775e: 4878 0001 pea 1 <ADD>
47762: 2f02 movel %d2,%sp@-
47764: 4e92 jsr %a2@
47766: 4fef 0010 lea %sp@(16),%sp
4776a: 6000 fe30 braw 4759c <_Heap_Walk+0x186>
...
00046bdc <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
46bdc: 4e56 0000 linkw %fp,#0
46be0: 222e 000c movel %fp@(12),%d1
46be4: 2f02 movel %d2,%sp@-
46be6: 242e 0010 movel %fp@(16),%d2
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
46bea: 13c1 0005 ec32 moveb %d1,5ec32 <_Internal_errors_What_happened+0x4>
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
46bf0: 2f02 movel %d2,%sp@-
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
46bf2: 202e 0008 movel %fp@(8),%d0
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
46bf6: 0281 0000 00ff andil #255,%d1
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
46bfc: 23c0 0005 ec2e movel %d0,5ec2e <_Internal_errors_What_happened>
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
46c02: 2f01 movel %d1,%sp@-
)
{
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
46c04: 23c2 0005 ec34 movel %d2,5ec34 <_Internal_errors_What_happened+0x6>
_User_extensions_Fatal( the_source, is_internal, the_error );
46c0a: 2f00 movel %d0,%sp@-
46c0c: 4eb9 0004 884a jsr 4884a <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
46c12: 7005 moveq #5,%d0
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
46c14: 2042 moveal %d2,%a0
46c16: 243c 0000 0700 movel #1792,%d2
46c1c: 23c0 0005 ecdc movel %d0,5ecdc <_System_state_Current>
46c22: 40c0 movew %sr,%d0
46c24: 8082 orl %d2,%d0
46c26: 46c0 movew %d0,%sr
46c28: 2008 movel %a0,%d0 <== NOT EXECUTED
46c2a: 223c dead beef movel #-559038737,%d1 <== NOT EXECUTED
46c30: 4ac8 halt <== NOT EXECUTED
46c32: 4fef 000c lea %sp@(12),%sp
46c36: 60fe bras 46c36 <_Internal_error_Occurred+0x5a>
00046c98 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
46c98: 4e56 fff0 linkw %fp,#-16
46c9c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
46ca0: 246e 0008 moveal %fp@(8),%a2
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
46ca4: 4aaa 0014 tstl %a2@(20)
46ca8: 675e beqs 46d08 <_Objects_Allocate+0x70> <== NEVER TAKEN
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
46caa: 240a movel %a2,%d2
46cac: 0682 0000 001c addil #28,%d2
46cb2: 47f9 0004 6414 lea 46414 <_Chain_Get>,%a3
46cb8: 2f02 movel %d2,%sp@-
46cba: 4e93 jsr %a3@
if ( information->auto_extend ) {
46cbc: 588f addql #4,%sp
46cbe: 4a2a 0010 tstb %a2@(16)
46cc2: 6746 beqs 46d0a <_Objects_Allocate+0x72>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
46cc4: 4a80 tstl %d0
46cc6: 6612 bnes 46cda <_Objects_Allocate+0x42>
_Objects_Extend_information( information );
46cc8: 2f0a movel %a2,%sp@-
46cca: 4eb9 0004 6d3c jsr 46d3c <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
46cd0: 2f02 movel %d2,%sp@-
46cd2: 4e93 jsr %a3@
}
if ( the_object ) {
46cd4: 508f addql #8,%sp
46cd6: 4a80 tstl %d0
46cd8: 6730 beqs 46d0a <_Objects_Allocate+0x72>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46cda: 2040 moveal %d0,%a0
46cdc: 4281 clrl %d1
46cde: 4282 clrl %d2
46ce0: 3228 000a movew %a0@(10),%d1
46ce4: 342a 0008 movew %a2@(8),%d2
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
46ce8: 206a 002a moveal %a2@(42),%a0
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46cec: 9282 subl %d2,%d1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
46cee: 342a 0012 movew %a2@(18),%d2
46cf2: 4c42 1001 remul %d2,%d1,%d1
information->inactive_per_block[ block ]--;
46cf6: e589 lsll #2,%d1
46cf8: d1c1 addal %d1,%a0
46cfa: 5390 subql #1,%a0@
information->inactive--;
46cfc: 322a 0028 movew %a2@(40),%d1
46d00: 5381 subql #1,%d1
46d02: 3541 0028 movew %d1,%a2@(40)
46d06: 6002 bras 46d0a <_Objects_Allocate+0x72>
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
return NULL;
46d08: 4280 clrl %d0 <== NOT EXECUTED
);
}
#endif
return the_object;
}
46d0a: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
46d10: 4e5e unlk %fp <== NOT EXECUTED
00046d14 <_Objects_Close>:
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46d14: 4280 clrl %d0
void _Objects_Close(
Objects_Information *information,
Objects_Control *the_object
)
{
46d16: 4e56 0000 linkw %fp,#0
46d1a: 206e 0008 moveal %fp@(8),%a0
46d1e: 226e 000c moveal %fp@(12),%a1
46d22: 2f0a movel %a2,%sp@-
46d24: 2468 0018 moveal %a0@(24),%a2
46d28: 3029 000a movew %a1@(10),%d0
46d2c: 42b2 0c00 clrl %a2@(00000000,%d0:l:4)
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
}
46d30: 245f moveal %sp@+,%a2
46d32: 4e5e unlk %fp
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
46d34: 4ef9 0004 725c jmp 4725c <_Objects_Namespace_remove>
...
00047044 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
47044: 4e56 0000 linkw %fp,#0
47048: 2f03 movel %d3,%sp@-
4704a: 362e 000e movew %fp@(14),%d3
4704e: 2f02 movel %d2,%sp@-
47050: 242e 0008 movel %fp@(8),%d2
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
47054: 4a43 tstw %d3
47056: 673a beqs 47092 <_Objects_Get_information+0x4e>
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
47058: 2f02 movel %d2,%sp@-
4705a: 4eb9 0004 b288 jsr 4b288 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
47060: 588f addql #4,%sp
47062: 4a80 tstl %d0
47064: 672c beqs 47092 <_Objects_Get_information+0x4e>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
47066: 0283 0000 ffff andil #65535,%d3
4706c: b083 cmpl %d3,%d0
4706e: 6522 bcss 47092 <_Objects_Get_information+0x4e>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
47070: 41f9 0005 eb54 lea 5eb54 <_Objects_Information_table>,%a0
47076: 2070 2c00 moveal %a0@(00000000,%d2:l:4),%a0
4707a: 4a88 tstl %a0
4707c: 6714 beqs 47092 <_Objects_Get_information+0x4e> <== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
4707e: 2030 3c00 movel %a0@(00000000,%d3:l:4),%d0
if ( !info )
47082: 6710 beqs 47094 <_Objects_Get_information+0x50> <== NEVER TAKEN
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
return NULL;
47084: 2040 moveal %d0,%a0
47086: 4a68 000e tstw %a0@(14)
4708a: 56c1 sne %d1
4708c: 49c1 extbl %d1
4708e: c081 andl %d1,%d0
47090: 6002 bras 47094 <_Objects_Get_information+0x50>
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
return NULL;
47092: 4280 clrl %d0
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
47094: 242e fff8 movel %fp@(-8),%d2
47098: 262e fffc movel %fp@(-4),%d3
4709c: 4e5e unlk %fp <== NOT EXECUTED
00053df4 <_Objects_Get_no_protection>:
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
53df4: 7001 moveq #1,%d0
if ( information->maximum >= index ) {
53df6: 4281 clrl %d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
53df8: 4e56 0000 linkw %fp,#0
53dfc: 206e 0008 moveal %fp@(8),%a0
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
53e00: 90a8 0006 subl %a0@(6),%d0
53e04: d0ae 000c addl %fp@(12),%d0
if ( information->maximum >= index ) {
53e08: 3228 000e movew %a0@(14),%d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
53e0c: 226e 0010 moveal %fp@(16),%a1
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
if ( information->maximum >= index ) {
53e10: b081 cmpl %d1,%d0
53e12: 620e bhis 53e22 <_Objects_Get_no_protection+0x2e>
if ( (the_object = information->local_table[ index ]) != NULL ) {
53e14: 2068 0018 moveal %a0@(24),%a0
53e18: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
53e1c: 6704 beqs 53e22 <_Objects_Get_no_protection+0x2e><== NEVER TAKEN
*location = OBJECTS_LOCAL;
53e1e: 4291 clrl %a1@
return the_object;
53e20: 6006 bras 53e28 <_Objects_Get_no_protection+0x34>
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
53e22: 7001 moveq #1,%d0
53e24: 2280 movel %d0,%a1@
return NULL;
53e26: 4280 clrl %d0
}
53e28: 4e5e unlk %fp <== NOT EXECUTED
000477fc <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
477fc: 4e56 fffc linkw %fp,#-4
47800: 222e 0008 movel %fp@(8),%d1
47804: 2f02 movel %d2,%sp@-
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
47806: 4a81 tstl %d1
47808: 660a bnes 47814 <_Objects_Id_to_name+0x18>
4780a: 2079 0005 ff62 moveal 5ff62 <_Per_CPU_Information+0xc>,%a0
47810: 2228 0008 movel %a0@(8),%d1
47814: 7418 moveq #24,%d2
47816: 2001 movel %d1,%d0
47818: e4a8 lsrl %d2,%d0
4781a: 143c 0007 moveb #7,%d2
4781e: c082 andl %d2,%d0
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47820: 143c 0002 moveb #2,%d2
47824: 2040 moveal %d0,%a0
47826: 5388 subql #1,%a0
47828: b488 cmpl %a0,%d2
4782a: 6540 bcss 4786c <_Objects_Id_to_name+0x70> <== NEVER TAKEN
4782c: 6048 bras 47876 <_Objects_Id_to_name+0x7a>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
4782e: 2001 movel %d1,%d0
47830: 741b moveq #27,%d2
47832: e4a8 lsrl %d2,%d0
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
47834: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
if ( !information )
47838: 4a88 tstl %a0
4783a: 6730 beqs 4786c <_Objects_Id_to_name+0x70> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
4783c: 4a28 0032 tstb %a0@(50)
47840: 662a bnes 4786c <_Objects_Id_to_name+0x70> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
47842: 486e fffc pea %fp@(-4)
47846: 2f01 movel %d1,%sp@-
47848: 2f08 movel %a0,%sp@-
4784a: 4eb9 0004 7794 jsr 47794 <_Objects_Get>
if ( !the_object )
47850: 4fef 000c lea %sp@(12),%sp
47854: 4a80 tstl %d0
47856: 6714 beqs 4786c <_Objects_Id_to_name+0x70>
return OBJECTS_INVALID_ID;
*name = the_object->name;
47858: 206e 000c moveal %fp@(12),%a0
4785c: 2240 moveal %d0,%a1
4785e: 20a9 000c movel %a1@(12),%a0@
_Thread_Enable_dispatch();
47862: 4eb9 0004 8434 jsr 48434 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
47868: 4280 clrl %d0
4786a: 6002 bras 4786e <_Objects_Id_to_name+0x72>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
4786c: 7003 moveq #3,%d0
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
4786e: 242e fff8 movel %fp@(-8),%d2
47872: 4e5e unlk %fp
47874: 4e75 rts
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
47876: 41f9 0005 fabc lea 5fabc <_Objects_Information_table>,%a0
4787c: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
47880: 4a88 tstl %a0
47882: 66aa bnes 4782e <_Objects_Id_to_name+0x32>
47884: 60e6 bras 4786c <_Objects_Id_to_name+0x70>
...
00047288 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
47288: 4e56 fff4 linkw %fp,#-12
4728c: 226e 0008 moveal %fp@(8),%a1
47290: 48d7 040c moveml %d2-%d3/%a2,%sp@
47294: 242e 000c movel %fp@(12),%d2
47298: 202e 0010 movel %fp@(16),%d0
4729c: 246e 0014 moveal %fp@(20),%a2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
472a0: 4a8a tstl %a2
472a2: 674a beqs 472ee <_Objects_Name_to_id_u32+0x66>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
472a4: 4a82 tstl %d2
472a6: 674a beqs 472f2 <_Objects_Name_to_id_u32+0x6a> <== NEVER TAKEN
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
472a8: 3229 000e movew %a1@(14),%d1
472ac: 6744 beqs 472f2 <_Objects_Name_to_id_u32+0x6a>
472ae: 4a80 tstl %d0
472b0: 672e beqs 472e0 <_Objects_Name_to_id_u32+0x58>
(node == OBJECTS_SEARCH_ALL_NODES ||
472b2: 0c80 7fff ffff cmpil #2147483647,%d0
472b8: 6726 beqs 472e0 <_Objects_Name_to_id_u32+0x58>
node == OBJECTS_SEARCH_LOCAL_NODE ||
472ba: 7601 moveq #1,%d3
472bc: b680 cmpl %d0,%d3
472be: 6632 bnes 472f2 <_Objects_Name_to_id_u32+0x6a> <== NEVER TAKEN
472c0: 601e bras 472e0 <_Objects_Name_to_id_u32+0x58>
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
472c2: 2069 0018 moveal %a1@(24),%a0
472c6: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
if ( !the_object )
472ca: 4a88 tstl %a0
472cc: 670e beqs 472dc <_Objects_Name_to_id_u32+0x54>
continue;
if ( name == the_object->name.name_u32 ) {
472ce: b4a8 000c cmpl %a0@(12),%d2
472d2: 6608 bnes 472dc <_Objects_Name_to_id_u32+0x54>
*id = the_object->id;
472d4: 24a8 0008 movel %a0@(8),%a2@
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
472d8: 4280 clrl %d0
472da: 6018 bras 472f4 <_Objects_Name_to_id_u32+0x6c>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
472dc: 5280 addql #1,%d0
472de: 6008 bras 472e8 <_Objects_Name_to_id_u32+0x60>
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
472e0: 7001 moveq #1,%d0
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
472e2: 0281 0000 ffff andil #65535,%d1
472e8: b280 cmpl %d0,%d1
472ea: 64d6 bccs 472c2 <_Objects_Name_to_id_u32+0x3a>
472ec: 6004 bras 472f2 <_Objects_Name_to_id_u32+0x6a>
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
472ee: 7002 moveq #2,%d0
472f0: 6002 bras 472f4 <_Objects_Name_to_id_u32+0x6c>
return OBJECTS_INVALID_NAME;
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
472f2: 7001 moveq #1,%d0
#endif
}
472f4: 4cd7 040c moveml %sp@,%d2-%d3/%a2
472f8: 4e5e unlk %fp <== NOT EXECUTED
00047470 <_Objects_Set_name>:
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
47470: 4280 clrl %d0
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
47472: 4e56 ffec linkw %fp,#-20
47476: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
4747a: 2a6e 0008 moveal %fp@(8),%a5
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
4747e: 302d 0034 movew %a5@(52),%d0
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
47482: 246e 0010 moveal %fp@(16),%a2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
47486: 2f00 movel %d0,%sp@-
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
47488: 286e 000c moveal %fp@(12),%a4
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
4748c: 2f0a movel %a2,%sp@-
4748e: 4eb9 0004 e6f8 jsr 4e6f8 <strnlen>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
47494: 508f addql #8,%sp
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
47496: 2640 moveal %d0,%a3
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
47498: 4a2d 0032 tstb %a5@(50)
4749c: 673c beqs 474da <_Objects_Set_name+0x6a>
char *d;
d = _Workspace_Allocate( length + 1 );
4749e: 486b 0001 pea %a3@(1)
474a2: 4eb9 0004 8e4c jsr 48e4c <_Workspace_Allocate>
if ( !d )
474a8: 588f addql #4,%sp
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
474aa: 2a40 moveal %d0,%a5
if ( !d )
474ac: 4a80 tstl %d0
474ae: 677a beqs 4752a <_Objects_Set_name+0xba> <== NEVER TAKEN
return false;
_Workspace_Free( (void *)the_object->name.name_p );
474b0: 2f2c 000c movel %a4@(12),%sp@-
474b4: 4eb9 0004 8e68 jsr 48e68 <_Workspace_Free>
the_object->name.name_p = NULL;
474ba: 42ac 000c clrl %a4@(12)
strncpy( d, name, length );
474be: 2f0b movel %a3,%sp@-
474c0: 2f0a movel %a2,%sp@-
474c2: 2f0d movel %a5,%sp@-
474c4: 4eb9 0004 e670 jsr 4e670 <strncpy>
d[length] = '\0';
the_object->name.name_p = d;
474ca: 4fef 0010 lea %sp@(16),%sp
_Workspace_Free( (void *)the_object->name.name_p );
the_object->name.name_p = NULL;
strncpy( d, name, length );
d[length] = '\0';
474ce: 4200 clrb %d0
474d0: 1b80 b800 moveb %d0,%a5@(00000000,%a3:l)
the_object->name.name_p = d;
474d4: 294d 000c movel %a5,%a4@(12)
474d8: 604c bras 47526 <_Objects_Set_name+0xb6>
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
474da: 7418 moveq #24,%d2
474dc: 1212 moveb %a2@,%d1
474de: 7020 moveq #32,%d0
474e0: 4840 swap %d0
474e2: 49c1 extbl %d1
474e4: e5a9 lsll %d2,%d1
474e6: 143c 0001 moveb #1,%d2
474ea: b48b cmpl %a3,%d2
474ec: 640a bccs 474f8 <_Objects_Set_name+0x88>
474ee: 102a 0001 moveb %a2@(1),%d0
474f2: 49c0 extbl %d0
474f4: 4840 swap %d0
474f6: 4240 clrw %d0
474f8: 7402 moveq #2,%d2
474fa: 8280 orl %d0,%d1
474fc: 203c 0000 2000 movel #8192,%d0
47502: b48b cmpl %a3,%d2
47504: 6408 bccs 4750e <_Objects_Set_name+0x9e>
47506: 102a 0002 moveb %a2@(2),%d0
4750a: 49c0 extbl %d0
4750c: e188 lsll #8,%d0
4750e: 8081 orl %d1,%d0
47510: 7203 moveq #3,%d1
47512: b28b cmpl %a3,%d1
47514: 6408 bccs 4751e <_Objects_Set_name+0xae>
47516: 142a 0003 moveb %a2@(3),%d2
4751a: 49c2 extbl %d2
4751c: 6002 bras 47520 <_Objects_Set_name+0xb0>
4751e: 7420 moveq #32,%d2
47520: 8082 orl %d2,%d0
47522: 2940 000c movel %d0,%a4@(12)
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
47526: 7001 moveq #1,%d0
47528: 6002 bras 4752c <_Objects_Set_name+0xbc>
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
4752a: 4200 clrb %d0
);
}
return true;
}
4752c: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
47532: 4e5e unlk %fp
...
000458b0 <_POSIX_Keys_Free_memory>:
#include <rtems/posix/key.h>
void _POSIX_Keys_Free_memory(
POSIX_Keys_Control *the_key
)
{
458b0: 4e56 0000 linkw %fp,#0
458b4: 2f0b movel %a3,%sp@-
uint32_t the_api;
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ )
_Workspace_Free( the_key->Values[ the_api ] );
458b6: 47f9 0004 9910 lea 49910 <_Workspace_Free>,%a3
#include <rtems/posix/key.h>
void _POSIX_Keys_Free_memory(
POSIX_Keys_Control *the_key
)
{
458bc: 2f0a movel %a2,%sp@-
458be: 246e 0008 moveal %fp@(8),%a2
uint32_t the_api;
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ )
_Workspace_Free( the_key->Values[ the_api ] );
458c2: 2f2a 0018 movel %a2@(24),%sp@-
458c6: 4e93 jsr %a3@
458c8: 2f2a 001c movel %a2@(28),%sp@-
458cc: 4e93 jsr %a3@
458ce: 2d6a 0020 0008 movel %a2@(32),%fp@(8)
458d4: 508f addql #8,%sp
}
458d6: 246e fff8 moveal %fp@(-8),%a2
458da: 266e fffc moveal %fp@(-4),%a3
458de: 4e5e unlk %fp
)
{
uint32_t the_api;
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ )
_Workspace_Free( the_key->Values[ the_api ] );
458e0: 4ef9 0004 9910 jmp 49910 <_Workspace_Free>
...
0004c5a0 <_POSIX_Keys_Run_destructors>:
4c5a0: 7218 moveq #24,%d1
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
4c5a2: 4e56 ffe8 linkw %fp,#-24
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
4c5a6: 206e 0008 moveal %fp@(8),%a0
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
4c5aa: 48d7 047c moveml %d2-%d6/%a2,%sp@
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
4c5ae: 2428 0008 movel %a0@(8),%d2
4c5b2: 2002 movel %d2,%d0
4c5b4: e2a8 lsrl %d1,%d0
4c5b6: 123c 0007 moveb #7,%d1
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
4c5ba: 0282 0000 ffff andil #65535,%d2
4c5c0: c081 andl %d1,%d0
4c5c2: e58a lsll #2,%d2
4c5c4: 2a00 movel %d0,%d5
4c5c6: 5a85 addql #5,%d5
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
4c5c8: 4286 clrl %d6
4c5ca: 7601 moveq #1,%d3
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
4c5cc: 7201 moveq #1,%d1
for ( index = 1 ; index <= max ; ++index ) {
4c5ce: 3c39 0005 eeee movew 5eeee <_POSIX_Keys_Information+0xe>,%d6
4c5d4: 6030 bras 4c606 <_POSIX_Keys_Run_destructors+0x66>
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
4c5d6: 2079 0005 eef8 moveal 5eef8 <_POSIX_Keys_Information+0x18>,%a0
4c5dc: 2070 4c00 moveal %a0@(00000000,%d4:l:4),%a0
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
4c5e0: 4a88 tstl %a0
4c5e2: 6720 beqs 4c604 <_POSIX_Keys_Run_destructors+0x64>
4c5e4: 4aa8 0010 tstl %a0@(16)
4c5e8: 671a beqs 4c604 <_POSIX_Keys_Run_destructors+0x64>
void *value = key->Values [ thread_api ][ thread_index ];
4c5ea: 2470 5c00 moveal %a0@(00000000,%d5:l:4),%a2
4c5ee: d5c2 addal %d2,%a2
4c5f0: 2252 moveal %a2@,%a1
if ( value != NULL ) {
4c5f2: 4a89 tstl %a1
4c5f4: 670e beqs 4c604 <_POSIX_Keys_Run_destructors+0x64><== ALWAYS TAKEN
key->Values [ thread_api ][ thread_index ] = NULL;
4c5f6: 4292 clrl %a2@ <== NOT EXECUTED
(*key->destructor)( value );
4c5f8: 2f09 movel %a1,%sp@- <== NOT EXECUTED
4c5fa: 2068 0010 moveal %a0@(16),%a0 <== NOT EXECUTED
4c5fe: 4e90 jsr %a0@ <== NOT EXECUTED
4c600: 588f addql #4,%sp <== NOT EXECUTED
done = false;
4c602: 4201 clrb %d1 <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
4c604: 5283 addql #1,%d3
4c606: 4284 clrl %d4
4c608: 3803 movew %d3,%d4
4c60a: bc84 cmpl %d4,%d6
4c60c: 64c8 bccs 4c5d6 <_POSIX_Keys_Run_destructors+0x36>
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
4c60e: 4a01 tstb %d1
4c610: 67b6 beqs 4c5c8 <_POSIX_Keys_Run_destructors+0x28><== NEVER TAKEN
done = false;
}
}
}
}
}
4c612: 4cee 047c ffe8 moveml %fp@(-24),%d2-%d6/%a2
4c618: 4e5e unlk %fp <== NOT EXECUTED
00049fc0 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
49fc0: 4e56 ffe4 linkw %fp,#-28
49fc4: 48d7 043c moveml %d2-%d5/%a2,%sp@
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
49fc8: 486e fff8 pea %fp@(-8)
49fcc: 242e 0008 movel %fp@(8),%d2
49fd0: 2f02 movel %d2,%sp@-
49fd2: 4879 0006 7144 pea 67144 <_POSIX_Message_queue_Information_fds>
49fd8: 246e 0014 moveal %fp@(20),%a2
49fdc: 162e 001b moveb %fp@(27),%d3
49fe0: 4eb9 0004 ce3c jsr 4ce3c <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
49fe6: 4fef 000c lea %sp@(12),%sp
49fea: 4aae fff8 tstl %fp@(-8)
49fee: 6600 00be bnew 4a0ae <_POSIX_Message_queue_Receive_support+0xee>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
49ff2: 2040 moveal %d0,%a0
49ff4: 7803 moveq #3,%d4
49ff6: 7a01 moveq #1,%d5
49ff8: 2228 0014 movel %a0@(20),%d1
49ffc: c881 andl %d1,%d4
49ffe: ba84 cmpl %d4,%d5
4a000: 660a bnes 4a00c <_POSIX_Message_queue_Receive_support+0x4c>
_Thread_Enable_dispatch();
4a002: 4eb9 0004 dad0 jsr 4dad0 <_Thread_Enable_dispatch>
4a008: 6000 00a4 braw 4a0ae <_POSIX_Message_queue_Receive_support+0xee>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
4a00c: 2068 0010 moveal %a0@(16),%a0
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
4a010: 2028 0066 movel %a0@(102),%d0
4a014: b0ae 0010 cmpl %fp@(16),%d0
4a018: 6316 blss 4a030 <_POSIX_Message_queue_Receive_support+0x70>
_Thread_Enable_dispatch();
4a01a: 4eb9 0004 dad0 jsr 4dad0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
4a020: 4eb9 0005 3158 jsr 53158 <__errno>
4a026: 727a moveq #122,%d1
4a028: 2040 moveal %d0,%a0
4a02a: 2081 movel %d1,%a0@
4a02c: 6000 008c braw 4a0ba <_POSIX_Message_queue_Receive_support+0xfa>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
4a030: 70ff moveq #-1,%d0
4a032: 2d40 fffc movel %d0,%fp@(-4)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
4a036: 4a03 tstb %d3
4a038: 670a beqs 4a044 <_POSIX_Message_queue_Receive_support+0x84>
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
4a03a: 0801 000e btst #14,%d1
4a03e: 57c0 seq %d0
4a040: 4480 negl %d0
4a042: 6002 bras 4a046 <_POSIX_Message_queue_Receive_support+0x86>
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
4a044: 4200 clrb %d0
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
4a046: 2f2e 001c movel %fp@(28),%sp@-
4a04a: 0280 0000 00ff andil #255,%d0
4a050: 2f00 movel %d0,%sp@-
4a052: 486e fffc pea %fp@(-4)
4a056: 2f2e 000c movel %fp@(12),%sp@-
4a05a: 2f02 movel %d2,%sp@-
4a05c: 4868 001a pea %a0@(26)
4a060: 4eb9 0004 bf28 jsr 4bf28 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
4a066: 4eb9 0004 dad0 jsr 4dad0 <_Thread_Enable_dispatch>
4a06c: 2079 0006 71b6 moveal 671b6 <_Per_CPU_Information+0xc>,%a0
if (msg_prio) {
4a072: 4fef 0018 lea %sp@(24),%sp
4a076: 4a8a tstl %a2
4a078: 670a beqs 4a084 <_POSIX_Message_queue_Receive_support+0xc4><== NEVER TAKEN
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
4a07a: 2028 0024 movel %a0@(36),%d0
4a07e: 6c02 bges 4a082 <_POSIX_Message_queue_Receive_support+0xc2>
4a080: 4480 negl %d0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
4a082: 2480 movel %d0,%a2@
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
4a084: 4aa8 0034 tstl %a0@(52)
4a088: 6606 bnes 4a090 <_POSIX_Message_queue_Receive_support+0xd0>
return length_out;
4a08a: 202e fffc movel %fp@(-4),%d0
4a08e: 602c bras 4a0bc <_POSIX_Message_queue_Receive_support+0xfc>
rtems_set_errno_and_return_minus_one(
4a090: 4eb9 0005 3158 jsr 53158 <__errno>
4a096: 2079 0006 71b6 moveal 671b6 <_Per_CPU_Information+0xc>,%a0
4a09c: 2440 moveal %d0,%a2
4a09e: 2f28 0034 movel %a0@(52),%sp@-
4a0a2: 4eb9 0004 a2d8 jsr 4a2d8 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
4a0a8: 588f addql #4,%sp
4a0aa: 2480 movel %d0,%a2@
4a0ac: 600c bras 4a0ba <_POSIX_Message_queue_Receive_support+0xfa>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
4a0ae: 4eb9 0005 3158 jsr 53158 <__errno>
4a0b4: 2040 moveal %d0,%a0
4a0b6: 7009 moveq #9,%d0
4a0b8: 2080 movel %d0,%a0@
4a0ba: 70ff moveq #-1,%d0
}
4a0bc: 4cee 043c ffe4 moveml %fp@(-28),%d2-%d5/%a2
4a0c2: 4e5e unlk %fp
...
0004a450 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
4a450: 4e56 0000 linkw %fp,#0
4a454: 226e 0008 moveal %fp@(8),%a1
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a458: 2069 0102 moveal %a1@(258),%a0
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4a45c: 4aa8 00d8 tstl %a0@(216)
4a460: 6634 bnes 4a496 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x46><== NEVER TAKEN
4a462: 7001 moveq #1,%d0
4a464: b0a8 00dc cmpl %a0@(220),%d0
4a468: 662c bnes 4a496 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x46>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
4a46a: 4aa8 00e0 tstl %a0@(224)
4a46e: 6726 beqs 4a496 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x46>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
4a470: 2039 0005 f00c movel 5f00c <_Thread_Dispatch_disable_level>,%d0
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
4a476: 4878 ffff pea ffffffff <LESS>
4a47a: 5380 subql #1,%d0
4a47c: 23c0 0005 f00c movel %d0,5f00c <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
4a482: 2039 0005 f00c movel 5f00c <_Thread_Dispatch_disable_level>,%d0
4a488: 2f09 movel %a1,%sp@-
4a48a: 4eb9 0004 aab0 jsr 4aab0 <_POSIX_Thread_Exit>
4a490: 508f addql #8,%sp
} else
_Thread_Enable_dispatch();
}
4a492: 4e5e unlk %fp
4a494: 4e75 rts
4a496: 4e5e unlk %fp
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
4a498: 4ef9 0004 7eec jmp 47eec <_Thread_Enable_dispatch>
...
0004b58c <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4b58c: 4e56 ffec linkw %fp,#-20
4b590: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
4b594: 246e 000c moveal %fp@(12),%a2
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4b598: 2f12 movel %a2@,%sp@-
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4b59a: 242e 0008 movel %fp@(8),%d2
4b59e: 266e 0010 moveal %fp@(16),%a3
4b5a2: 286e 0014 moveal %fp@(20),%a4
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4b5a6: 4eb9 0004 b568 jsr 4b568 <_POSIX_Priority_Is_valid>
4b5ac: 588f addql #4,%sp
4b5ae: 4a00 tstb %d0
4b5b0: 677a beqs 4b62c <_POSIX_Thread_Translate_sched_param+0xa0><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4b5b2: 4293 clrl %a3@
*budget_callout = NULL;
4b5b4: 4294 clrl %a4@
if ( policy == SCHED_OTHER ) {
4b5b6: 4a82 tstl %d2
4b5b8: 6606 bnes 4b5c0 <_POSIX_Thread_Translate_sched_param+0x34>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4b5ba: 7401 moveq #1,%d2
4b5bc: 2682 movel %d2,%a3@
4b5be: 6068 bras 4b628 <_POSIX_Thread_Translate_sched_param+0x9c>
return 0;
}
if ( policy == SCHED_FIFO ) {
4b5c0: 7001 moveq #1,%d0
4b5c2: b082 cmpl %d2,%d0
4b5c4: 6762 beqs 4b628 <_POSIX_Thread_Translate_sched_param+0x9c>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4b5c6: 103c 0002 moveb #2,%d0
4b5ca: b082 cmpl %d2,%d0
4b5cc: 6608 bnes 4b5d6 <_POSIX_Thread_Translate_sched_param+0x4a>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4b5ce: 7202 moveq #2,%d1
return 0;
4b5d0: 4200 clrb %d0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4b5d2: 2681 movel %d1,%a3@
return 0;
4b5d4: 6058 bras 4b62e <_POSIX_Thread_Translate_sched_param+0xa2>
}
if ( policy == SCHED_SPORADIC ) {
4b5d6: 7004 moveq #4,%d0
4b5d8: b082 cmpl %d2,%d0
4b5da: 6650 bnes 4b62c <_POSIX_Thread_Translate_sched_param+0xa0>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4b5dc: 4aaa 0008 tstl %a2@(8)
4b5e0: 6606 bnes 4b5e8 <_POSIX_Thread_Translate_sched_param+0x5c>
4b5e2: 4aaa 000c tstl %a2@(12)
4b5e6: 6744 beqs 4b62c <_POSIX_Thread_Translate_sched_param+0xa0><== NEVER TAKEN
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
4b5e8: 4aaa 0010 tstl %a2@(16)
4b5ec: 6606 bnes 4b5f4 <_POSIX_Thread_Translate_sched_param+0x68>
4b5ee: 4aaa 0014 tstl %a2@(20)
4b5f2: 6738 beqs 4b62c <_POSIX_Thread_Translate_sched_param+0xa0><== NEVER TAKEN
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4b5f4: 486a 0008 pea %a2@(8)
4b5f8: 4bf9 0004 94b8 lea 494b8 <_Timespec_To_ticks>,%a5
4b5fe: 4e95 jsr %a5@
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4b600: 486a 0010 pea %a2@(16)
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4b604: 2400 movel %d0,%d2
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4b606: 4e95 jsr %a5@
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4b608: 508f addql #8,%sp
4b60a: b082 cmpl %d2,%d0
4b60c: 621e bhis 4b62c <_POSIX_Thread_Translate_sched_param+0xa0>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
4b60e: 2f2a 0004 movel %a2@(4),%sp@-
4b612: 4eb9 0004 b568 jsr 4b568 <_POSIX_Priority_Is_valid>
4b618: 588f addql #4,%sp
4b61a: 4a00 tstb %d0
4b61c: 670e beqs 4b62c <_POSIX_Thread_Translate_sched_param+0xa0>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4b61e: 7003 moveq #3,%d0
4b620: 2680 movel %d0,%a3@
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4b622: 28bc 0004 5f02 movel #286466,%a4@
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
4b628: 4280 clrl %d0
4b62a: 6002 bras 4b62e <_POSIX_Thread_Translate_sched_param+0xa2>
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
4b62c: 7016 moveq #22,%d0
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
4b62e: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
4b634: 4e5e unlk %fp <== NOT EXECUTED
0004a69a <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
4a69a: 4e56 ffec linkw %fp,#-20
4a69e: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@
4a6a2: 246e 000c moveal %fp@(12),%a2
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
4a6a6: 49f9 0004 807c lea 4807c <_Thread_queue_Dequeue>,%a4
{
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
4a6ac: 266a 0102 moveal %a2@(258),%a3
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
4a6b0: 240b movel %a3,%d2
4a6b2: 0682 0000 0044 addil #68,%d2
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
4a6b8: 2f0a movel %a2,%sp@-
4a6ba: 4eb9 0004 c538 jsr 4c538 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
4a6c0: 2f0a movel %a2,%sp@-
4a6c2: 4eb9 0004 c5a0 jsr 4c5a0 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
4a6c8: 262a 0028 movel %a2@(40),%d3
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
4a6cc: 508f addql #8,%sp
4a6ce: 6008 bras 4a6d8 <_POSIX_Threads_Delete_extension+0x3e>
*(void **)the_thread->Wait.return_argument = value_ptr;
4a6d0: 2240 moveal %d0,%a1 <== NOT EXECUTED
4a6d2: 2069 0028 moveal %a1@(40),%a0 <== NOT EXECUTED
4a6d6: 2083 movel %d3,%a0@ <== NOT EXECUTED
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
4a6d8: 2f02 movel %d2,%sp@-
4a6da: 4e94 jsr %a4@
4a6dc: 588f addql #4,%sp
4a6de: 4a80 tstl %d0
4a6e0: 66ee bnes 4a6d0 <_POSIX_Threads_Delete_extension+0x36><== NEVER TAKEN
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
4a6e2: 103c 0004 moveb #4,%d0
4a6e6: b0ab 0084 cmpl %a3@(132),%d0
4a6ea: 660c bnes 4a6f8 <_POSIX_Threads_Delete_extension+0x5e>
(void) _Watchdog_Remove( &api->Sporadic_timer );
4a6ec: 486b 00a8 pea %a3@(168)
4a6f0: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove>
4a6f6: 588f addql #4,%sp
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
4a6f8: 42aa 0102 clrl %a2@(258)
_Workspace_Free( api );
4a6fc: 2d4b 0008 movel %a3,%fp@(8)
}
4a700: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
4a706: 4e5e unlk %fp
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
_Workspace_Free( api );
4a708: 4ef9 0004 8c2c jmp 48c2c <_Workspace_Free>
00045c2c <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
45c2c: 4e56 ff98 linkw %fp,#-104
45c30: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
45c34: 2479 0005 e024 moveal 5e024 <Configuration_POSIX_API+0x34>,%a2
maximum = Configuration_POSIX_API.number_of_initialization_threads;
45c3a: 2839 0005 e020 movel 5e020 <Configuration_POSIX_API+0x30>,%d4
if ( !user_threads || maximum == 0 )
45c40: 4a8a tstl %a2
45c42: 676a beqs 45cae <_POSIX_Threads_Initialize_user_threads_body+0x82><== NEVER TAKEN
45c44: 4a84 tstl %d4
45c46: 6766 beqs 45cae <_POSIX_Threads_Initialize_user_threads_body+0x82><== NEVER TAKEN
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
45c48: 240e movel %fp,%d2
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
status = pthread_create(
45c4a: 2a0e movel %fp,%d5
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
maximum = Configuration_POSIX_API.number_of_initialization_threads;
if ( !user_threads || maximum == 0 )
45c4c: 4283 clrl %d3
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
45c4e: 0682 ffff ffbc addil #-68,%d2
45c54: 2c3c 0004 b638 movel #308792,%d6
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
45c5a: 4bf9 0004 b664 lea 4b664 <pthread_attr_setinheritsched>,%a5
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
45c60: 49f9 0004 b69c lea 4b69c <pthread_attr_setstacksize>,%a4
status = pthread_create(
45c66: 5985 subql #4,%d5
45c68: 47f9 0004 5904 lea 45904 <pthread_create>,%a3
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
45c6e: 2f02 movel %d2,%sp@-
45c70: 2046 moveal %d6,%a0
45c72: 4e90 jsr %a0@
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
45c74: 4878 0002 pea 2 <DOUBLE_FLOAT>
45c78: 2f02 movel %d2,%sp@-
45c7a: 4e95 jsr %a5@
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
45c7c: 2f2a 0004 movel %a2@(4),%sp@-
45c80: 2f02 movel %d2,%sp@-
45c82: 4e94 jsr %a4@
status = pthread_create(
45c84: 42a7 clrl %sp@-
45c86: 2f12 movel %a2@,%sp@-
45c88: 2f02 movel %d2,%sp@-
45c8a: 2f05 movel %d5,%sp@-
45c8c: 4e93 jsr %a3@
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
45c8e: 4fef 0024 lea %sp@(36),%sp
45c92: 4a80 tstl %d0
45c94: 6710 beqs 45ca6 <_POSIX_Threads_Initialize_user_threads_body+0x7a>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
45c96: 2f00 movel %d0,%sp@-
45c98: 4878 0001 pea 1 <ADD>
45c9c: 4878 0002 pea 2 <DOUBLE_FLOAT>
45ca0: 4eb9 0004 79a8 jsr 479a8 <_Internal_error_Occurred>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
45ca6: 5283 addql #1,%d3
45ca8: 508a addql #8,%a2
45caa: b883 cmpl %d3,%d4
45cac: 66c0 bnes 45c6e <_POSIX_Threads_Initialize_user_threads_body+0x42><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
45cae: 4cee 3c7c ff98 moveml %fp@(-104),%d2-%d6/%a2-%a5
45cb4: 4e5e unlk %fp <== NOT EXECUTED
0004a822 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
4a822: 4e56 0000 linkw %fp,#0
4a826: 2f0b movel %a3,%sp@-
4a828: 2f0a movel %a2,%sp@-
4a82a: 246e 000c moveal %fp@(12),%a2
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a82e: 266a 0102 moveal %a2@(258),%a3
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
4a832: 486b 0098 pea %a3@(152)
4a836: 4eb9 0004 b56c jsr 4b56c <_Timespec_To_ticks>
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4a83c: 588f addql #4,%sp
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
the_thread->cpu_time_budget = ticks;
4a83e: 2540 0076 movel %d0,%a2@(118)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
4a842: 4280 clrl %d0
4a844: 1039 0005 d1fa moveb 5d1fa <rtems_maximum_priority>,%d0
4a84a: 90ab 0088 subl %a3@(136),%d0
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
4a84e: 2540 0018 movel %d0,%a2@(24)
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4a852: 4aaa 001c tstl %a2@(28)
4a856: 6618 bnes 4a870 <_POSIX_Threads_Sporadic_budget_TSR+0x4e><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
4a858: b0aa 0014 cmpl %a2@(20),%d0
4a85c: 6412 bccs 4a870 <_POSIX_Threads_Sporadic_budget_TSR+0x4e>
_Thread_Change_priority( the_thread, new_priority, true );
4a85e: 4878 0001 pea 1 <ADD>
4a862: 2f00 movel %d0,%sp@-
4a864: 2f0a movel %a2,%sp@-
4a866: 4eb9 0004 7930 jsr 47930 <_Thread_Change_priority>
4a86c: 4fef 000c lea %sp@(12),%sp
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
4a870: 486b 0090 pea %a3@(144)
4a874: 4eb9 0004 b56c jsr 4b56c <_Timespec_To_ticks>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
4a87a: 246e fff8 moveal %fp@(-8),%a2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4a87e: 588f addql #4,%sp
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4a880: 2740 00b4 movel %d0,%a3@(180)
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
4a884: 47eb 00a8 lea %a3@(168),%a3
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4a888: 203c 0005 ec50 movel #388176,%d0
4a88e: 2d4b 000c movel %a3,%fp@(12)
}
4a892: 266e fffc moveal %fp@(-4),%a3
4a896: 2d40 0008 movel %d0,%fp@(8)
4a89a: 4e5e unlk %fp
4a89c: 4ef9 0004 8994 jmp 48994 <_Watchdog_Insert>
0004a8a2 <_POSIX_Threads_Sporadic_budget_callout>:
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
4a8a2: 70ff moveq #-1,%d0
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
4a8a4: 4e56 0000 linkw %fp,#0
4a8a8: 206e 0008 moveal %fp@(8),%a0
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
4a8ac: 2140 0076 movel %d0,%a0@(118)
4a8b0: 4280 clrl %d0
4a8b2: 1039 0005 d1fa moveb 5d1fa <rtems_maximum_priority>,%d0
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a8b8: 2268 0102 moveal %a0@(258),%a1
4a8bc: 90a9 008c subl %a1@(140),%d0
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
4a8c0: 2140 0018 movel %d0,%a0@(24)
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4a8c4: 4aa8 001c tstl %a0@(28)
4a8c8: 6618 bnes 4a8e2 <_POSIX_Threads_Sporadic_budget_callout+0x40><== NEVER TAKEN
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
4a8ca: b0a8 0014 cmpl %a0@(20),%d0
4a8ce: 6312 blss 4a8e2 <_POSIX_Threads_Sporadic_budget_callout+0x40><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
4a8d0: 4878 0001 pea 1 <ADD>
4a8d4: 2f00 movel %d0,%sp@-
4a8d6: 2f08 movel %a0,%sp@-
4a8d8: 4eb9 0004 7930 jsr 47930 <_Thread_Change_priority>
4a8de: 4fef 000c lea %sp@(12),%sp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
4a8e2: 4e5e unlk %fp <== NOT EXECUTED
00045764 <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
45764: 4e56 0000 linkw %fp,#0
45768: 2f0a movel %a2,%sp@-
4576a: 246e 000c moveal %fp@(12),%a2
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
4576e: 52aa 0066 addql #1,%a2@(102)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
45772: 4aaa 0052 tstl %a2@(82)
45776: 6606 bnes 4577e <_POSIX_Timer_TSR+0x1a>
45778: 4aaa 0056 tstl %a2@(86)
4577c: 6736 beqs 457b4 <_POSIX_Timer_TSR+0x50> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
4577e: 2f0a movel %a2,%sp@-
45780: 4879 0004 5764 pea 45764 <_POSIX_Timer_TSR>
45786: 2f2a 0008 movel %a2@(8),%sp@-
4578a: 2f2a 0062 movel %a2@(98),%sp@-
4578e: 486a 0010 pea %a2@(16)
45792: 4eb9 0004 aff4 jsr 4aff4 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
45798: 4fef 0014 lea %sp@(20),%sp
4579c: 4a00 tstb %d0
4579e: 672e beqs 457ce <_POSIX_Timer_TSR+0x6a> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
457a0: 486a 006a pea %a2@(106)
457a4: 4eb9 0004 6cf4 jsr 46cf4 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
457aa: 588f addql #4,%sp
457ac: 7003 moveq #3,%d0
457ae: 1540 003c moveb %d0,%a2@(60)
457b2: 6006 bras 457ba <_POSIX_Timer_TSR+0x56>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
457b4: 7004 moveq #4,%d0 <== NOT EXECUTED
457b6: 1540 003c moveb %d0,%a2@(60) <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
457ba: 2f2a 0042 movel %a2@(66),%sp@-
457be: 2f2a 0038 movel %a2@(56),%sp@-
457c2: 4eb9 0004 abe0 jsr 4abe0 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
457c8: 508f addql #8,%sp
457ca: 42aa 0066 clrl %a2@(102)
}
457ce: 246e fffc moveal %fp@(-4),%a2
457d2: 4e5e unlk %fp
...
0004c61c <_POSIX_signals_Check_signal>:
{
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
4c61c: 4280 clrl %d0
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c61e: 4e56 ffb4 linkw %fp,#-76
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
4c622: 102e 0013 moveb %fp@(19),%d0
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c626: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
4c62a: 4878 0001 pea 1 <ADD>
4c62e: 2a0e movel %fp,%d5
4c630: 0685 ffff fff4 addil #-12,%d5
4c636: 2f00 movel %d0,%sp@-
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c638: 242e 000c movel %fp@(12),%d2
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
4c63c: 2f05 movel %d5,%sp@-
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c63e: 246e 0008 moveal %fp@(8),%a2
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
4c642: 2f02 movel %d2,%sp@-
4c644: 2f0a movel %a2,%sp@-
4c646: 4eb9 0004 c6f4 jsr 4c6f4 <_POSIX_signals_Clear_signals>
4c64c: 4fef 0014 lea %sp@(20),%sp
4c650: 4a00 tstb %d0
4c652: 6700 0092 beqw 4c6e6 <_POSIX_signals_Check_signal+0xca>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
4c656: 2002 movel %d2,%d0
4c658: 2602 movel %d2,%d3
4c65a: e588 lsll #2,%d0
4c65c: e98b lsll #4,%d3
4c65e: 9680 subl %d0,%d3
4c660: 2043 moveal %d3,%a0
4c662: d1fc 0005 f034 addal #389172,%a0
4c668: 7001 moveq #1,%d0
4c66a: 2668 0008 moveal %a0@(8),%a3
4c66e: b08b cmpl %a3,%d0
4c670: 6774 beqs 4c6e6 <_POSIX_signals_Check_signal+0xca><== NEVER TAKEN
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4c672: 2028 0004 movel %a0@(4),%d0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
4c676: 282a 00d0 movel %a2@(208),%d4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4c67a: 8084 orl %d4,%d0
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
4c67c: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
4c682: 41e8 0020 lea %a0@(32),%a0
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4c686: 2540 00d0 movel %d0,%a2@(208)
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
4c68a: 4878 0028 pea 28 <OPER2+0x14>
4c68e: 2f08 movel %a0,%sp@-
4c690: 486e ffcc pea %fp@(-52)
4c694: 4eb9 0004 d588 jsr 4d588 <memcpy>
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
4c69a: 4fef 000c lea %sp@(12),%sp
4c69e: 41f9 0005 f034 lea 5f034 <_POSIX_signals_Vectors>,%a0
4c6a4: 7002 moveq #2,%d0
4c6a6: b0b0 3800 cmpl %a0@(00000000,%d3:l),%d0
4c6aa: 660e bnes 4c6ba <_POSIX_signals_Check_signal+0x9e>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
4c6ac: 42a7 clrl %sp@-
4c6ae: 2f05 movel %d5,%sp@-
4c6b0: 2f02 movel %d2,%sp@-
4c6b2: 4e93 jsr %a3@
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
4c6b4: 4fef 000c lea %sp@(12),%sp
4c6b8: 6006 bras 4c6c0 <_POSIX_signals_Check_signal+0xa4>
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
4c6ba: 2f02 movel %d2,%sp@-
4c6bc: 4e93 jsr %a3@
break;
4c6be: 588f addql #4,%sp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
4c6c0: 4878 0028 pea 28 <OPER2+0x14>
4c6c4: 486e ffcc pea %fp@(-52)
4c6c8: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
4c6ce: 41e8 0020 lea %a0@(32),%a0
4c6d2: 2f08 movel %a0,%sp@-
4c6d4: 4eb9 0004 d588 jsr 4d588 <memcpy>
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
4c6da: 4fef 000c lea %sp@(12),%sp
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
4c6de: 2544 00d0 movel %d4,%a2@(208)
return true;
4c6e2: 7001 moveq #1,%d0
4c6e4: 6002 bras 4c6e8 <_POSIX_signals_Check_signal+0xcc>
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
return false;
4c6e6: 4200 clrb %d0
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
}
4c6e8: 4cee 0c3c ffb4 moveml %fp@(-76),%d2-%d5/%a2-%a3
4c6ee: 4e5e unlk %fp
...
0004cce0 <_POSIX_signals_Clear_process_signals>:
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4cce0: 203c 0000 0700 movel #1792,%d0
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
4cce6: 4e56 0000 linkw %fp,#0
4ccea: 222e 0008 movel %fp@(8),%d1
4ccee: 2f03 movel %d3,%sp@-
4ccf0: 2f02 movel %d2,%sp@-
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4ccf2: 40c2 movew %sr,%d2
4ccf4: 8082 orl %d2,%d0
4ccf6: 46c0 movew %d0,%sr
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4ccf8: 2601 movel %d1,%d3
4ccfa: 2001 movel %d1,%d0
4ccfc: 41f9 0005 f034 lea 5f034 <_POSIX_signals_Vectors>,%a0
4cd02: e58b lsll #2,%d3
4cd04: e988 lsll #4,%d0
4cd06: 9083 subl %d3,%d0
4cd08: 7602 moveq #2,%d3
4cd0a: b6b0 0800 cmpl %a0@(00000000,%d0:l),%d3
4cd0e: 6610 bnes 4cd20 <_POSIX_signals_Clear_process_signals+0x40>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
4cd10: 2040 moveal %d0,%a0
4cd12: d1fc 0005 f22c addal #389676,%a0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4cd18: 2008 movel %a0,%d0
4cd1a: 5880 addql #4,%d0
4cd1c: b090 cmpl %a0@,%d0
4cd1e: 660e bnes 4cd2e <_POSIX_signals_Clear_process_signals+0x4e><== NEVER TAKEN
4cd20: 5381 subql #1,%d1
4cd22: 7001 moveq #1,%d0
4cd24: e3a8 lsll %d1,%d0
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
4cd26: 4680 notl %d0
4cd28: c1b9 0005 f228 andl %d0,5f228 <_POSIX_signals_Pending>
}
_ISR_Enable( level );
4cd2e: 46c2 movew %d2,%sr
}
4cd30: 241f movel %sp@+,%d2
4cd32: 261f movel %sp@+,%d3
4cd34: 4e5e unlk %fp <== NOT EXECUTED
000462dc <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
462dc: 701b moveq #27,%d0
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
462de: 4e56 fff4 linkw %fp,#-12
462e2: 48d7 001c moveml %d2-%d4,%sp@
462e6: 242e 0008 movel %fp@(8),%d2
462ea: 7601 moveq #1,%d3
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
462ec: 2200 movel %d0,%d1
462ee: 5381 subql #1,%d1
462f0: 2803 movel %d3,%d4
462f2: e3ac lsll %d1,%d4
462f4: 2204 movel %d4,%d1
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
462f6: c282 andl %d2,%d1
462f8: 6626 bnes 46320 <_POSIX_signals_Get_lowest+0x44> <== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
462fa: 5280 addql #1,%d0
462fc: 123c 0020 moveb #32,%d1
46300: b280 cmpl %d0,%d1
46302: 66e8 bnes 462ec <_POSIX_signals_Get_lowest+0x10>
46304: 7001 moveq #1,%d0
46306: 7601 moveq #1,%d3
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
46308: 2200 movel %d0,%d1
4630a: 5381 subql #1,%d1
4630c: 2803 movel %d3,%d4
4630e: e3ac lsll %d1,%d4
46310: 2204 movel %d4,%d1
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
46312: c282 andl %d2,%d1
46314: 660a bnes 46320 <_POSIX_signals_Get_lowest+0x44>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
46316: 5280 addql #1,%d0
46318: 123c 001b moveb #27,%d1
4631c: b280 cmpl %d0,%d1
4631e: 66e8 bnes 46308 <_POSIX_signals_Get_lowest+0x2c> <== ALWAYS TAKEN
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
46320: 4cd7 001c moveml %sp@,%d2-%d4
46324: 4e5e unlk %fp <== NOT EXECUTED
0004a482 <_POSIX_signals_Post_switch_extension>:
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
4a482: 4e56 ffec linkw %fp,#-20
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a486: 206e 0008 moveal %fp@(8),%a0
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
4a48a: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a48e: 2468 0102 moveal %a0@(258),%a2
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
4a492: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
4a498: 2628 0034 movel %a0@(52),%d3
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
4a49c: 4a8a tstl %a2
4a49e: 677a beqs 4a51a <_POSIX_signals_Post_switch_extension+0x98><== NEVER TAKEN
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
4a4a0: 283c 0000 0700 movel #1792,%d4
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4a4a6: 47f9 0004 c61c lea 4c61c <_POSIX_signals_Check_signal>,%a3
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
4a4ac: 2004 movel %d4,%d0
4a4ae: 40c1 movew %sr,%d1
4a4b0: 8081 orl %d1,%d0
4a4b2: 46c0 movew %d0,%sr
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4a4b4: 2039 0005 f228 movel 5f228 <_POSIX_signals_Pending>,%d0
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
4a4ba: 242a 00d0 movel %a2@(208),%d2
4a4be: 4682 notl %d2
(api->signals_pending | _POSIX_signals_Pending)) ) {
4a4c0: 80aa 00d4 orl %a2@(212),%d0
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
4a4c4: c082 andl %d2,%d0
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
4a4c6: 46c1 movew %d1,%sr
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
4a4c8: 4a80 tstl %d0
4a4ca: 660c bnes 4a4d8 <_POSIX_signals_Post_switch_extension+0x56>
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
4a4cc: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
4a4d2: 2143 0034 movel %d3,%a0@(52)
4a4d6: 6042 bras 4a51a <_POSIX_signals_Post_switch_extension+0x98>
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4a4d8: 741b moveq #27,%d2
_POSIX_signals_Check_signal( api, signo, false );
4a4da: 42a7 clrl %sp@-
4a4dc: 2f02 movel %d2,%sp@-
4a4de: 2f0a movel %a2,%sp@-
4a4e0: 4e93 jsr %a3@
_POSIX_signals_Check_signal( api, signo, true );
4a4e2: 4878 0001 pea 1 <ADD>
4a4e6: 2f02 movel %d2,%sp@-
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4a4e8: 5282 addql #1,%d2
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
4a4ea: 2f0a movel %a2,%sp@-
4a4ec: 4e93 jsr %a3@
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4a4ee: 4fef 0018 lea %sp@(24),%sp
4a4f2: 7020 moveq #32,%d0
4a4f4: b082 cmpl %d2,%d0
4a4f6: 66e2 bnes 4a4da <_POSIX_signals_Post_switch_extension+0x58>
4a4f8: 7401 moveq #1,%d2
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4a4fa: 42a7 clrl %sp@-
4a4fc: 2f02 movel %d2,%sp@-
4a4fe: 2f0a movel %a2,%sp@-
4a500: 4e93 jsr %a3@
_POSIX_signals_Check_signal( api, signo, true );
4a502: 4878 0001 pea 1 <ADD>
4a506: 2f02 movel %d2,%sp@-
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
4a508: 5282 addql #1,%d2
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
4a50a: 2f0a movel %a2,%sp@-
4a50c: 4e93 jsr %a3@
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
4a50e: 4fef 0018 lea %sp@(24),%sp
4a512: 701b moveq #27,%d0
4a514: b082 cmpl %d2,%d0
4a516: 66e2 bnes 4a4fa <_POSIX_signals_Post_switch_extension+0x78>
4a518: 6092 bras 4a4ac <_POSIX_signals_Post_switch_extension+0x2a>
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
}
4a51a: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
4a520: 4e5e unlk %fp <== NOT EXECUTED
0005ae80 <_POSIX_signals_Unblock_thread>:
5ae80: 7201 moveq #1,%d1
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
5ae82: 4e56 fff4 linkw %fp,#-12
5ae86: 226e 0010 moveal %fp@(16),%a1
5ae8a: 48d7 040c moveml %d2-%d3/%a2,%sp@
5ae8e: 242e 000c movel %fp@(12),%d2
5ae92: 2002 movel %d2,%d0
5ae94: 5380 subql #1,%d0
5ae96: 246e 0008 moveal %fp@(8),%a2
5ae9a: e1a9 lsll %d0,%d1
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
5ae9c: 202a 0010 movel %a2@(16),%d0
5aea0: 2600 movel %d0,%d3
5aea2: 0283 1000 8000 andil #268468224,%d3
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
5aea8: 206a 0102 moveal %a2@(258),%a0
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
5aeac: 0c83 1000 8000 cmpil #268468224,%d3
5aeb2: 6650 bnes 5af04 <_POSIX_signals_Unblock_thread+0x84>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
5aeb4: 2001 movel %d1,%d0
5aeb6: c0aa 0030 andl %a2@(48),%d0
5aeba: 660c bnes 5aec8 <_POSIX_signals_Unblock_thread+0x48>
5aebc: 2028 00d0 movel %a0@(208),%d0
5aec0: 4680 notl %d0
5aec2: c280 andl %d0,%d1
5aec4: 6700 00a8 beqw 5af6e <_POSIX_signals_Unblock_thread+0xee>
the_thread->Wait.return_code = EINTR;
5aec8: 7004 moveq #4,%d0
the_info = (siginfo_t *) the_thread->Wait.return_argument;
5aeca: 206a 0028 moveal %a2@(40),%a0
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
5aece: 2540 0034 movel %d0,%a2@(52)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
5aed2: 4a89 tstl %a1
5aed4: 660e bnes 5aee4 <_POSIX_signals_Unblock_thread+0x64>
the_info->si_signo = signo;
the_info->si_code = SI_USER;
5aed6: 7201 moveq #1,%d1
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
5aed8: 2082 movel %d2,%a0@
the_info->si_code = SI_USER;
5aeda: 2141 0004 movel %d1,%a0@(4)
the_info->si_value.sival_int = 0;
5aede: 42a8 0008 clrl %a0@(8)
5aee2: 6012 bras 5aef6 <_POSIX_signals_Unblock_thread+0x76>
} else {
*the_info = *info;
5aee4: 4878 000c pea c <OPER1>
5aee8: 2f09 movel %a1,%sp@-
5aeea: 2f08 movel %a0,%sp@-
5aeec: 4eb9 0004 d588 jsr 4d588 <memcpy>
5aef2: 4fef 000c lea %sp@(12),%sp
}
_Thread_queue_Extract_with_proxy( the_thread );
5aef6: 2f0a movel %a2,%sp@-
5aef8: 4eb9 0004 8388 jsr 48388 <_Thread_queue_Extract_with_proxy>
return true;
5aefe: 588f addql #4,%sp
5af00: 7001 moveq #1,%d0
5af02: 606c bras 5af70 <_POSIX_signals_Unblock_thread+0xf0>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
5af04: 2428 00d0 movel %a0@(208),%d2
5af08: 4682 notl %d2
5af0a: c282 andl %d2,%d1
5af0c: 6760 beqs 5af6e <_POSIX_signals_Unblock_thread+0xee>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
5af0e: 0800 001c btst #28,%d0
5af12: 673e beqs 5af52 <_POSIX_signals_Unblock_thread+0xd2>
the_thread->Wait.return_code = EINTR;
5af14: 7204 moveq #4,%d1
5af16: 2541 0034 movel %d1,%a2@(52)
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
5af1a: 2200 movel %d0,%d1
5af1c: 0281 0003 bee0 andil #245472,%d1
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
5af22: 670c beqs 5af30 <_POSIX_signals_Unblock_thread+0xb0>
_Thread_queue_Extract_with_proxy( the_thread );
5af24: 2f0a movel %a2,%sp@-
5af26: 4eb9 0004 8388 jsr 48388 <_Thread_queue_Extract_with_proxy>
5af2c: 588f addql #4,%sp
5af2e: 603e bras 5af6e <_POSIX_signals_Unblock_thread+0xee>
else if ( _States_Is_delaying(the_thread->current_state) ) {
5af30: 44c0 movew %d0,%ccr
5af32: 6a3a bpls 5af6e <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
5af34: 486a 0048 pea %a2@(72)
5af38: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
5af3e: 2f3c 1003 fff8 movel #268697592,%sp@-
5af44: 2f0a movel %a2,%sp@-
5af46: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state>
5af4c: 4fef 000c lea %sp@(12),%sp
5af50: 601c bras 5af6e <_POSIX_signals_Unblock_thread+0xee>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
5af52: 4a80 tstl %d0
5af54: 6618 bnes 5af6e <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
5af56: 4ab9 0005 eff6 tstl 5eff6 <_Per_CPU_Information+0x8>
5af5c: 6710 beqs 5af6e <_POSIX_signals_Unblock_thread+0xee>
5af5e: b5f9 0005 effa cmpal 5effa <_Per_CPU_Information+0xc>,%a2
5af64: 6608 bnes 5af6e <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
5af66: 7001 moveq #1,%d0
5af68: 13c0 0005 f006 moveb %d0,5f006 <_Per_CPU_Information+0x18>
}
}
return false;
5af6e: 4200 clrb %d0
}
5af70: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
5af76: 4e5e unlk %fp
...
0004bb9e <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
4bb9e: 4e56 ffec linkw %fp,#-20
4bba2: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
4bba6: 286e 0008 moveal %fp@(8),%a4
4bbaa: 246e 000c moveal %fp@(12),%a2
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
4bbae: 4a8a tstl %a2
4bbb0: 6700 0110 beqw 4bcc2 <_RBTree_Extract_unprotected+0x124>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
4bbb4: b5ec 0008 cmpal %a4@(8),%a2
4bbb8: 661a bnes 4bbd4 <_RBTree_Extract_unprotected+0x36>
if (the_node->child[RBT_RIGHT])
4bbba: 202a 0008 movel %a2@(8),%d0
4bbbe: 6706 beqs 4bbc6 <_RBTree_Extract_unprotected+0x28>
the_rbtree->first[RBT_LEFT] = the_node->child[RBT_RIGHT];
4bbc0: 2940 0008 movel %d0,%a4@(8)
4bbc4: 600e bras 4bbd4 <_RBTree_Extract_unprotected+0x36>
else {
the_rbtree->first[RBT_LEFT] = the_node->parent;
4bbc6: 2012 movel %a2@,%d0
4bbc8: 2940 0008 movel %d0,%a4@(8)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
4bbcc: b08c cmpl %a4,%d0
4bbce: 6604 bnes 4bbd4 <_RBTree_Extract_unprotected+0x36>
the_rbtree->first[RBT_LEFT]))
the_rbtree->first[RBT_LEFT] = NULL;
4bbd0: 42ac 0008 clrl %a4@(8)
4bbd4: 2a6a 0004 moveal %a2@(4),%a5
}
}
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
4bbd8: b5ec 000c cmpal %a4@(12),%a2
4bbdc: 6618 bnes 4bbf6 <_RBTree_Extract_unprotected+0x58>
if (the_node->child[RBT_LEFT])
4bbde: 4a8d tstl %a5
4bbe0: 6706 beqs 4bbe8 <_RBTree_Extract_unprotected+0x4a>
the_rbtree->first[RBT_RIGHT] = the_node->child[RBT_LEFT];
4bbe2: 294d 000c movel %a5,%a4@(12)
4bbe6: 600e bras 4bbf6 <_RBTree_Extract_unprotected+0x58>
else {
the_rbtree->first[RBT_RIGHT] = the_node->parent;
4bbe8: 2012 movel %a2@,%d0
4bbea: 2940 000c movel %d0,%a4@(12)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
4bbee: b08c cmpl %a4,%d0
4bbf0: 6604 bnes 4bbf6 <_RBTree_Extract_unprotected+0x58>
the_rbtree->first[RBT_RIGHT]))
the_rbtree->first[RBT_RIGHT] = NULL;
4bbf2: 42ac 000c clrl %a4@(12)
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
4bbf6: 264d moveal %a5,%a3
4bbf8: 4a8d tstl %a5
4bbfa: 6778 beqs 4bc74 <_RBTree_Extract_unprotected+0xd6>
4bbfc: 4aaa 0008 tstl %a2@(8)
4bc00: 6604 bnes 4bc06 <_RBTree_Extract_unprotected+0x68>
4bc02: 6078 bras 4bc7c <_RBTree_Extract_unprotected+0xde>
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
4bc04: 2640 moveal %d0,%a3
4bc06: 202b 0008 movel %a3@(8),%d0
4bc0a: 66f8 bnes 4bc04 <_RBTree_Extract_unprotected+0x66>
* target's position (target is the right child of target->parent)
* when target vacates it. if there is no child, then target->parent
* should become NULL. This may cause the coloring to be violated.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = target->child[RBT_LEFT];
4bc0c: 2a6b 0004 moveal %a3@(4),%a5
if(leaf) {
4bc10: 4a8d tstl %a5
4bc12: 6704 beqs 4bc18 <_RBTree_Extract_unprotected+0x7a>
leaf->parent = target->parent;
4bc14: 2a93 movel %a3@,%a5@
4bc16: 600a bras 4bc22 <_RBTree_Extract_unprotected+0x84>
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
4bc18: 2f0b movel %a3,%sp@-
4bc1a: 4eb9 0004 ba58 jsr 4ba58 <_RBTree_Extract_validate_unprotected>
4bc20: 588f addql #4,%sp
}
victim_color = target->color;
dir = target != target->parent->child[0];
4bc22: 2053 moveal %a3@,%a0
4bc24: b7e8 0004 cmpal %a0@(4),%a3
4bc28: 56c1 sne %d1
target->parent->child[dir] = leaf;
4bc2a: 7401 moveq #1,%d2
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
4bc2c: 49c1 extbl %d1
target->parent->child[dir] = leaf;
4bc2e: 9481 subl %d1,%d2
4bc30: 218d 2c00 movel %a5,%a0@(00000000,%d2:l:4)
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
the_node->parent->child[dir] = target;
4bc34: 7401 moveq #1,%d2
victim_color = target->color;
dir = target != target->parent->child[0];
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4bc36: 2052 moveal %a2@,%a0
4bc38: b5e8 0004 cmpal %a0@(4),%a2
4bc3c: 56c1 sne %d1
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
4bc3e: 202b 000c movel %a3@(12),%d0
dir = target != target->parent->child[0];
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4bc42: 49c1 extbl %d1
the_node->parent->child[dir] = target;
4bc44: 9481 subl %d1,%d2
4bc46: 218b 2c00 movel %a3,%a0@(00000000,%d2:l:4)
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
4bc4a: 276a 0008 0008 movel %a2@(8),%a3@(8)
if (the_node->child[RBT_RIGHT])
4bc50: 206a 0008 moveal %a2@(8),%a0
4bc54: 4a88 tstl %a0
4bc56: 6702 beqs 4bc5a <_RBTree_Extract_unprotected+0xbc><== NEVER TAKEN
the_node->child[RBT_RIGHT]->parent = target;
4bc58: 208b movel %a3,%a0@
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
4bc5a: 276a 0004 0004 movel %a2@(4),%a3@(4)
if (the_node->child[RBT_LEFT])
4bc60: 206a 0004 moveal %a2@(4),%a0
4bc64: 4a88 tstl %a0
4bc66: 6702 beqs 4bc6a <_RBTree_Extract_unprotected+0xcc>
the_node->child[RBT_LEFT]->parent = target;
4bc68: 208b movel %a3,%a0@
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
4bc6a: 2692 movel %a2@,%a3@
target->color = the_node->color;
4bc6c: 276a 000c 000c movel %a2@(12),%a3@(12)
4bc72: 602c bras 4bca0 <_RBTree_Extract_unprotected+0x102>
* the_node's location in the tree. This may cause the coloring to be
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
4bc74: 2a6a 0008 moveal %a2@(8),%a5
if( leaf ) {
4bc78: 4a8d tstl %a5
4bc7a: 6704 beqs 4bc80 <_RBTree_Extract_unprotected+0xe2>
leaf->parent = the_node->parent;
4bc7c: 2a92 movel %a2@,%a5@
4bc7e: 600a bras 4bc8a <_RBTree_Extract_unprotected+0xec>
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
4bc80: 2f0a movel %a2,%sp@-
4bc82: 4eb9 0004 ba58 jsr 4ba58 <_RBTree_Extract_validate_unprotected>
4bc88: 588f addql #4,%sp
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4bc8a: 2052 moveal %a2@,%a0
4bc8c: b5e8 0004 cmpal %a0@(4),%a2
4bc90: 56c1 sne %d1
the_node->parent->child[dir] = leaf;
4bc92: 7401 moveq #1,%d2
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4bc94: 49c1 extbl %d1
the_node->parent->child[dir] = leaf;
4bc96: 9481 subl %d1,%d2
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
4bc98: 202a 000c movel %a2@(12),%d0
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
the_node->parent->child[dir] = leaf;
4bc9c: 218d 2c00 movel %a5,%a0@(00000000,%d2:l:4)
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
4bca0: 4a80 tstl %d0
4bca2: 6608 bnes 4bcac <_RBTree_Extract_unprotected+0x10e>
if (leaf) {
4bca4: 4a8d tstl %a5
4bca6: 6704 beqs 4bcac <_RBTree_Extract_unprotected+0x10e>
leaf->color = RBT_BLACK; /* case 2 */
4bca8: 42ad 000c clrl %a5@(12)
/* Wipe the_node */
_RBTree_Set_off_rbtree(the_node);
/* set root to black, if it exists */
if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK;
4bcac: 206c 0004 moveal %a4@(4),%a0
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(
RBTree_Node *node
)
{
node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
4bcb0: 42aa 0008 clrl %a2@(8)
4bcb4: 42aa 0004 clrl %a2@(4)
4bcb8: 4292 clrl %a2@
4bcba: 4a88 tstl %a0
4bcbc: 6704 beqs 4bcc2 <_RBTree_Extract_unprotected+0x124>
4bcbe: 42a8 000c clrl %a0@(12)
}
4bcc2: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
4bcc8: 4e5e unlk %fp <== NOT EXECUTED
0004ba58 <_RBTree_Extract_validate_unprotected>:
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
4ba58: 4e56 ffe8 linkw %fp,#-24
4ba5c: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
4ba60: 266e 0008 moveal %fp@(8),%a3
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
4ba64: 2453 moveal %a3@,%a2
if(!parent->parent) return;
4ba66: 4a92 tstl %a2@
4ba68: 6700 012a beqw 4bb94 <_RBTree_Extract_validate_unprotected+0x13c>
sibling = _RBTree_Sibling(the_node);
4ba6c: 2f0b movel %a3,%sp@-
4ba6e: 49fa ff6c lea %pc@(4b9dc <_RBTree_Sibling>),%a4
4ba72: 4e94 jsr %a4@
4ba74: 588f addql #4,%sp
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
_RBTree_Rotate(parent, dir);
4ba76: 4bfa ff8e lea %pc@(4ba06 <_RBTree_Rotate>),%a5
RBTree_Direction dir;
parent = the_node->parent;
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
4ba7a: 2040 moveal %d0,%a0
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
4ba7c: 6000 00ec braw 4bb6a <_RBTree_Extract_validate_unprotected+0x112>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4ba80: 4a88 tstl %a0
4ba82: 6730 beqs 4bab4 <_RBTree_Extract_validate_unprotected+0x5c><== NEVER TAKEN
4ba84: 7001 moveq #1,%d0
4ba86: b0a8 000c cmpl %a0@(12),%d0
4ba8a: 6628 bnes 4bab4 <_RBTree_Extract_validate_unprotected+0x5c>
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
4ba8c: b7ea 0004 cmpal %a2@(4),%a3
4ba90: 56c2 sne %d2
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
4ba92: 2540 000c movel %d0,%a2@(12)
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
4ba96: 49c2 extbl %d2
4ba98: 4482 negl %d2
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
4ba9a: 42a8 000c clrl %a0@(12)
dir = the_node != parent->child[0];
_RBTree_Rotate(parent, dir);
4ba9e: 2f02 movel %d2,%sp@-
4baa0: 2f0a movel %a2,%sp@-
4baa2: 4e95 jsr %a5@
sibling = parent->child[!dir];
4baa4: 508f addql #8,%sp
4baa6: 4a82 tstl %d2
4baa8: 57c0 seq %d0
4baaa: 7201 moveq #1,%d1
4baac: 49c0 extbl %d0
4baae: 9280 subl %d0,%d1
4bab0: 2072 1c00 moveal %a2@(00000000,%d1:l:4),%a0
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4bab4: 2268 0008 moveal %a0@(8),%a1
4bab8: 4a89 tstl %a1
4baba: 670e beqs 4baca <_RBTree_Extract_validate_unprotected+0x72>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
4babc: 7001 moveq #1,%d0
4babe: b0a9 000c cmpl %a1@(12),%d0
4bac2: 57c0 seq %d0
4bac4: 49c0 extbl %d0
4bac6: 4480 negl %d0
4bac8: 6002 bras 4bacc <_RBTree_Extract_validate_unprotected+0x74>
4baca: 4280 clrl %d0
_RBTree_Rotate(parent, dir);
sibling = parent->child[!dir];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4bacc: 4a00 tstb %d0
4bace: 6630 bnes 4bb00 <_RBTree_Extract_validate_unprotected+0xa8>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
4bad0: 2268 0004 moveal %a0@(4),%a1
4bad4: 4a89 tstl %a1
4bad6: 670e beqs 4bae6 <_RBTree_Extract_validate_unprotected+0x8e>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
4bad8: 7201 moveq #1,%d1
4bada: b2a9 000c cmpl %a1@(12),%d1
4bade: 57c0 seq %d0
4bae0: 49c0 extbl %d0
4bae2: 4480 negl %d0
4bae4: 6002 bras 4bae8 <_RBTree_Extract_validate_unprotected+0x90>
4bae6: 4280 clrl %d0
_RBTree_Rotate(parent, dir);
sibling = parent->child[!dir];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4bae8: 4a00 tstb %d0
4baea: 6614 bnes 4bb00 <_RBTree_Extract_validate_unprotected+0xa8>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
4baec: 7001 moveq #1,%d0
4baee: 2140 000c movel %d0,%a0@(12)
4baf2: b0aa 000c cmpl %a2@(12),%d0
4baf6: 6600 008c bnew 4bb84 <_RBTree_Extract_validate_unprotected+0x12c>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
4bafa: 42aa 000c clrl %a2@(12)
break;
4bafe: 6078 bras 4bb78 <_RBTree_Extract_validate_unprotected+0x120>
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
4bb00: b7ea 0004 cmpal %a2@(4),%a3
4bb04: 56c2 sne %d2
4bb06: 49c2 extbl %d2
4bb08: 4482 negl %d2
if (!_RBTree_Is_red(sibling->child[!dir])) {
4bb0a: 57c3 seq %d3
4bb0c: 49c3 extbl %d3
4bb0e: 4483 negl %d3
4bb10: 2270 3c04 moveal %a0@(00000004,%d3:l:4),%a1
4bb14: 4a89 tstl %a1
4bb16: 670e beqs 4bb26 <_RBTree_Extract_validate_unprotected+0xce>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
4bb18: 7201 moveq #1,%d1
4bb1a: b2a9 000c cmpl %a1@(12),%d1
4bb1e: 57c0 seq %d0
4bb20: 49c0 extbl %d0
4bb22: 4480 negl %d0
4bb24: 6002 bras 4bb28 <_RBTree_Extract_validate_unprotected+0xd0>
4bb26: 4280 clrl %d0
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
4bb28: 4a00 tstb %d0
4bb2a: 6620 bnes 4bb4c <_RBTree_Extract_validate_unprotected+0xf4>
sibling->color = RBT_RED;
4bb2c: 7001 moveq #1,%d0
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
4bb2e: 7201 moveq #1,%d1
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
4bb30: 2270 2c04 moveal %a0@(00000004,%d2:l:4),%a1
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
4bb34: 2140 000c movel %d0,%a0@(12)
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
4bb38: b581 eorl %d2,%d1
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
4bb3a: 42a9 000c clrl %a1@(12)
_RBTree_Rotate(sibling, !dir);
4bb3e: 2f01 movel %d1,%sp@-
4bb40: 2f08 movel %a0,%sp@-
4bb42: 4eba fec2 jsr %pc@(4ba06 <_RBTree_Rotate>)
sibling = parent->child[!dir];
4bb46: 508f addql #8,%sp
4bb48: 2072 3c04 moveal %a2@(00000004,%d3:l:4),%a0
}
sibling->color = parent->color;
4bb4c: 216a 000c 000c movel %a2@(12),%a0@(12)
parent->color = RBT_BLACK;
sibling->child[!dir]->color = RBT_BLACK;
4bb52: 2070 3c04 moveal %a0@(00000004,%d3:l:4),%a0
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
sibling = parent->child[!dir];
}
sibling->color = parent->color;
parent->color = RBT_BLACK;
4bb56: 42aa 000c clrl %a2@(12)
sibling->child[!dir]->color = RBT_BLACK;
4bb5a: 42a8 000c clrl %a0@(12)
_RBTree_Rotate(parent, dir);
4bb5e: 2f02 movel %d2,%sp@-
4bb60: 2f0a movel %a2,%sp@-
4bb62: 4eba fea2 jsr %pc@(4ba06 <_RBTree_Rotate>)
break; /* done */
4bb66: 508f addql #8,%sp
4bb68: 600e bras 4bb78 <_RBTree_Extract_validate_unprotected+0x120>
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
4bb6a: 7001 moveq #1,%d0
4bb6c: b0ab 000c cmpl %a3@(12),%d0
4bb70: 6706 beqs 4bb78 <_RBTree_Extract_validate_unprotected+0x120>
4bb72: 4a92 tstl %a2@
4bb74: 6600 ff0a bnew 4ba80 <_RBTree_Extract_validate_unprotected+0x28>
sibling->child[!dir]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4bb78: 2053 moveal %a3@,%a0
4bb7a: 4a90 tstl %a0@
4bb7c: 6616 bnes 4bb94 <_RBTree_Extract_validate_unprotected+0x13c>
4bb7e: 42ab 000c clrl %a3@(12)
4bb82: 6010 bras 4bb94 <_RBTree_Extract_validate_unprotected+0x13c>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
4bb84: 2412 movel %a2@,%d2
sibling = _RBTree_Sibling(the_node);
4bb86: 264a moveal %a2,%a3
4bb88: 2f0a movel %a2,%sp@-
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
4bb8a: 2442 moveal %d2,%a2
sibling = _RBTree_Sibling(the_node);
4bb8c: 4e94 jsr %a4@
4bb8e: 588f addql #4,%sp
4bb90: 2040 moveal %d0,%a0
4bb92: 60d6 bras 4bb6a <_RBTree_Extract_validate_unprotected+0x112>
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
4bb94: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
4bb9a: 4e5e unlk %fp <== NOT EXECUTED
00048ae4 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
48ae4: 4e56 ffec linkw %fp,#-20
48ae8: 202e 001c movel %fp@(28),%d0
48aec: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
48af0: 246e 0008 moveal %fp@(8),%a2
48af4: 262e 0014 movel %fp@(20),%d3
48af8: 282e 0018 movel %fp@(24),%d4
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
48afc: 4a8a tstl %a2
48afe: 6734 beqs 48b34 <_RBTree_Initialize+0x50> <== NEVER TAKEN
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
48b00: 4292 clrl %a2@
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
48b02: 256e 000c 0010 movel %fp@(12),%a2@(16)
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
48b08: 242e 0010 movel %fp@(16),%d2
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
48b0c: 42aa 0004 clrl %a2@(4)
while ( count-- ) {
_RBTree_Insert(the_rbtree, next);
48b10: 47f9 0004 8ab8 lea 48ab8 <_RBTree_Insert>,%a3
the_rbtree->first[0] = NULL;
48b16: 42aa 0008 clrl %a2@(8)
the_rbtree->first[1] = NULL;
48b1a: 42aa 000c clrl %a2@(12)
the_rbtree->compare_function = compare_function;
the_rbtree->is_unique = is_unique;
48b1e: 1540 0014 moveb %d0,%a2@(20)
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
48b22: 600c bras 48b30 <_RBTree_Initialize+0x4c>
_RBTree_Insert(the_rbtree, next);
48b24: 2f02 movel %d2,%sp@-
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
48b26: d484 addl %d4,%d2
48b28: 5383 subql #1,%d3
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
_RBTree_Insert(the_rbtree, next);
48b2a: 2f0a movel %a2,%sp@-
48b2c: 4e93 jsr %a3@
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
48b2e: 508f addql #8,%sp
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
48b30: 4a83 tstl %d3
48b32: 66f0 bnes 48b24 <_RBTree_Initialize+0x40>
_RBTree_Insert(the_rbtree, next);
next = (RBTree_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
}
48b34: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
48b3a: 4e5e unlk %fp
...
0004b9dc <_RBTree_Sibling>:
* exists, and NULL if not.
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
RBTree_Node *the_node
)
{
4b9dc: 4e56 0000 linkw %fp,#0
4b9e0: 226e 0008 moveal %fp@(8),%a1
if(!the_node) return NULL;
4b9e4: 4a89 tstl %a1
4b9e6: 6718 beqs 4ba00 <_RBTree_Sibling+0x24>
if(!(the_node->parent)) return NULL;
4b9e8: 2051 moveal %a1@,%a0
4b9ea: 4a88 tstl %a0
4b9ec: 6712 beqs 4ba00 <_RBTree_Sibling+0x24> <== NEVER TAKEN
if(!(the_node->parent->parent)) return NULL;
4b9ee: 4a90 tstl %a0@
4b9f0: 670e beqs 4ba00 <_RBTree_Sibling+0x24>
if(the_node == the_node->parent->child[RBT_LEFT])
4b9f2: 2028 0004 movel %a0@(4),%d0
4b9f6: b089 cmpl %a1,%d0
4b9f8: 6608 bnes 4ba02 <_RBTree_Sibling+0x26>
return the_node->parent->child[RBT_RIGHT];
4b9fa: 2028 0008 movel %a0@(8),%d0
4b9fe: 6002 bras 4ba02 <_RBTree_Sibling+0x26>
RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
4ba00: 4280 clrl %d0
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
else
return the_node->parent->child[RBT_LEFT];
}
4ba02: 4e5e unlk %fp <== NOT EXECUTED
0004bd4a <_RBTree_Validate_insert_unprotected>:
* append operation.
*/
void _RBTree_Validate_insert_unprotected(
RBTree_Node *the_node
)
{
4bd4a: 4e56 fff0 linkw %fp,#-16
4bd4e: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
4bd52: 266e 0008 moveal %fp@(8),%a3
}
the_node->parent->color = RBT_BLACK;
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
4bd56: 49fa ffa0 lea %pc@(4bcf8 <_RBTree_Rotate>),%a4
RBTree_Node *u,*g;
/* note: the insert root case is handled already */
/* if the parent is black, nothing needs to be done
* otherwise may need to loop a few times */
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
4bd5a: 604e bras 4bdaa <_RBTree_Validate_insert_unprotected+0x60>
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
4bd5c: 4a92 tstl %a2@
4bd5e: 6762 beqs 4bdc2 <_RBTree_Validate_insert_unprotected+0x78><== NEVER TAKEN
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
4bd60: 226a 0004 moveal %a2@(4),%a1
4bd64: b3c8 cmpal %a0,%a1
4bd66: 6604 bnes 4bd6c <_RBTree_Validate_insert_unprotected+0x22>
return the_node->parent->child[RBT_RIGHT];
4bd68: 226a 0008 moveal %a2@(8),%a1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4bd6c: 4a89 tstl %a1
4bd6e: 6752 beqs 4bdc2 <_RBTree_Validate_insert_unprotected+0x78>
4bd70: 7001 moveq #1,%d0
4bd72: b0a9 000c cmpl %a1@(12),%d0
4bd76: 664a bnes 4bdc2 <_RBTree_Validate_insert_unprotected+0x78>
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
4bd78: 42a8 000c clrl %a0@(12)
u->color = RBT_BLACK;
g->color = RBT_RED;
4bd7c: 264a moveal %a2,%a3
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
4bd7e: 42a9 000c clrl %a1@(12)
g->color = RBT_RED;
4bd82: 2540 000c movel %d0,%a2@(12)
4bd86: 6022 bras 4bdaa <_RBTree_Validate_insert_unprotected+0x60>
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
4bd88: 2f02 movel %d2,%sp@-
4bd8a: 2f08 movel %a0,%sp@-
4bd8c: 4e94 jsr %a4@
the_node = the_node->child[pdir];
4bd8e: 508f addql #8,%sp
4bd90: 2673 2c04 moveal %a3@(00000004,%d2:l:4),%a3
}
the_node->parent->color = RBT_BLACK;
4bd94: 2053 moveal %a3@,%a0
g->color = RBT_RED;
4bd96: 7001 moveq #1,%d0
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
4bd98: 42a8 000c clrl %a0@(12)
g->color = RBT_RED;
4bd9c: 2540 000c movel %d0,%a2@(12)
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
4bda0: 9082 subl %d2,%d0
4bda2: 2f00 movel %d0,%sp@-
4bda4: 2f0a movel %a2,%sp@-
4bda6: 4e94 jsr %a4@
4bda8: 508f addql #8,%sp
ISR_Level level;
_ISR_Disable( level );
return _RBTree_Insert_unprotected( tree, node );
_ISR_Enable( level );
}
4bdaa: 2053 moveal %a3@,%a0
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
4bdac: 2450 moveal %a0@,%a2
4bdae: 4a8a tstl %a2
4bdb0: 670a beqs 4bdbc <_RBTree_Validate_insert_unprotected+0x72>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4bdb2: 7001 moveq #1,%d0
4bdb4: b0a8 000c cmpl %a0@(12),%d0
4bdb8: 6622 bnes 4bddc <_RBTree_Validate_insert_unprotected+0x92>
4bdba: 60a0 bras 4bd5c <_RBTree_Validate_insert_unprotected+0x12>
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4bdbc: 42ab 000c clrl %a3@(12)
4bdc0: 601a bras 4bddc <_RBTree_Validate_insert_unprotected+0x92>
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
4bdc2: b1ea 0004 cmpal %a2@(4),%a0
4bdc6: 56c2 sne %d2
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4bdc8: b7e8 0004 cmpal %a0@(4),%a3
4bdcc: 56c0 sne %d0
RBTree_Direction pdir = the_node->parent != g->child[0];
4bdce: 49c2 extbl %d2
4bdd0: 4482 negl %d2
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4bdd2: 49c0 extbl %d0
4bdd4: 4480 negl %d0
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
4bdd6: b480 cmpl %d0,%d2
4bdd8: 66ae bnes 4bd88 <_RBTree_Validate_insert_unprotected+0x3e>
4bdda: 60b8 bras 4bd94 <_RBTree_Validate_insert_unprotected+0x4a>
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
4bddc: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
4bde2: 4e5e unlk %fp <== NOT EXECUTED
00057a68 <_Region_Process_queue>:
*/
void _Region_Process_queue(
Region_Control *the_region
)
{
57a68: 4e56 ffe4 linkw %fp,#-28
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
57a6c: 2039 0007 6b3c movel 76b3c <_Thread_Dispatch_disable_level>,%d0
57a72: 5280 addql #1,%d0
57a74: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
57a78: 23c0 0007 6b3c movel %d0,76b3c <_Thread_Dispatch_disable_level>
57a7e: 266e 0008 moveal %fp@(8),%a3
return _Thread_Dispatch_disable_level;
57a82: 2039 0007 6b3c movel 76b3c <_Thread_Dispatch_disable_level>,%d0
* NOTE: Be sure to disable dispatching before unlocking the mutex
* since we do not want to open a window where a context
* switch could occur.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
57a88: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@-
/*
* NOTE: The following loop is O(n) where n is the number of
* threads whose memory request is satisfied.
*/
for ( ; ; ) {
the_thread = _Thread_queue_First( &the_region->Wait_queue );
57a8e: 240b movel %a3,%d2
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
Region_Control *the_region,
uintptr_t size
)
{
return _Heap_Allocate( &the_region->Memory, size );
57a90: 260b movel %a3,%d3
57a92: 0682 0000 0010 addil #16,%d2
57a98: 0683 0000 0068 addil #104,%d3
57a9e: 4bf9 0005 2ec8 lea 52ec8 <_Heap_Allocate_aligned_with_boundary>,%a5
if ( the_segment == NULL )
break;
*(void **)the_thread->Wait.return_argument = the_segment;
the_region->number_of_used_blocks += 1;
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
57aa4: 49f9 0005 80ec lea 580ec <_Thread_queue_Extract>,%a4
* NOTE: Be sure to disable dispatching before unlocking the mutex
* since we do not want to open a window where a context
* switch could occur.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
57aaa: 4eb9 0005 2428 jsr 52428 <_API_Mutex_Unlock>
57ab0: 588f addql #4,%sp
/*
* NOTE: The following loop is O(n) where n is the number of
* threads whose memory request is satisfied.
*/
for ( ; ; ) {
the_thread = _Thread_queue_First( &the_region->Wait_queue );
57ab2: 283c 0005 81e8 movel #360936,%d4
57ab8: 2f02 movel %d2,%sp@-
57aba: 2044 moveal %d4,%a0
57abc: 4e90 jsr %a0@
if ( the_thread == NULL )
57abe: 588f addql #4,%sp
/*
* NOTE: The following loop is O(n) where n is the number of
* threads whose memory request is satisfied.
*/
for ( ; ; ) {
the_thread = _Thread_queue_First( &the_region->Wait_queue );
57ac0: 2440 moveal %d0,%a2
if ( the_thread == NULL )
57ac2: 4a80 tstl %d0
57ac4: 672c beqs 57af2 <_Region_Process_queue+0x8a>
57ac6: 42a7 clrl %sp@-
57ac8: 42a7 clrl %sp@-
57aca: 2f2a 0024 movel %a2@(36),%sp@-
57ace: 2f03 movel %d3,%sp@-
57ad0: 4e95 jsr %a5@
the_segment = (void **) _Region_Allocate_segment(
the_region,
the_thread->Wait.count
);
if ( the_segment == NULL )
57ad2: 4fef 0010 lea %sp@(16),%sp
57ad6: 4a80 tstl %d0
57ad8: 6718 beqs 57af2 <_Region_Process_queue+0x8a> <== NEVER TAKEN
break;
*(void **)the_thread->Wait.return_argument = the_segment;
57ada: 206a 0028 moveal %a2@(40),%a0
57ade: 2080 movel %d0,%a0@
the_region->number_of_used_blocks += 1;
57ae0: 52ab 0064 addql #1,%a3@(100)
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
57ae4: 2f0a movel %a2,%sp@-
57ae6: 2f02 movel %d2,%sp@-
57ae8: 4e94 jsr %a4@
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
}
57aea: 508f addql #8,%sp
break;
*(void **)the_thread->Wait.return_argument = the_segment;
the_region->number_of_used_blocks += 1;
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
57aec: 42aa 0034 clrl %a2@(52)
}
57af0: 60c6 bras 57ab8 <_Region_Process_queue+0x50>
_Thread_Enable_dispatch();
}
57af2: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
57af8: 4e5e unlk %fp
*(void **)the_thread->Wait.return_argument = the_segment;
the_region->number_of_used_blocks += 1;
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
57afa: 4ef9 0005 4ab4 jmp 54ab4 <_Thread_Enable_dispatch>
00047b10 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
47b10: 4e56 0000 linkw %fp,#0
47b14: 2f0a movel %a2,%sp@-
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
47b16: 4878 0018 pea 18 <OPER2+0x4>
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
47b1a: 246e 0008 moveal %fp@(8),%a2
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
47b1e: 4eb9 0004 933c jsr 4933c <_Workspace_Allocate>
if ( sched ) {
47b24: 588f addql #4,%sp
47b26: 4a80 tstl %d0
47b28: 670e beqs 47b38 <_Scheduler_EDF_Allocate+0x28> <== NEVER TAKEN
the_thread->scheduler_info = sched;
47b2a: 2540 008a movel %d0,%a2@(138)
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
47b2e: 2040 moveal %d0,%a0
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
47b30: 7202 moveq #2,%d1
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
if ( sched ) {
the_thread->scheduler_info = sched;
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
47b32: 208a movel %a2,%a0@
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
47b34: 2141 0014 movel %d1,%a0@(20)
}
return sched;
}
47b38: 246e fffc moveal %fp@(-4),%a2
47b3c: 4e5e unlk %fp <== NOT EXECUTED
00047b40 <_Scheduler_EDF_Block>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Block(
Thread_Control *the_thread
)
{
47b40: 4e56 0000 linkw %fp,#0
47b44: 2f02 movel %d2,%sp@-
47b46: 242e 0008 movel %fp@(8),%d2
_Scheduler_EDF_Extract( the_thread );
47b4a: 2f02 movel %d2,%sp@-
47b4c: 4eb9 0004 7bb8 jsr 47bb8 <_Scheduler_EDF_Extract>
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
47b52: 588f addql #4,%sp
47b54: b4b9 0006 04a6 cmpl 604a6 <_Per_CPU_Information+0x10>,%d2
47b5a: 6606 bnes 47b62 <_Scheduler_EDF_Block+0x22> <== NEVER TAKEN
_Scheduler_EDF_Schedule();
47b5c: 4eb9 0004 7cd8 jsr 47cd8 <_Scheduler_EDF_Schedule>
if ( _Thread_Is_executing( the_thread ) )
47b62: b4b9 0006 04a2 cmpl 604a2 <_Per_CPU_Information+0xc>,%d2
47b68: 6608 bnes 47b72 <_Scheduler_EDF_Block+0x32> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
47b6a: 7001 moveq #1,%d0
47b6c: 13c0 0006 04ae moveb %d0,604ae <_Per_CPU_Information+0x18>
}
47b72: 242e fffc movel %fp@(-4),%d2
47b76: 4e5e unlk %fp
...
00047be4 <_Scheduler_EDF_Free>:
#include <rtems/score/wkspace.h>
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
47be4: 4e56 0000 linkw %fp,#0
_Workspace_Free( the_thread->scheduler_info );
47be8: 206e 0008 moveal %fp@(8),%a0
47bec: 2d68 008a 0008 movel %a0@(138),%fp@(8)
}
47bf2: 4e5e unlk %fp
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
47bf4: 4ef9 0004 9358 jmp 49358 <_Workspace_Free>
...
00047c9c <_Scheduler_EDF_Release_job>:
void _Scheduler_EDF_Release_job(
Thread_Control *the_thread,
uint32_t deadline
)
{
47c9c: 4e56 0000 linkw %fp,#0
47ca0: 206e 0008 moveal %fp@(8),%a0
47ca4: 202e 000c movel %fp@(12),%d0
Priority_Control new_priority;
if (deadline) {
47ca8: 670e beqs 47cb8 <_Scheduler_EDF_Release_job+0x1c><== NEVER TAKEN
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
47caa: 2239 0006 0142 movel 60142 <_Watchdog_Ticks_since_boot>,%d1
47cb0: d081 addl %d1,%d0
47cb2: 0880 001f bclr #31,%d0
47cb6: 6004 bras 47cbc <_Scheduler_EDF_Release_job+0x20>
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
47cb8: 2028 00ac movel %a0@(172),%d0 <== NOT EXECUTED
}
the_thread->real_priority = new_priority;
47cbc: 2140 0018 movel %d0,%a0@(24)
_Thread_Change_priority(the_thread, new_priority, true);
47cc0: 4878 0001 pea 1 <ADD>
47cc4: 2f00 movel %d0,%sp@-
47cc6: 2f08 movel %a0,%sp@-
47cc8: 4eb9 0004 7fdc jsr 47fdc <_Thread_Change_priority>
47cce: 4fef 000c lea %sp@(12),%sp
}
47cd2: 4e5e unlk %fp
...
00047cfc <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
47cfc: 4e56 0000 linkw %fp,#0
47d00: 2f0a movel %a2,%sp@-
47d02: 246e 0008 moveal %fp@(8),%a2
_Scheduler_EDF_Enqueue(the_thread);
47d06: 2f0a movel %a2,%sp@-
47d08: 4eb9 0004 7b88 jsr 47b88 <_Scheduler_EDF_Enqueue>
47d0e: 2f2a 0014 movel %a2@(20),%sp@-
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
47d12: 2079 0006 04a6 moveal 604a6 <_Per_CPU_Information+0x10>,%a0
47d18: 2f28 0014 movel %a0@(20),%sp@-
47d1c: 2079 0005 e6fe moveal 5e6fe <_Scheduler+0x30>,%a0
47d22: 4e90 jsr %a0@
47d24: 4fef 000c lea %sp@(12),%sp
47d28: 4a80 tstl %d0
47d2a: 6c20 bges 47d4c <_Scheduler_EDF_Unblock+0x50>
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
47d2c: 2079 0006 04a2 moveal 604a2 <_Per_CPU_Information+0xc>,%a0
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
47d32: 23ca 0006 04a6 movel %a2,604a6 <_Per_CPU_Information+0x10>
if ( _Thread_Executing->is_preemptible ||
47d38: 4a28 0074 tstb %a0@(116)
47d3c: 6606 bnes 47d44 <_Scheduler_EDF_Unblock+0x48> <== ALWAYS TAKEN
47d3e: 4aaa 0014 tstl %a2@(20) <== NOT EXECUTED
47d42: 6608 bnes 47d4c <_Scheduler_EDF_Unblock+0x50> <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
47d44: 7001 moveq #1,%d0
47d46: 13c0 0006 04ae moveb %d0,604ae <_Per_CPU_Information+0x18>
}
}
47d4c: 246e fffc moveal %fp@(-4),%a2
47d50: 4e5e unlk %fp <== NOT EXECUTED
00047d54 <_Scheduler_EDF_Update>:
{
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
47d54: 7002 moveq #2,%d0
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
47d56: 4e56 0000 linkw %fp,#0
47d5a: 2f0a movel %a2,%sp@-
47d5c: 246e 0008 moveal %fp@(8),%a2
Scheduler_EDF_Per_thread *sched_info =
47d60: 206a 008a moveal %a2@(138),%a0
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
47d64: 2f02 movel %d2,%sp@-
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
47d66: b0a8 0014 cmpl %a0@(20),%d0
47d6a: 6618 bnes 47d84 <_Scheduler_EDF_Update+0x30>
/* Shifts the priority to the region of background tasks. */
the_thread->Start.initial_priority |= (SCHEDULER_EDF_PRIO_MSB);
47d6c: 202a 00ac movel %a2@(172),%d0
47d70: 08c0 001f bset #31,%d0
47d74: 2540 00ac movel %d0,%a2@(172)
the_thread->real_priority = the_thread->Start.initial_priority;
47d78: 2540 0018 movel %d0,%a2@(24)
the_thread->current_priority = the_thread->Start.initial_priority;
47d7c: 2540 0014 movel %d0,%a2@(20)
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
47d80: 42a8 0014 clrl %a0@(20)
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
47d84: 7001 moveq #1,%d0
47d86: b0a8 0014 cmpl %a0@(20),%d0
47d8a: 664c bnes 47dd8 <_Scheduler_EDF_Update+0x84> <== ALWAYS TAKEN
Thread_Control *the_thread
)
{
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
47d8c: 2408 movel %a0,%d2 <== NOT EXECUTED
47d8e: 5882 addql #4,%d2 <== NOT EXECUTED
the_thread->current_priority = the_thread->Start.initial_priority;
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
_RBTree_Extract(&_Scheduler_EDF_Ready_queue, the_node);
47d90: 2f02 movel %d2,%sp@- <== NOT EXECUTED
47d92: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47d98: 4eb9 0004 bccc jsr 4bccc <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert(&_Scheduler_EDF_Ready_queue, the_node);
47d9e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
47da0: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47da6: 4eb9 0004 be90 jsr 4be90 <_RBTree_Insert> <== NOT EXECUTED
_Scheduler_EDF_Schedule();
47dac: 4eb9 0004 7cd8 jsr 47cd8 <_Scheduler_EDF_Schedule> <== NOT EXECUTED
if ( _Thread_Executing != _Thread_Heir ) {
47db2: 2079 0006 04a2 moveal 604a2 <_Per_CPU_Information+0xc>,%a0 <== NOT EXECUTED
47db8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
47dbc: b1f9 0006 04a6 cmpal 604a6 <_Per_CPU_Information+0x10>,%a0 <== NOT EXECUTED
47dc2: 6714 beqs 47dd8 <_Scheduler_EDF_Update+0x84> <== NOT EXECUTED
if ( _Thread_Executing->is_preemptible ||
47dc4: 4a28 0074 tstb %a0@(116) <== NOT EXECUTED
47dc8: 6606 bnes 47dd0 <_Scheduler_EDF_Update+0x7c> <== NOT EXECUTED
47dca: 4aaa 0014 tstl %a2@(20) <== NOT EXECUTED
47dce: 6608 bnes 47dd8 <_Scheduler_EDF_Update+0x84> <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
47dd0: 7001 moveq #1,%d0 <== NOT EXECUTED
47dd2: 13c0 0006 04ae moveb %d0,604ae <_Per_CPU_Information+0x18> <== NOT EXECUTED
}
}
}
47dd8: 242e fff8 movel %fp@(-8),%d2
47ddc: 246e fffc moveal %fp@(-4),%a2
47de0: 4e5e unlk %fp <== NOT EXECUTED
00047de4 <_Scheduler_EDF_Yield>:
Thread_Control *executing = _Thread_Executing;
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
47de4: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
47dea: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
47dee: 48d7 040c moveml %d2-%d3/%a2,%sp@ <== NOT EXECUTED
Scheduler_EDF_Per_thread *first_info;
RBTree_Node *first_node;
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
47df2: 2479 0006 04a2 moveal 604a2 <_Per_CPU_Information+0xc>,%a2 <== NOT EXECUTED
Scheduler_EDF_Per_thread *executing_info =
47df8: 262a 008a movel %a2@(138),%d3 <== NOT EXECUTED
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
47dfc: 40c2 movew %sr,%d2 <== NOT EXECUTED
47dfe: 8082 orl %d2,%d0 <== NOT EXECUTED
47e00: 46c0 movew %d0,%sr <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _RBTree_Has_only_one_node(
const RBTree_Control *the_rbtree
)
{
if(!the_rbtree) return NULL; /* TODO: expected behavior? */
return (the_rbtree->root->child[RBT_LEFT] == NULL && the_rbtree->root->child[RBT_RIGHT] == NULL);
47e02: 2079 0006 04bc moveal 604bc <_Scheduler_EDF_Ready_queue+0x4>,%a0<== NOT EXECUTED
47e08: 4aa8 0004 tstl %a0@(4) <== NOT EXECUTED
47e0c: 660c bnes 47e1a <_Scheduler_EDF_Yield+0x36> <== NOT EXECUTED
#include <rtems/score/isr.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
47e0e: 4aa8 0008 tstl %a0@(8) <== NOT EXECUTED
47e12: 57c0 seq %d0 <== NOT EXECUTED
47e14: 49c0 extbl %d0 <== NOT EXECUTED
47e16: 4480 negl %d0 <== NOT EXECUTED
47e18: 6002 bras 47e1c <_Scheduler_EDF_Yield+0x38> <== NOT EXECUTED
47e1a: 4280 clrl %d0 <== NOT EXECUTED
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
if ( !_RBTree_Has_only_one_node(&_Scheduler_EDF_Ready_queue) ) {
47e1c: 4a00 tstb %d0 <== NOT EXECUTED
47e1e: 6652 bnes 47e72 <_Scheduler_EDF_Yield+0x8e> <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
47e20: 5883 addql #4,%d3 <== NOT EXECUTED
if ( !_RBTree_Has_only_one_node(&_Scheduler_EDF_Ready_queue) ) {
/*
* The RBTree has more than one node, enqueue behind the tasks
* with the same priority in case there are such ones.
*/
_RBTree_Extract( &_Scheduler_EDF_Ready_queue, executing_node );
47e22: 2f03 movel %d3,%sp@- <== NOT EXECUTED
47e24: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47e2a: 4eb9 0004 bccc jsr 4bccc <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
47e30: 2f03 movel %d3,%sp@- <== NOT EXECUTED
47e32: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47e38: 4eb9 0004 be90 jsr 4be90 <_RBTree_Insert> <== NOT EXECUTED
_ISR_Flash( level );
47e3e: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
47e44: 46c2 movew %d2,%sr <== NOT EXECUTED
47e46: 8082 orl %d2,%d0 <== NOT EXECUTED
47e48: 46c0 movew %d0,%sr <== NOT EXECUTED
if ( _Thread_Is_heir( executing ) ) {
47e4a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
47e4e: b5f9 0006 04a6 cmpal 604a6 <_Per_CPU_Information+0x10>,%a2 <== NOT EXECUTED
47e54: 6624 bnes 47e7a <_Scheduler_EDF_Yield+0x96> <== NOT EXECUTED
first_node = _RBTree_Peek( &_Scheduler_EDF_Ready_queue, RBT_LEFT );
47e56: 42a7 clrl %sp@- <== NOT EXECUTED
47e58: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47e5e: 4eb9 0004 bebc jsr 4bebc <_RBTree_Peek> <== NOT EXECUTED
first_info =
_RBTree_Container_of(first_node, Scheduler_EDF_Per_thread, Node);
_Thread_Heir = first_info->thread;
47e64: 508f addql #8,%sp <== NOT EXECUTED
47e66: 2040 moveal %d0,%a0 <== NOT EXECUTED
47e68: 5988 subql #4,%a0 <== NOT EXECUTED
47e6a: 23d0 0006 04a6 movel %a0@,604a6 <_Per_CPU_Information+0x10><== NOT EXECUTED
47e70: 6008 bras 47e7a <_Scheduler_EDF_Yield+0x96> <== NOT EXECUTED
}
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
47e72: b5f9 0006 04a6 cmpal 604a6 <_Per_CPU_Information+0x10>,%a2 <== NOT EXECUTED
47e78: 6708 beqs 47e82 <_Scheduler_EDF_Yield+0x9e> <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
47e7a: 7001 moveq #1,%d0 <== NOT EXECUTED
47e7c: 13c0 0006 04ae moveb %d0,604ae <_Per_CPU_Information+0x18> <== NOT EXECUTED
_ISR_Enable( level );
47e82: 46c2 movew %d2,%sr <== NOT EXECUTED
}
47e84: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 <== NOT EXECUTED
47e8a: 4e5e unlk %fp <== NOT EXECUTED
...
00047434 <_Scheduler_Handler_initialization>:
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
47434: 4e56 0000 linkw %fp,#0
(*_Scheduler.Operations.initialize)();
}
47438: 4e5e unlk %fp
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
(*_Scheduler.Operations.initialize)();
4743a: 2279 0005 d2a2 moveal 5d2a2 <_Scheduler+0x4>,%a1
47440: 4ed1 jmp %a1@
...
0004760c <_Scheduler_priority_Free>:
#include <rtems/score/wkspace.h>
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
4760c: 4e56 0000 linkw %fp,#0
_Workspace_Free( the_thread->scheduler_info );
47610: 206e 0008 moveal %fp@(8),%a0
47614: 2d68 008a 0008 movel %a0@(138),%fp@(8)
}
4761a: 4e5e unlk %fp
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
4761c: 4ef9 0004 8c2c jmp 48c2c <_Workspace_Free>
...
00047704 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
47704: 4e56 0000 linkw %fp,#0
47708: 2f0a movel %a2,%sp@-
Thread_Control *executing;
executing = _Thread_Executing;
4770a: 2479 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a2
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
47710: 4a2a 0074 tstb %a2@(116)
47714: 6758 beqs 4776e <_Scheduler_priority_Tick+0x6a>
return;
if ( !_States_Is_ready( executing->current_state ) )
47716: 4aaa 0010 tstl %a2@(16)
4771a: 6652 bnes 4776e <_Scheduler_priority_Tick+0x6a>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
4771c: 202a 007a movel %a2@(122),%d0
47720: 7201 moveq #1,%d1
47722: b280 cmpl %d0,%d1
47724: 6248 bhis 4776e <_Scheduler_priority_Tick+0x6a>
47726: 123c 0002 moveb #2,%d1
4772a: b280 cmpl %d0,%d1
4772c: 640a bccs 47738 <_Scheduler_priority_Tick+0x34>
4772e: 123c 0003 moveb #3,%d1
47732: b280 cmpl %d0,%d1
47734: 6638 bnes 4776e <_Scheduler_priority_Tick+0x6a> <== NEVER TAKEN
47736: 6020 bras 47758 <_Scheduler_priority_Tick+0x54>
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
47738: 202a 0076 movel %a2@(118),%d0
4773c: 5380 subql #1,%d0
4773e: 2540 0076 movel %d0,%a2@(118)
47742: 6e2a bgts 4776e <_Scheduler_priority_Tick+0x6a>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
47744: 2079 0005 d2aa moveal 5d2aa <_Scheduler+0xc>,%a0
4774a: 4e90 jsr %a0@
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield();
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4774c: 41f9 0005 eb50 lea 5eb50 <_Thread_Ticks_per_timeslice>,%a0
47752: 2550 0076 movel %a0@,%a2@(118)
47756: 6016 bras 4776e <_Scheduler_priority_Tick+0x6a>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
47758: 202a 0076 movel %a2@(118),%d0
4775c: 5380 subql #1,%d0
4775e: 2540 0076 movel %d0,%a2@(118)
47762: 660a bnes 4776e <_Scheduler_priority_Tick+0x6a>
(*executing->budget_callout)( executing );
47764: 2f0a movel %a2,%sp@-
47766: 206a 007e moveal %a2@(126),%a0
4776a: 4e90 jsr %a0@
4776c: 588f addql #4,%sp
break;
#endif
}
}
4776e: 246e fffc moveal %fp@(-4),%a2
47772: 4e5e unlk %fp
...
000461dc <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
461dc: 4e56 0000 linkw %fp,#0
461e0: 206e 0008 moveal %fp@(8),%a0
461e4: 2f03 movel %d3,%sp@-
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
461e6: 2039 0005 efd8 movel 5efd8 <Configuration+0xc>,%d0
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
461ec: 2f02 movel %d2,%sp@-
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
461ee: 4a88 tstl %a0
461f0: 6762 beqs 46254 <_TOD_Validate+0x78> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
461f2: 243c 000f 4240 movel #1000000,%d2
461f8: 4c40 2002 remul %d0,%d2,%d2
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
461fc: b4a8 0018 cmpl %a0@(24),%d2
46200: 6352 blss 46254 <_TOD_Validate+0x78>
(the_tod->ticks >= ticks_per_second) ||
46202: 763b moveq #59,%d3
46204: b6a8 0014 cmpl %a0@(20),%d3
46208: 654a bcss 46254 <_TOD_Validate+0x78>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
4620a: b6a8 0010 cmpl %a0@(16),%d3
4620e: 6544 bcss 46254 <_TOD_Validate+0x78>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
46210: 7017 moveq #23,%d0
46212: b0a8 000c cmpl %a0@(12),%d0
46216: 653c bcss 46254 <_TOD_Validate+0x78>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
46218: 2028 0004 movel %a0@(4),%d0
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
4621c: 6736 beqs 46254 <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->month == 0) ||
4621e: 720c moveq #12,%d1
46220: b280 cmpl %d0,%d1
46222: 6530 bcss 46254 <_TOD_Validate+0x78>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
46224: 2410 movel %a0@,%d2
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
46226: 0c82 0000 07c3 cmpil #1987,%d2
4622c: 6326 blss 46254 <_TOD_Validate+0x78>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
4622e: 2228 0008 movel %a0@(8),%d1
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
46232: 6720 beqs 46254 <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
46234: 163c 0003 moveb #3,%d3
46238: 41f9 0005 e058 lea 5e058 <_TOD_Days_per_month>,%a0
4623e: c483 andl %d3,%d2
46240: 6606 bnes 46248 <_TOD_Validate+0x6c>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
46242: 2030 0c34 movel %a0@(00000034,%d0:l:4),%d0
46246: 6004 bras 4624c <_TOD_Validate+0x70>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
46248: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
4624c: b081 cmpl %d1,%d0
4624e: 54c0 scc %d0
46250: 4480 negl %d0
46252: 6002 bras 46256 <_TOD_Validate+0x7a>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
46254: 4200 clrb %d0
if ( the_tod->day > days_in_month )
return false;
return true;
}
46256: 241f movel %sp@+,%d2
46258: 261f movel %sp@+,%d3
4625a: 4e5e unlk %fp
...
00047930 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47930: 4e56 fff0 linkw %fp,#-16
47934: 48d7 041c moveml %d2-%d4/%a2,%sp@
47938: 246e 0008 moveal %fp@(8),%a2
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
4793c: 282a 0010 movel %a2@(16),%d4
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47940: 242e 000c movel %fp@(12),%d2
/*
* Set a transient state for the thread so it is pulled off the Ready chains.
* This will prevent it from being scheduled no matter what happens in an
* ISR.
*/
_Thread_Set_transient( the_thread );
47944: 2f0a movel %a2,%sp@-
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47946: 162e 0013 moveb %fp@(19),%d3
/*
* Set a transient state for the thread so it is pulled off the Ready chains.
* This will prevent it from being scheduled no matter what happens in an
* ISR.
*/
_Thread_Set_transient( the_thread );
4794a: 4eb9 0004 8548 jsr 48548 <_Thread_Set_transient>
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
47950: 588f addql #4,%sp
47952: b4aa 0014 cmpl %a2@(20),%d2
47956: 670c beqs 47964 <_Thread_Change_priority+0x34>
_Thread_Set_priority( the_thread, new_priority );
47958: 2f02 movel %d2,%sp@-
4795a: 2f0a movel %a2,%sp@-
4795c: 4eb9 0004 84ec jsr 484ec <_Thread_Set_priority>
47962: 508f addql #8,%sp
_ISR_Disable( level );
47964: 203c 0000 0700 movel #1792,%d0
4796a: 40c2 movew %sr,%d2
4796c: 8082 orl %d2,%d0
4796e: 46c0 movew %d0,%sr
47970: 7204 moveq #4,%d1
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
47972: 202a 0010 movel %a2@(16),%d0
47976: c284 andl %d4,%d1
if ( state != STATES_TRANSIENT ) {
47978: 7804 moveq #4,%d4
4797a: b880 cmpl %d0,%d4
4797c: 672e beqs 479ac <_Thread_Change_priority+0x7c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
4797e: 4a81 tstl %d1
47980: 6608 bnes 4798a <_Thread_Change_priority+0x5a> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
47982: 72fb moveq #-5,%d1
47984: c280 andl %d0,%d1
47986: 2541 0010 movel %d1,%a2@(16)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
4798a: 46c2 movew %d2,%sr
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
4798c: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
47992: 676c beqs 47a00 <_Thread_Change_priority+0xd0>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
47994: 2d4a 000c movel %a2,%fp@(12)
47998: 2d6a 0044 0008 movel %a2@(68),%fp@(8)
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
4799e: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
479a4: 4e5e unlk %fp
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
479a6: 4ef9 0004 844c jmp 4844c <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
479ac: 4a81 tstl %d1
479ae: 661e bnes 479ce <_Thread_Change_priority+0x9e> <== NEVER TAKEN
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
479b0: 42aa 0010 clrl %a2@(16)
if ( prepend_it )
479b4: 4a03 tstb %d3
479b6: 670a beqs 479c2 <_Thread_Change_priority+0x92>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
479b8: 2f0a movel %a2,%sp@-
479ba: 2079 0005 d2c6 moveal 5d2c6 <_Scheduler+0x28>,%a0
479c0: 6008 bras 479ca <_Thread_Change_priority+0x9a>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
479c2: 2079 0005 d2c2 moveal 5d2c2 <_Scheduler+0x24>,%a0
479c8: 2f0a movel %a2,%sp@-
479ca: 4e90 jsr %a0@
479cc: 588f addql #4,%sp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
479ce: 203c 0000 0700 movel #1792,%d0
479d4: 46c2 movew %d2,%sr
479d6: 8082 orl %d2,%d0
479d8: 46c0 movew %d0,%sr
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
479da: 2079 0005 d2a6 moveal 5d2a6 <_Scheduler+0x8>,%a0
479e0: 4e90 jsr %a0@
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
479e2: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
479e8: b1f9 0005 effe cmpal 5effe <_Per_CPU_Information+0x10>,%a0
479ee: 670e beqs 479fe <_Thread_Change_priority+0xce>
479f0: 4a28 0074 tstb %a0@(116)
479f4: 6708 beqs 479fe <_Thread_Change_priority+0xce>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
479f6: 7801 moveq #1,%d4
479f8: 13c4 0005 f006 moveb %d4,5f006 <_Per_CPU_Information+0x18>
_ISR_Enable( level );
479fe: 46c2 movew %d2,%sr
}
47a00: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
47a06: 4e5e unlk %fp
...
00047be4 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
47be4: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
47be8: 486e fffc pea %fp@(-4)
47bec: 2f2e 0008 movel %fp@(8),%sp@-
47bf0: 4eb9 0004 7da8 jsr 47da8 <_Thread_Get>
switch ( location ) {
47bf6: 508f addql #8,%sp
47bf8: 4aae fffc tstl %fp@(-4)
47bfc: 6624 bnes 47c22 <_Thread_Delay_ended+0x3e> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
47bfe: 2f3c 1000 0018 movel #268435480,%sp@-
47c04: 2f00 movel %d0,%sp@-
47c06: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state>
47c0c: 508f addql #8,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
47c0e: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
47c14: 5380 subql #1,%d0
47c16: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47c1c: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
47c22: 4e5e unlk %fp
...
00047c28 <_Thread_Dispatch>:
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
47c28: 4e56 ffd0 linkw %fp,#-48
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
47c2c: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
47c32: 5280 addql #1,%d0
47c34: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47c3a: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
47c40: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
47c44: 223c 0000 0700 movel #1792,%d1
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
47c4a: 2479 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
47c50: 40c0 movew %sr,%d0
47c52: 8280 orl %d0,%d1
47c54: 46c1 movew %d1,%sr
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47c56: 260e movel %fp,%d3
_Timestamp_Subtract(
47c58: 240e movel %fp,%d2
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47c5a: 0683 ffff fff0 addil #-16,%d3
47c60: 2a3c 0004 af48 movel #307016,%d5
_Timestamp_Subtract(
47c66: 5182 subql #8,%d2
47c68: 283c 0004 86dc movel #296668,%d4
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47c6e: 4bf9 0004 86a4 lea 486a4 <_Timespec_Add_to>,%a5
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
47c74: 49f9 0004 895c lea 4895c <_User_extensions_Thread_switch>,%a4
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
47c7a: 6000 00d2 braw 47d4e <_Thread_Dispatch+0x126>
heir = _Thread_Heir;
47c7e: 2679 0005 effe moveal 5effe <_Per_CPU_Information+0x10>,%a3
_Thread_Dispatch_necessary = false;
47c84: 4201 clrb %d1
_Thread_Executing = heir;
47c86: 23cb 0005 effa movel %a3,5effa <_Per_CPU_Information+0xc>
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
47c8c: 13c1 0005 f006 moveb %d1,5f006 <_Per_CPU_Information+0x18>
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
47c92: b5cb cmpal %a3,%a2
47c94: 6700 00c2 beqw 47d58 <_Thread_Dispatch+0x130>
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
47c98: 7201 moveq #1,%d1
47c9a: b2ab 007a cmpl %a3@(122),%d1
47c9e: 660a bnes 47caa <_Thread_Dispatch+0x82>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
47ca0: 41f9 0005 eb50 lea 5eb50 <_Thread_Ticks_per_timeslice>,%a0
47ca6: 2750 0076 movel %a0@,%a3@(118)
_ISR_Enable( level );
47caa: 46c0 movew %d0,%sr
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47cac: 2f03 movel %d3,%sp@-
47cae: 2045 moveal %d5,%a0
47cb0: 4e90 jsr %a0@
_Timestamp_Subtract(
47cb2: 2044 moveal %d4,%a0
47cb4: 2f02 movel %d2,%sp@-
47cb6: 2f03 movel %d3,%sp@-
47cb8: 4879 0005 f008 pea 5f008 <_Per_CPU_Information+0x1a>
47cbe: 4e90 jsr %a0@
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47cc0: 2f02 movel %d2,%sp@-
47cc2: 486a 0082 pea %a2@(130)
47cc6: 4e95 jsr %a5@
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
47cc8: 2079 0005 ec1e moveal 5ec1e <_Thread_libc_reent>,%a0
47cce: 4fef 0018 lea %sp@(24),%sp
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
47cd2: 202e fff0 movel %fp@(-16),%d0
47cd6: 222e fff4 movel %fp@(-12),%d1
47cda: 23c0 0005 f008 movel %d0,5f008 <_Per_CPU_Information+0x1a>
47ce0: 23c1 0005 f00c movel %d1,5f00c <_Per_CPU_Information+0x1e>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
47ce6: 4a88 tstl %a0
47ce8: 6708 beqs 47cf2 <_Thread_Dispatch+0xca> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
47cea: 2550 00fa movel %a0@,%a2@(250)
*_Thread_libc_reent = heir->libc_reent;
47cee: 20ab 00fa movel %a3@(250),%a0@
}
_User_extensions_Thread_switch( executing, heir );
47cf2: 2f0b movel %a3,%sp@-
47cf4: 2f0a movel %a2,%sp@-
47cf6: 4e94 jsr %a4@
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
47cf8: 486b 00c2 pea %a3@(194)
47cfc: 486a 00c2 pea %a2@(194)
47d00: 4eb9 0004 8c7c jsr 48c7c <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
47d06: 4fef 0010 lea %sp@(16),%sp
47d0a: 4aaa 00f6 tstl %a2@(246)
47d0e: 672c beqs 47d3c <_Thread_Dispatch+0x114>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
47d10: 2079 0005 ec1a moveal 5ec1a <_Thread_Allocated_fp>,%a0
47d16: b1ca cmpal %a2,%a0
47d18: 6722 beqs 47d3c <_Thread_Dispatch+0x114>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
47d1a: 4a88 tstl %a0
47d1c: 670c beqs 47d2a <_Thread_Dispatch+0x102>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
47d1e: 4868 00f6 pea %a0@(246)
47d22: 4eb9 0004 8dc2 jsr 48dc2 <_CPU_Context_save_fp>
47d28: 588f addql #4,%sp
_Context_Restore_fp( &executing->fp_context );
47d2a: 486a 00f6 pea %a2@(246)
47d2e: 4eb9 0004 8de4 jsr 48de4 <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
47d34: 588f addql #4,%sp
47d36: 23ca 0005 ec1a movel %a2,5ec1a <_Thread_Allocated_fp>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
47d3c: 2479 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
47d42: 223c 0000 0700 movel #1792,%d1
47d48: 40c0 movew %sr,%d0
47d4a: 8280 orl %d0,%d1
47d4c: 46c1 movew %d1,%sr
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
47d4e: 1239 0005 f006 moveb 5f006 <_Per_CPU_Information+0x18>,%d1
47d54: 6600 ff28 bnew 47c7e <_Thread_Dispatch+0x56>
_ISR_Disable( level );
}
post_switch:
_ISR_Enable( level );
47d58: 46c0 movew %d0,%sr
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
47d5a: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
47d60: 5380 subql #1,%d0
47d62: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47d68: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
47d6e: 4eb9 0004 6288 jsr 46288 <_API_extensions_Run_postswitch>
}
47d74: 4cee 3c3c ffd0 moveml %fp@(-48),%d2-%d5/%a2-%a5
47d7a: 4e5e unlk %fp
...
00047da8 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
47da8: 4e56 0000 linkw %fp,#0
47dac: 202e 0008 movel %fp@(8),%d0
47db0: 2f03 movel %d3,%sp@-
47db2: 206e 000c moveal %fp@(12),%a0
47db6: 2f02 movel %d2,%sp@-
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
47db8: 4a80 tstl %d0
47dba: 661e bnes 47dda <_Thread_Get+0x32>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
47dbc: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
47dc2: 5280 addql #1,%d0
47dc4: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47dca: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
47dd0: 4290 clrl %a0@
tp = _Thread_Executing;
47dd2: 2039 0005 effa movel 5effa <_Per_CPU_Information+0xc>,%d0
goto done;
47dd8: 6044 bras 47e1e <_Thread_Get+0x76>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
47dda: 7418 moveq #24,%d2
47ddc: 2200 movel %d0,%d1
47dde: e4a9 lsrl %d2,%d1
47de0: 7607 moveq #7,%d3
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47de2: 143c 0002 moveb #2,%d2
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
47de6: c283 andl %d3,%d1
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47de8: 2241 moveal %d1,%a1
47dea: 5389 subql #1,%a1
47dec: b489 cmpl %a1,%d2
47dee: 643a bccs 47e2a <_Thread_Get+0x82>
47df0: 6014 bras 47e06 <_Thread_Get+0x5e>
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
47df2: 43f9 0005 eb54 lea 5eb54 <_Objects_Information_table>,%a1
47df8: 2271 1c00 moveal %a1@(00000000,%d1:l:4),%a1
* There is no way for this to happen if POSIX is enabled. But there
* is actually a test case in sp43 for this which trips it whether or
* not POSIX is enabled. So in the interest of safety, this is left
* on in all configurations.
*/
if ( !api_information ) {
47dfc: 4a89 tstl %a1
47dfe: 6706 beqs 47e06 <_Thread_Get+0x5e>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
47e00: 2229 0004 movel %a1@(4),%d1
if ( !information ) {
47e04: 6608 bnes 47e0e <_Thread_Get+0x66>
*location = OBJECTS_ERROR;
47e06: 7001 moveq #1,%d0
47e08: 2080 movel %d0,%a0@
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
47e0a: 4280 clrl %d0
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
goto done;
47e0c: 6010 bras 47e1e <_Thread_Get+0x76>
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
47e0e: 2f08 movel %a0,%sp@-
47e10: 2f00 movel %d0,%sp@-
47e12: 2f01 movel %d1,%sp@-
47e14: 4eb9 0004 70f8 jsr 470f8 <_Objects_Get>
47e1a: 4fef 000c lea %sp@(12),%sp
done:
return tp;
}
47e1e: 242e fff8 movel %fp@(-8),%d2
47e22: 262e fffc movel %fp@(-4),%d3
47e26: 4e5e unlk %fp
47e28: 4e75 rts
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
47e2a: 761b moveq #27,%d3
47e2c: 2400 movel %d0,%d2
47e2e: e6aa lsrl %d3,%d2
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
47e30: 163c 0001 moveb #1,%d3
47e34: b682 cmpl %d2,%d3
47e36: 67ba beqs 47df2 <_Thread_Get+0x4a>
47e38: 60cc bras 47e06 <_Thread_Get+0x5e>
...
0004cb84 <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4cb84: 4e56 0000 linkw %fp,#0
4cb88: 2f0a movel %a2,%sp@-
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
4cb8a: 2479 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a2
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4cb90: 2f02 movel %d2,%sp@-
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
4cb92: 222a 00a8 movel %a2@(168),%d1
_ISR_Set_level(level);
4cb96: 40c0 movew %sr,%d0
4cb98: e189 lsll #8,%d1
4cb9a: 0280 0000 f8ff andil #63743,%d0
4cba0: 8081 orl %d1,%d0
4cba2: 46c0 movew %d0,%sr
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
doneConstructors = true;
4cba4: 7001 moveq #1,%d0
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
4cba6: 1439 0005 e358 moveb 5e358 <doneConstructors.3399>,%d2
doneConstructors = true;
4cbac: 13c0 0005 e358 moveb %d0,5e358 <doneConstructors.3399>
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
4cbb2: 4aaa 00f6 tstl %a2@(246)
4cbb6: 6720 beqs 4cbd8 <_Thread_Handler+0x54>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
4cbb8: 2079 0005 ec1a moveal 5ec1a <_Thread_Allocated_fp>,%a0
4cbbe: b1ca cmpal %a2,%a0
4cbc0: 6716 beqs 4cbd8 <_Thread_Handler+0x54>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
4cbc2: 4a88 tstl %a0
4cbc4: 670c beqs 4cbd2 <_Thread_Handler+0x4e>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
4cbc6: 4868 00f6 pea %a0@(246)
4cbca: 4eb9 0004 8dc2 jsr 48dc2 <_CPU_Context_save_fp>
4cbd0: 588f addql #4,%sp
_Thread_Allocated_fp = executing;
4cbd2: 23ca 0005 ec1a movel %a2,5ec1a <_Thread_Allocated_fp>
/*
* Take care that 'begin' extensions get to complete before
* 'switch' extensions can run. This means must keep dispatch
* disabled until all 'begin' extensions complete.
*/
_User_extensions_Thread_begin( executing );
4cbd8: 2f0a movel %a2,%sp@-
4cbda: 4eb9 0004 87d8 jsr 487d8 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4cbe0: 4eb9 0004 7d80 jsr 47d80 <_Thread_Enable_dispatch>
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (doCons) /* && (volatile void *)_init) */ {
4cbe6: 588f addql #4,%sp
4cbe8: 4a02 tstb %d2
4cbea: 6606 bnes 4cbf2 <_Thread_Handler+0x6e>
INIT_NAME ();
4cbec: 4eb9 0005 b2a8 jsr 5b2a8 <_init>
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4cbf2: 202a 0092 movel %a2@(146),%d0
4cbf6: 6606 bnes 4cbfe <_Thread_Handler+0x7a>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
4cbf8: 2f2a 009a movel %a2@(154),%sp@-
4cbfc: 600a bras 4cc08 <_Thread_Handler+0x84>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
4cbfe: 7201 moveq #1,%d1
4cc00: b280 cmpl %d0,%d1
4cc02: 6610 bnes 4cc14 <_Thread_Handler+0x90> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
4cc04: 2f2a 0096 movel %a2@(150),%sp@-
4cc08: 206a 008e moveal %a2@(142),%a0
4cc0c: 4e90 jsr %a0@
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
4cc0e: 588f addql #4,%sp
4cc10: 2540 0028 movel %d0,%a2@(40)
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
4cc14: 2f0a movel %a2,%sp@-
4cc16: 4eb9 0004 8810 jsr 48810 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
4cc1c: 4878 0005 pea 5 <COMPARE>
4cc20: 4878 0001 pea 1 <ADD>
4cc24: 42a7 clrl %sp@-
4cc26: 4eb9 0004 6bdc jsr 46bdc <_Internal_error_Occurred>
00047e3c <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
47e3c: 4e56 ffe4 linkw %fp,#-28
47e40: 222e 0010 movel %fp@(16),%d1
47e44: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
47e48: 246e 000c moveal %fp@(12),%a2
47e4c: 242e 0014 movel %fp@(20),%d2
47e50: 2a2e 001c movel %fp@(28),%d5
47e54: 282e 0024 movel %fp@(36),%d4
47e58: 162e 001b moveb %fp@(27),%d3
47e5c: 1c2e 0023 moveb %fp@(35),%d6
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
47e60: 42aa 00fe clrl %a2@(254)
47e64: 42aa 0102 clrl %a2@(258)
extensions_area = NULL;
the_thread->libc_reent = NULL;
47e68: 42aa 00fa clrl %a2@(250)
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
47e6c: 4a81 tstl %d1
47e6e: 6624 bnes 47e94 <_Thread_Initialize+0x58>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
47e70: 2f02 movel %d2,%sp@-
47e72: 2f0a movel %a2,%sp@-
47e74: 4eb9 0004 8584 jsr 48584 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
47e7a: 508f addql #8,%sp
47e7c: 4a80 tstl %d0
47e7e: 6700 0152 beqw 47fd2 <_Thread_Initialize+0x196>
47e82: b480 cmpl %d0,%d2
47e84: 6200 014c bhiw 47fd2 <_Thread_Initialize+0x196>
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
47e88: 222a 00be movel %a2@(190),%d1
the_thread->Start.core_allocated_stack = true;
47e8c: 7401 moveq #1,%d2
47e8e: 1542 00b0 moveb %d2,%a2@(176)
47e92: 6008 bras 47e9c <_Thread_Initialize+0x60>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
47e94: 4200 clrb %d0
47e96: 1540 00b0 moveb %d0,%a2@(176)
47e9a: 2002 movel %d2,%d0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
47e9c: 2541 00b6 movel %d1,%a2@(182)
the_stack->size = size;
47ea0: 2540 00b2 movel %d0,%a2@(178)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
47ea4: 4a03 tstb %d3
47ea6: 6714 beqs 47ebc <_Thread_Initialize+0x80>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
47ea8: 4878 001c pea 1c <OPER2+0x8>
47eac: 4eb9 0004 8c10 jsr 48c10 <_Workspace_Allocate>
if ( !fp_area )
47eb2: 588f addql #4,%sp
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
47eb4: 2600 movel %d0,%d3
if ( !fp_area )
47eb6: 6606 bnes 47ebe <_Thread_Initialize+0x82>
47eb8: 6000 00e4 braw 47f9e <_Thread_Initialize+0x162>
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
47ebc: 4283 clrl %d3
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
47ebe: 2039 0005 ec2a movel 5ec2a <_Thread_Maximum_extensions>,%d0
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area )
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
47ec4: 2543 00f6 movel %d3,%a2@(246)
the_thread->Start.fp_context = fp_area;
47ec8: 2543 00ba movel %d3,%a2@(186)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
47ecc: 42aa 0050 clrl %a2@(80)
the_watchdog->routine = routine;
47ed0: 42aa 0064 clrl %a2@(100)
the_watchdog->id = id;
47ed4: 42aa 0068 clrl %a2@(104)
the_watchdog->user_data = user_data;
47ed8: 42aa 006c clrl %a2@(108)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
47edc: 4a80 tstl %d0
47ede: 6718 beqs 47ef8 <_Thread_Initialize+0xbc>
extensions_area = _Workspace_Allocate(
47ee0: e588 lsll #2,%d0
47ee2: 2040 moveal %d0,%a0
47ee4: 4868 0004 pea %a0@(4)
47ee8: 4eb9 0004 8c10 jsr 48c10 <_Workspace_Allocate>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
47eee: 588f addql #4,%sp
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
47ef0: 2400 movel %d0,%d2
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
47ef2: 6606 bnes 47efa <_Thread_Initialize+0xbe>
47ef4: 6000 00aa braw 47fa0 <_Thread_Initialize+0x164>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
47ef8: 4282 clrl %d2
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
47efa: 2542 0106 movel %d2,%a2@(262)
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
47efe: 6718 beqs 47f18 <_Thread_Initialize+0xdc>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
47f00: 2239 0005 ec2a movel 5ec2a <_Thread_Maximum_extensions>,%d1
47f06: 4280 clrl %d0
47f08: 600a bras 47f14 <_Thread_Initialize+0xd8>
the_thread->extensions[i] = NULL;
47f0a: 206a 0106 moveal %a2@(262),%a0
47f0e: 42b0 0c00 clrl %a0@(00000000,%d0:l:4)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
47f12: 5280 addql #1,%d0
47f14: b280 cmpl %d0,%d1
47f16: 64f2 bccs 47f0a <_Thread_Initialize+0xce>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
47f18: 2544 00a0 movel %d4,%a2@(160)
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
47f1c: 7002 moveq #2,%d0
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
47f1e: 1546 009e moveb %d6,%a2@(158)
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
47f22: 256e 0028 00a4 movel %fp@(40),%a2@(164)
switch ( budget_algorithm ) {
47f28: b084 cmpl %d4,%d0
47f2a: 660a bnes 47f36 <_Thread_Initialize+0xfa>
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
47f2c: 41f9 0005 eb50 lea 5eb50 <_Thread_Ticks_per_timeslice>,%a0
47f32: 2550 0076 movel %a0@,%a2@(118)
#endif
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
47f36: 7001 moveq #1,%d0
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
47f38: 256e 002c 00a8 movel %fp@(44),%a2@(168)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
47f3e: 2079 0005 d2b6 moveal 5d2b6 <_Scheduler+0x18>,%a0
the_thread->current_state = STATES_DORMANT;
47f44: 2540 0010 movel %d0,%a2@(16)
the_thread->Wait.queue = NULL;
47f48: 42aa 0044 clrl %a2@(68)
the_thread->resource_count = 0;
47f4c: 42aa 001c clrl %a2@(28)
the_thread->real_priority = priority;
47f50: 2545 0018 movel %d5,%a2@(24)
the_thread->Start.initial_priority = priority;
47f54: 2545 00ac movel %d5,%a2@(172)
47f58: 2f0a movel %a2,%sp@-
47f5a: 4e90 jsr %a0@
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
47f5c: 588f addql #4,%sp
47f5e: 2800 movel %d0,%d4
47f60: 6740 beqs 47fa2 <_Thread_Initialize+0x166> <== NEVER TAKEN
goto failed;
_Thread_Set_priority( the_thread, priority );
47f62: 2f05 movel %d5,%sp@-
47f64: 2f0a movel %a2,%sp@-
47f66: 4eb9 0004 84ec jsr 484ec <_Thread_Set_priority>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
47f6c: 206e 0008 moveal %fp@(8),%a0
47f70: 4280 clrl %d0
47f72: 2068 0018 moveal %a0@(24),%a0
47f76: 302a 000a movew %a2@(10),%d0
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
47f7a: 42aa 0082 clrl %a2@(130)
47f7e: 42aa 0086 clrl %a2@(134)
47f82: 218a 0c00 movel %a2,%a0@(00000000,%d0:l:4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
47f86: 256e 0030 000c movel %fp@(48),%a2@(12)
* enabled when we get here. We want to be able to run the
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
47f8c: 2f0a movel %a2,%sp@-
47f8e: 4eb9 0004 8894 jsr 48894 <_User_extensions_Thread_create>
if ( extension_status )
47f94: 4fef 000c lea %sp@(12),%sp
47f98: 4a00 tstb %d0
47f9a: 6706 beqs 47fa2 <_Thread_Initialize+0x166>
47f9c: 6038 bras 47fd6 <_Thread_Initialize+0x19a>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
47f9e: 4282 clrl %d2
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
47fa0: 4284 clrl %d4
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
47fa2: 2f2a 00fa movel %a2@(250),%sp@-
47fa6: 47f9 0004 8c2c lea 48c2c <_Workspace_Free>,%a3
47fac: 4e93 jsr %a3@
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
47fae: 2f2a 00fe movel %a2@(254),%sp@-
47fb2: 4e93 jsr %a3@
47fb4: 2f2a 0102 movel %a2@(258),%sp@-
47fb8: 4e93 jsr %a3@
_Workspace_Free( extensions_area );
47fba: 2f02 movel %d2,%sp@-
47fbc: 4e93 jsr %a3@
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
47fbe: 2f03 movel %d3,%sp@-
47fc0: 4e93 jsr %a3@
#endif
_Workspace_Free( sched );
47fc2: 2f04 movel %d4,%sp@-
47fc4: 4e93 jsr %a3@
_Thread_Stack_Free( the_thread );
47fc6: 2f0a movel %a2,%sp@-
47fc8: 4eb9 0004 85d0 jsr 485d0 <_Thread_Stack_Free>
return false;
47fce: 4fef 001c lea %sp@(28),%sp
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
47fd2: 4200 clrb %d0
47fd4: 6002 bras 47fd8 <_Thread_Initialize+0x19c>
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
47fd6: 7001 moveq #1,%d0
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
47fd8: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
47fde: 4e5e unlk %fp
...
00048ae8 <_Thread_Restart>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
48ae8: 7001 moveq #1,%d0
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
48aea: 4e56 0000 linkw %fp,#0
48aee: 2f0a movel %a2,%sp@-
48af0: 246e 0008 moveal %fp@(8),%a2
48af4: c0aa 0010 andl %a2@(16),%d0
if ( !_States_Is_dormant( the_thread->current_state ) ) {
48af8: 6664 bnes 48b5e <_Thread_Restart+0x76>
_Thread_Set_transient( the_thread );
48afa: 2f0a movel %a2,%sp@-
48afc: 4eb9 0004 8bc8 jsr 48bc8 <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
48b02: 2f2e 0010 movel %fp@(16),%sp@-
48b06: 2f2e 000c movel %fp@(12),%sp@-
48b0a: 2f0a movel %a2,%sp@-
48b0c: 4eb9 0004 bc2c jsr 4bc2c <_Thread_Reset>
_Thread_Load_environment( the_thread );
48b12: 2f0a movel %a2,%sp@-
48b14: 4eb9 0004 b970 jsr 4b970 <_Thread_Load_environment>
_Thread_Ready( the_thread );
48b1a: 2f0a movel %a2,%sp@-
48b1c: 4eb9 0004 bbfc jsr 4bbfc <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
48b22: 2f0a movel %a2,%sp@-
48b24: 4eb9 0004 8f9c jsr 48f9c <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
48b2a: 4fef 001c lea %sp@(28),%sp
48b2e: b5f9 0005 f902 cmpal 5f902 <_Per_CPU_Information+0xc>,%a2
48b34: 662c bnes 48b62 <_Thread_Restart+0x7a>
*/
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( _Thread_Executing->fp_context != NULL )
48b36: 4aaa 00f6 tstl %a2@(246)
48b3a: 670c beqs 48b48 <_Thread_Restart+0x60>
_Context_Restore_fp( &_Thread_Executing->fp_context );
48b3c: 486a 00f6 pea %a2@(246)
48b40: 4eb9 0004 94a4 jsr 494a4 <_CPU_Context_restore_fp>
48b46: 588f addql #4,%sp
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
48b48: 2079 0005 f902 moveal 5f902 <_Per_CPU_Information+0xc>,%a0
48b4e: 41e8 00c2 lea %a0@(194),%a0
48b52: 2f08 movel %a0,%sp@-
48b54: 4eb9 0004 9352 jsr 49352 <_CPU_Context_Restart_self>
48b5a: 588f addql #4,%sp <== NOT EXECUTED
48b5c: 6004 bras 48b62 <_Thread_Restart+0x7a> <== NOT EXECUTED
_Thread_Restart_self();
return true;
}
return false;
48b5e: 4200 clrb %d0
48b60: 6002 bras 48b64 <_Thread_Restart+0x7c>
_User_extensions_Thread_restart( the_thread );
if ( _Thread_Is_executing ( the_thread ) )
_Thread_Restart_self();
return true;
48b62: 7001 moveq #1,%d0
}
return false;
}
48b64: 246e fffc moveal %fp@(-4),%a2
48b68: 4e5e unlk %fp <== NOT EXECUTED
000485d0 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
485d0: 4e56 0000 linkw %fp,#0
485d4: 206e 0008 moveal %fp@(8),%a0
#if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
485d8: 4a28 00b0 tstb %a0@(176)
485dc: 671c beqs 485fa <_Thread_Stack_Free+0x2a> <== NEVER TAKEN
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
485de: 2279 0005 d1e0 moveal 5d1e0 <Configuration+0x24>,%a1
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
485e4: 2d68 00b6 0008 movel %a0@(182),%fp@(8)
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
485ea: 4a89 tstl %a1
485ec: 6704 beqs 485f2 <_Thread_Stack_Free+0x22>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
485ee: 4e5e unlk %fp
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
485f0: 4ed1 jmp %a1@
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
485f2: 4e5e unlk %fp
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
485f4: 4ef9 0004 8c2c jmp 48c2c <_Workspace_Free>
}
485fa: 4e5e unlk %fp <== NOT EXECUTED
...
000478e0 <_Thread_blocking_operation_Cancel>:
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
478e0: 7202 moveq #2,%d1
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
478e2: 4e56 0000 linkw %fp,#0
478e6: 202e 0010 movel %fp@(16),%d0
478ea: 2f0a movel %a2,%sp@-
478ec: 246e 000c moveal %fp@(12),%a2
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
478f0: 42aa 0044 clrl %a2@(68)
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
478f4: b2aa 0050 cmpl %a2@(80),%d1
478f8: 6618 bnes 47912 <_Thread_blocking_operation_Cancel+0x32>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
478fa: 123c 0003 moveb #3,%d1
478fe: 2541 0050 movel %d1,%a2@(80)
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
47902: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
47904: 486a 0048 pea %a2@(72)
47908: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove>
4790e: 588f addql #4,%sp
47910: 6002 bras 47914 <_Thread_blocking_operation_Cancel+0x34>
} else
_ISR_Enable( level );
47912: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
47914: 2d4a 0008 movel %a2,%fp@(8)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
47918: 246e fffc moveal %fp@(-4),%a2
4791c: 203c 1003 fff8 movel #268697592,%d0
47922: 2d40 000c movel %d0,%fp@(12)
47926: 4e5e unlk %fp
47928: 4ef9 0004 7a0c jmp 47a0c <_Thread_Clear_state>
...
0004cc2c <_Thread_queue_Extract_fifo>:
Thread_Control *the_thread
)
{
ISR_Level level;
_ISR_Disable( level );
4cc2c: 223c 0000 0700 movel #1792,%d1
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4cc32: 4e56 0000 linkw %fp,#0
4cc36: 2f0a movel %a2,%sp@-
4cc38: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
_ISR_Disable( level );
4cc3c: 40c0 movew %sr,%d0
4cc3e: 8280 orl %d0,%d1
4cc40: 46c1 movew %d1,%sr
4cc42: 222a 0010 movel %a2@(16),%d1
4cc46: 0281 0003 bee0 andil #245472,%d1
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4cc4c: 660a bnes 4cc58 <_Thread_queue_Extract_fifo+0x2c>
_ISR_Enable( level );
4cc4e: 46c0 movew %d0,%sr
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
4cc50: 246e fffc moveal %fp@(-4),%a2
4cc54: 4e5e unlk %fp
4cc56: 4e75 rts
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4cc58: 2252 moveal %a2@,%a1
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4cc5a: 7202 moveq #2,%d1
previous = the_node->previous;
4cc5c: 206a 0004 moveal %a2@(4),%a0
next->previous = previous;
4cc60: 2348 0004 movel %a0,%a1@(4)
previous->next = next;
4cc64: 2089 movel %a1,%a0@
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
4cc66: 42aa 0044 clrl %a2@(68)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4cc6a: b2aa 0050 cmpl %a2@(80),%d1
4cc6e: 6704 beqs 4cc74 <_Thread_queue_Extract_fifo+0x48>
_ISR_Enable( level );
4cc70: 46c0 movew %d0,%sr
4cc72: 6014 bras 4cc88 <_Thread_queue_Extract_fifo+0x5c>
4cc74: 7203 moveq #3,%d1
4cc76: 2541 0050 movel %d1,%a2@(80)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4cc7a: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
4cc7c: 486a 0048 pea %a2@(72)
4cc80: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove>
4cc86: 588f addql #4,%sp
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4cc88: 2d4a 0008 movel %a2,%fp@(8)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
4cc8c: 246e fffc moveal %fp@(-4),%a2
4cc90: 203c 1003 fff8 movel #268697592,%d0
4cc96: 2d40 000c movel %d0,%fp@(12)
4cc9a: 4e5e unlk %fp
4cc9c: 4ef9 0004 7a0c jmp 47a0c <_Thread_Clear_state>
...
0004844c <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
4844c: 4e56 fff0 linkw %fp,#-16
48450: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
48454: 246e 0008 moveal %fp@(8),%a2
48458: 266e 000c moveal %fp@(12),%a3
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
4845c: 4a8a tstl %a2
4845e: 6746 beqs 484a6 <_Thread_queue_Requeue+0x5a> <== NEVER TAKEN
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
48460: 7001 moveq #1,%d0
48462: b0aa 0034 cmpl %a2@(52),%d0
48466: 663e bnes 484a6 <_Thread_queue_Requeue+0x5a> <== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
48468: 303c 0700 movew #1792,%d0
4846c: 40c2 movew %sr,%d2
4846e: 8082 orl %d2,%d0
48470: 46c0 movew %d0,%sr
48472: 202b 0010 movel %a3@(16),%d0
48476: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4847c: 6726 beqs 484a4 <_Thread_queue_Requeue+0x58> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
4847e: 7001 moveq #1,%d0
48480: 2540 0030 movel %d0,%a2@(48)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
48484: 4878 0001 pea 1 <ADD>
48488: 2f0b movel %a3,%sp@-
4848a: 2f0a movel %a2,%sp@-
4848c: 4eb9 0004 b434 jsr 4b434 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
48492: 486e fffc pea %fp@(-4)
48496: 2f0b movel %a3,%sp@-
48498: 2f0a movel %a2,%sp@-
4849a: 4eb9 0004 8250 jsr 48250 <_Thread_queue_Enqueue_priority>
484a0: 4fef 0018 lea %sp@(24),%sp
}
_ISR_Enable( level );
484a4: 46c2 movew %d2,%sr
}
}
484a6: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
484ac: 4e5e unlk %fp <== NOT EXECUTED
000484b0 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
484b0: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
484b4: 486e fffc pea %fp@(-4)
484b8: 2f2e 0008 movel %fp@(8),%sp@-
484bc: 4eb9 0004 7da8 jsr 47da8 <_Thread_Get>
switch ( location ) {
484c2: 508f addql #8,%sp
484c4: 4aae fffc tstl %fp@(-4)
484c8: 661e bnes 484e8 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
484ca: 2f00 movel %d0,%sp@-
484cc: 4eb9 0004 b4f8 jsr 4b4f8 <_Thread_queue_Process_timeout>
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
return _Thread_Dispatch_disable_level;
484d2: 588f addql #4,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
484d4: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
484da: 5380 subql #1,%d0
484dc: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
484e2: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
_Thread_Unnest_dispatch();
break;
}
}
484e8: 4e5e unlk %fp <== NOT EXECUTED
000519e0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
519e0: 4e56 ffc0 linkw %fp,#-64
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
519e4: 200e movel %fp,%d0
519e6: 41ee ffec lea %fp@(-20),%a0
519ea: 5180 subql #8,%d0
519ec: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
519f0: 246e 0008 moveal %fp@(8),%a2
519f4: 2e0e movel %fp,%d7
519f6: 260e movel %fp,%d3
519f8: 0687 ffff ffe8 addil #-24,%d7
519fe: 0683 ffff fff4 addil #-12,%d3
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a04: 2a0a movel %a2,%d5
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
51a06: 240a movel %a2,%d2
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a08: 0685 0000 0030 addil #48,%d5
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
51a0e: 0682 0000 0068 addil #104,%d2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51a14: 2c08 movel %a0,%d6
51a16: 2800 movel %d0,%d4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
51a18: 2d48 ffe8 movel %a0,%fp@(-24)
head->previous = NULL;
51a1c: 42ae ffec clrl %fp@(-20)
tail->previous = head;
51a20: 2d47 fff0 movel %d7,%fp@(-16)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
51a24: 2d40 fff4 movel %d0,%fp@(-12)
head->previous = NULL;
51a28: 42ae fff8 clrl %fp@(-8)
tail->previous = head;
51a2c: 2d43 fffc movel %d3,%fp@(-4)
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
51a30: 2547 0078 movel %d7,%a2@(120)
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a34: 47f9 0005 586c lea 5586c <_Watchdog_Adjust_to_chain>,%a3
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
51a3a: 4bf9 0005 57ec lea 557ec <_Watchdog_Adjust>,%a5
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
51a40: 2039 0007 6c3e movel 76c3e <_Watchdog_Ticks_since_boot>,%d0
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
51a46: 222a 003c movel %a2@(60),%d1
watchdogs->last_snapshot = snapshot;
51a4a: 2540 003c movel %d0,%a2@(60)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a4e: 9081 subl %d1,%d0
51a50: 2f03 movel %d3,%sp@-
51a52: 2f00 movel %d0,%sp@-
51a54: 2f05 movel %d5,%sp@-
51a56: 4e93 jsr %a3@
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
51a58: 2879 0007 6bc6 moveal 76bc6 <_TOD_Now>,%a4
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
51a5e: 4fef 000c lea %sp@(12),%sp
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
51a62: 202a 0074 movel %a2@(116),%d0
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
51a66: b08c cmpl %a4,%d0
51a68: 640e bccs 51a78 <_Timer_server_Body+0x98>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a6a: 2f03 movel %d3,%sp@-
51a6c: 220c movel %a4,%d1
51a6e: 9280 subl %d0,%d1
51a70: 2f01 movel %d1,%sp@-
51a72: 2f02 movel %d2,%sp@-
51a74: 4e93 jsr %a3@
51a76: 6010 bras 51a88 <_Timer_server_Body+0xa8>
} else if ( snapshot < last_snapshot ) {
51a78: b08c cmpl %a4,%d0
51a7a: 6310 blss 51a8c <_Timer_server_Body+0xac>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
51a7c: 908c subl %a4,%d0
51a7e: 2f00 movel %d0,%sp@-
51a80: 4878 0001 pea 1 <ADD>
51a84: 2f02 movel %d2,%sp@-
51a86: 4e95 jsr %a5@
51a88: 4fef 000c lea %sp@(12),%sp
}
watchdogs->last_snapshot = snapshot;
51a8c: 254c 0074 movel %a4,%a2@(116)
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51a90: 49f9 0005 58f8 lea 558f8 <_Watchdog_Insert>,%a4
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
51a96: 202a 0078 movel %a2@(120),%d0
51a9a: 2f00 movel %d0,%sp@-
51a9c: 4eb9 0005 24c0 jsr 524c0 <_Chain_Get>
if ( timer == NULL ) {
51aa2: 588f addql #4,%sp
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
51aa4: 2040 moveal %d0,%a0
if ( timer == NULL ) {
51aa6: 4a80 tstl %d0
51aa8: 6724 beqs 51ace <_Timer_server_Body+0xee> <== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51aaa: 2028 0038 movel %a0@(56),%d0 <== NOT EXECUTED
51aae: 7201 moveq #1,%d1 <== NOT EXECUTED
51ab0: b280 cmpl %d0,%d1 <== NOT EXECUTED
51ab2: 6608 bnes 51abc <_Timer_server_Body+0xdc> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
51ab4: 4868 0010 pea %a0@(16) <== NOT EXECUTED
51ab8: 2f05 movel %d5,%sp@- <== NOT EXECUTED
51aba: 600c bras 51ac8 <_Timer_server_Body+0xe8> <== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
51abc: 7203 moveq #3,%d1 <== NOT EXECUTED
51abe: b280 cmpl %d0,%d1 <== NOT EXECUTED
51ac0: 66d4 bnes 51a96 <_Timer_server_Body+0xb6> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51ac2: 4868 0010 pea %a0@(16) <== NOT EXECUTED
51ac6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
51ac8: 4e94 jsr %a4@ <== NOT EXECUTED
51aca: 508f addql #8,%sp <== NOT EXECUTED
51acc: 60c8 bras 51a96 <_Timer_server_Body+0xb6> <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
51ace: 203c 0000 0700 movel #1792,%d0
51ad4: 40c1 movew %sr,%d1
51ad6: 8081 orl %d1,%d0
51ad8: 46c0 movew %d0,%sr
if ( _Chain_Is_empty( insert_chain ) ) {
51ada: bcae ffe8 cmpl %fp@(-24),%d6
51ade: 6612 bnes 51af2 <_Timer_server_Body+0x112> <== NEVER TAKEN
ts->insert_chain = NULL;
51ae0: 42aa 0078 clrl %a2@(120)
_ISR_Enable( level );
51ae4: 46c1 movew %d1,%sr
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
51ae6: 367c 0700 moveaw #1792,%a3
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
51aea: b8ae fff4 cmpl %fp@(-12),%d4
51aee: 6608 bnes 51af8 <_Timer_server_Body+0x118>
51af0: 603e bras 51b30 <_Timer_server_Body+0x150>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
51af2: 46c1 movew %d1,%sr <== NOT EXECUTED
51af4: 6000 ff4a braw 51a40 <_Timer_server_Body+0x60> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
51af8: 200b movel %a3,%d0
51afa: 40c1 movew %sr,%d1
51afc: 8081 orl %d1,%d0
51afe: 46c0 movew %d0,%sr
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51b00: 206e fff4 moveal %fp@(-12),%a0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
51b04: b888 cmpl %a0,%d4
51b06: 6722 beqs 51b2a <_Timer_server_Body+0x14a>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
51b08: 2250 moveal %a0@,%a1
head->next = new_first;
new_first->previous = head;
51b0a: 2343 0004 movel %d3,%a1@(4)
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
51b0e: 42a8 0008 clrl %a0@(8)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
51b12: 2d49 fff4 movel %a1,%fp@(-12)
_ISR_Enable( level );
51b16: 46c1 movew %d1,%sr
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
51b18: 2f28 0024 movel %a0@(36),%sp@-
51b1c: 2f28 0020 movel %a0@(32),%sp@-
51b20: 2068 001c moveal %a0@(28),%a0
51b24: 4e90 jsr %a0@
}
51b26: 508f addql #8,%sp
51b28: 60ce bras 51af8 <_Timer_server_Body+0x118>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
51b2a: 46c1 movew %d1,%sr
51b2c: 6000 ff02 braw 51a30 <_Timer_server_Body+0x50>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
51b30: 47f9 0005 5a1c lea 55a1c <_Watchdog_Remove>,%a3
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
51b36: 4200 clrb %d0
51b38: 1540 007c moveb %d0,%a2@(124)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
51b3c: 4eba fdc2 jsr %pc@(51900 <_Thread_Disable_dispatch>)
_Thread_Set_state( ts->thread, STATES_DELAYING );
51b40: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
51b44: 2f12 movel %a2@,%sp@-
51b46: 4eb9 0005 52bc jsr 552bc <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
51b4c: 2f0a movel %a2,%sp@-
51b4e: 4eba fdcc jsr %pc@(5191c <_Timer_server_Reset_interval_system_watchdog>)
_Timer_server_Reset_tod_system_watchdog( ts );
51b52: 2f0a movel %a2,%sp@-
51b54: 4eba fe26 jsr %pc@(5197c <_Timer_server_Reset_tod_system_watchdog>)
_Thread_Enable_dispatch();
51b58: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
ts->active = true;
51b5e: 7201 moveq #1,%d1
51b60: 1541 007c moveb %d1,%a2@(124)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
51b64: 486a 0008 pea %a2@(8)
51b68: 4e93 jsr %a3@
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
51b6a: 486a 0040 pea %a2@(64)
51b6e: 4e93 jsr %a3@
51b70: 4fef 0018 lea %sp@(24),%sp
51b74: 6000 feba braw 51a30 <_Timer_server_Body+0x50>
00051b78 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
51b78: 4e56 fff0 linkw %fp,#-16
51b7c: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
51b80: 246e 0008 moveal %fp@(8),%a2
51b84: 266e 000c moveal %fp@(12),%a3
if ( ts->insert_chain == NULL ) {
51b88: 202a 0078 movel %a2@(120),%d0
51b8c: 6600 00ea bnew 51c78 <_Timer_server_Schedule_operation_method+0x100>
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
51b90: 4eba fd6e jsr %pc@(51900 <_Thread_Disable_dispatch>)
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51b94: 202b 0038 movel %a3@(56),%d0
51b98: 7201 moveq #1,%d1
51b9a: b280 cmpl %d0,%d1
51b9c: 665c bnes 51bfa <_Timer_server_Schedule_operation_method+0x82>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
51b9e: 203c 0000 0700 movel #1792,%d0
51ba4: 40c2 movew %sr,%d2
51ba6: 8082 orl %d2,%d0
51ba8: 46c0 movew %d0,%sr
snapshot = _Watchdog_Ticks_since_boot;
51baa: 2039 0007 6c3e movel 76c3e <_Watchdog_Ticks_since_boot>,%d0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51bb0: 43ea 0034 lea %a2@(52),%a1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
51bb4: 222a 003c movel %a2@(60),%d1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51bb8: 206a 0030 moveal %a2@(48),%a0
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
51bbc: b3c8 cmpal %a0,%a1
51bbe: 6716 beqs 51bd6 <_Timer_server_Schedule_operation_method+0x5e>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
51bc0: 2240 moveal %d0,%a1
51bc2: 93c1 subal %d1,%a1
delta_interval = first_watchdog->delta_interval;
51bc4: 2228 0010 movel %a0@(16),%d1
if (delta_interval > delta) {
51bc8: b3c1 cmpal %d1,%a1
51bca: 6404 bccs 51bd0 <_Timer_server_Schedule_operation_method+0x58>
delta_interval -= delta;
51bcc: 9289 subl %a1,%d1
51bce: 6002 bras 51bd2 <_Timer_server_Schedule_operation_method+0x5a>
} else {
delta_interval = 0;
51bd0: 4281 clrl %d1
}
first_watchdog->delta_interval = delta_interval;
51bd2: 2141 0010 movel %d1,%a0@(16)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
51bd6: 2540 003c movel %d0,%a2@(60)
_ISR_Enable( level );
51bda: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
51bdc: 486b 0010 pea %a3@(16)
51be0: 486a 0030 pea %a2@(48)
51be4: 4eb9 0005 58f8 jsr 558f8 <_Watchdog_Insert>
if ( !ts->active ) {
51bea: 508f addql #8,%sp
51bec: 102a 007c moveb %a2@(124),%d0
51bf0: 6678 bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_interval_system_watchdog( ts );
51bf2: 2f0a movel %a2,%sp@-
51bf4: 4eba fd26 jsr %pc@(5191c <_Timer_server_Reset_interval_system_watchdog>)
51bf8: 606e bras 51c68 <_Timer_server_Schedule_operation_method+0xf0>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
51bfa: 7203 moveq #3,%d1
51bfc: b280 cmpl %d0,%d1
51bfe: 666a bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
51c00: 203c 0000 0700 movel #1792,%d0
51c06: 40c2 movew %sr,%d2
51c08: 8082 orl %d2,%d0
51c0a: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51c0c: 200a movel %a2,%d0
51c0e: 0680 0000 006c addil #108,%d0
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
51c14: 2239 0007 6bc6 movel 76bc6 <_TOD_Now>,%d1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
51c1a: 226a 0074 moveal %a2@(116),%a1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51c1e: 206a 0068 moveal %a2@(104),%a0
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
51c22: b088 cmpl %a0,%d0
51c24: 6720 beqs 51c46 <_Timer_server_Schedule_operation_method+0xce>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
51c26: 2028 0010 movel %a0@(16),%d0
if ( snapshot > last_snapshot ) {
51c2a: b3c1 cmpal %d1,%a1
51c2c: 640c bccs 51c3a <_Timer_server_Schedule_operation_method+0xc2>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
51c2e: 2841 moveal %d1,%a4
51c30: 99c9 subal %a1,%a4
if (delta_interval > delta) {
51c32: b9c0 cmpal %d0,%a4
51c34: 640a bccs 51c40 <_Timer_server_Schedule_operation_method+0xc8><== NEVER TAKEN
delta_interval -= delta;
51c36: 908c subl %a4,%d0
51c38: 6008 bras 51c42 <_Timer_server_Schedule_operation_method+0xca>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
51c3a: d089 addl %a1,%d0
delta_interval += delta;
51c3c: 9081 subl %d1,%d0
51c3e: 6002 bras 51c42 <_Timer_server_Schedule_operation_method+0xca>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
51c40: 4280 clrl %d0 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
51c42: 2140 0010 movel %d0,%a0@(16)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
51c46: 2541 0074 movel %d1,%a2@(116)
_ISR_Enable( level );
51c4a: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51c4c: 486b 0010 pea %a3@(16)
51c50: 486a 0068 pea %a2@(104)
51c54: 4eb9 0005 58f8 jsr 558f8 <_Watchdog_Insert>
if ( !ts->active ) {
51c5a: 508f addql #8,%sp
51c5c: 102a 007c moveb %a2@(124),%d0
51c60: 6608 bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_tod_system_watchdog( ts );
51c62: 2f0a movel %a2,%sp@-
51c64: 4eba fd16 jsr %pc@(5197c <_Timer_server_Reset_tod_system_watchdog>)
51c68: 588f addql #4,%sp
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
51c6a: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
51c70: 4e5e unlk %fp
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
51c72: 4ef9 0005 4ab4 jmp 54ab4 <_Thread_Enable_dispatch>
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
51c78: 202a 0078 movel %a2@(120),%d0 <== NOT EXECUTED
51c7c: 2d4b 000c movel %a3,%fp@(12) <== NOT EXECUTED
}
}
51c80: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
51c86: 2d40 0008 movel %d0,%fp@(8) <== NOT EXECUTED
}
}
51c8a: 4e5e unlk %fp <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
51c8c: 4ef9 0005 2460 jmp 52460 <_Chain_Append> <== NOT EXECUTED
00048724 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
48724: 4e56 ffe8 linkw %fp,#-24
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48728: 203c 0005 ece4 movel #388324,%d0
4872e: 23c0 0005 ece0 movel %d0,5ece0 <_User_extensions_List>
head->previous = NULL;
tail->previous = head;
48734: 203c 0005 ece0 movel #388320,%d0
4873a: 23c0 0005 ece8 movel %d0,5ece8 <_User_extensions_List+0x8>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48740: 203c 0005 eba0 movel #388000,%d0
48746: 23c0 0005 eb9c movel %d0,5eb9c <_User_extensions_Switches_list>
head->previous = NULL;
tail->previous = head;
4874c: 203c 0005 eb9c movel #387996,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
48752: 42b9 0005 ece4 clrl 5ece4 <_User_extensions_List+0x4>
48758: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
User_extensions_Control *extension;
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
4875c: 2839 0005 d1f2 movel 5d1f2 <Configuration+0x36>,%d4
initial_extensions = Configuration.User_extension_table;
48762: 2639 0005 d1f6 movel 5d1f6 <Configuration+0x3a>,%d3
48768: 42b9 0005 eba0 clrl 5eba0 <_User_extensions_Switches_list+0x4>
tail->previous = head;
4876e: 23c0 0005 eba4 movel %d0,5eba4 <_User_extensions_Switches_list+0x8>
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
48774: 4a83 tstl %d3
48776: 6754 beqs 487cc <_User_extensions_Handler_initialization+0xa8><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
48778: 7434 moveq #52,%d2
4877a: 4c04 2800 mulsl %d4,%d2
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
4877e: 49f9 0004 d588 lea 4d588 <memcpy>,%a4
_User_extensions_Add_set( extension );
48784: 47f9 0004 b5c0 lea 4b5c0 <_User_extensions_Add_set>,%a3
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
4878a: 2f02 movel %d2,%sp@-
4878c: 4eb9 0004 8c46 jsr 48c46 <_Workspace_Allocate_or_fatal_error>
48792: 2440 moveal %d0,%a2
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
48794: 2f02 movel %d2,%sp@-
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
48796: 4282 clrl %d2
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
48798: 42a7 clrl %sp@-
4879a: 2f00 movel %d0,%sp@-
4879c: 4eb9 0004 d5f8 jsr 4d5f8 <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
487a2: 4fef 0010 lea %sp@(16),%sp
487a6: 6020 bras 487c8 <_User_extensions_Handler_initialization+0xa4>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
487a8: 4878 0020 pea 20 <OPER2+0xc>
487ac: 5282 addql #1,%d2
487ae: 2f03 movel %d3,%sp@-
487b0: 486a 0014 pea %a2@(20)
487b4: 0683 0000 0020 addil #32,%d3
487ba: 4e94 jsr %a4@
_User_extensions_Add_set( extension );
487bc: 2f0a movel %a2,%sp@-
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
487be: 45ea 0034 lea %a2@(52),%a2
487c2: 4e93 jsr %a3@
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
487c4: 4fef 0010 lea %sp@(16),%sp
487c8: b882 cmpl %d2,%d4
487ca: 66dc bnes 487a8 <_User_extensions_Handler_initialization+0x84>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
487cc: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
487d2: 4e5e unlk %fp
...
00049c60 <_Watchdog_Adjust>:
Watchdog_Interval units
)
{
ISR_Level level;
_ISR_Disable( level );
49c60: 327c 0700 moveaw #1792,%a1
49c64: 2209 movel %a1,%d1
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
49c66: 4e56 ffec linkw %fp,#-20
49c6a: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@
49c6e: 266e 0008 moveal %fp@(8),%a3
49c72: 262e 000c movel %fp@(12),%d3
49c76: 242e 0010 movel %fp@(16),%d2
ISR_Level level;
_ISR_Disable( level );
49c7a: 40c0 movew %sr,%d0
49c7c: 8280 orl %d0,%d1
49c7e: 46c1 movew %d1,%sr
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
49c80: 244b moveal %a3,%a2
49c82: 205a moveal %a2@+,%a0
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
49c84: b5c8 cmpal %a0,%a2
49c86: 674c beqs 49cd4 <_Watchdog_Adjust+0x74>
switch ( direction ) {
49c88: 4a83 tstl %d3
49c8a: 673c beqs 49cc8 <_Watchdog_Adjust+0x68>
49c8c: 7201 moveq #1,%d1
49c8e: b283 cmpl %d3,%d1
49c90: 6642 bnes 49cd4 <_Watchdog_Adjust+0x74> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
49c92: d5a8 0010 addl %d2,%a0@(16)
break;
49c96: 603c bras 49cd4 <_Watchdog_Adjust+0x74>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
49c98: 2053 moveal %a3@,%a0
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
49c9a: 2228 0010 movel %a0@(16),%d1
49c9e: b282 cmpl %d2,%d1
49ca0: 6308 blss 49caa <_Watchdog_Adjust+0x4a>
_Watchdog_First( header )->delta_interval -= units;
49ca2: 9282 subl %d2,%d1
49ca4: 2141 0010 movel %d1,%a0@(16)
break;
49ca8: 602a bras 49cd4 <_Watchdog_Adjust+0x74>
} else {
units -= _Watchdog_First( header )->delta_interval;
49caa: 9481 subl %d1,%d2
_Watchdog_First( header )->delta_interval = 1;
49cac: 7201 moveq #1,%d1
49cae: 2141 0010 movel %d1,%a0@(16)
_ISR_Enable( level );
49cb2: 46c0 movew %d0,%sr
_Watchdog_Tickle( header );
49cb4: 2f0b movel %a3,%sp@-
49cb6: 4e94 jsr %a4@
_ISR_Disable( level );
49cb8: 2203 movel %d3,%d1
49cba: 40c0 movew %sr,%d0
49cbc: 8280 orl %d0,%d1
49cbe: 46c1 movew %d1,%sr
if ( _Chain_Is_empty( header ) )
49cc0: 588f addql #4,%sp
49cc2: b5d3 cmpal %a3@,%a2
49cc4: 660a bnes 49cd0 <_Watchdog_Adjust+0x70>
49cc6: 600c bras 49cd4 <_Watchdog_Adjust+0x74>
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
_Watchdog_Tickle( header );
49cc8: 49f9 0004 9e80 lea 49e80 <_Watchdog_Tickle>,%a4
_ISR_Disable( level );
49cce: 2609 movel %a1,%d3
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
49cd0: 4a82 tstl %d2
49cd2: 66c4 bnes 49c98 <_Watchdog_Adjust+0x38> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
49cd4: 46c0 movew %d0,%sr
}
49cd6: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
49cdc: 4e5e unlk %fp <== NOT EXECUTED
00048ab8 <_Watchdog_Remove>:
{
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
48ab8: 203c 0000 0700 movel #1792,%d0
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
48abe: 4e56 0000 linkw %fp,#0
48ac2: 206e 0008 moveal %fp@(8),%a0
48ac6: 2f0a movel %a2,%sp@-
48ac8: 2f02 movel %d2,%sp@-
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
48aca: 40c1 movew %sr,%d1
48acc: 8081 orl %d1,%d0
48ace: 46c0 movew %d0,%sr
previous_state = the_watchdog->state;
48ad0: 2028 0008 movel %a0@(8),%d0
switch ( previous_state ) {
48ad4: 7401 moveq #1,%d2
48ad6: b480 cmpl %d0,%d2
48ad8: 670c beqs 48ae6 <_Watchdog_Remove+0x2e>
48ada: 6242 bhis 48b1e <_Watchdog_Remove+0x66>
48adc: 143c 0003 moveb #3,%d2
48ae0: b480 cmpl %d0,%d2
48ae2: 653a bcss 48b1e <_Watchdog_Remove+0x66> <== NEVER TAKEN
48ae4: 6006 bras 48aec <_Watchdog_Remove+0x34>
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
48ae6: 42a8 0008 clrl %a0@(8)
break;
48aea: 6032 bras 48b1e <_Watchdog_Remove+0x66>
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
48aec: 2250 moveal %a0@,%a1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
48aee: 42a8 0008 clrl %a0@(8)
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
48af2: 4a91 tstl %a1@
48af4: 6708 beqs 48afe <_Watchdog_Remove+0x46>
next_watchdog->delta_interval += the_watchdog->delta_interval;
48af6: 2428 0010 movel %a0@(16),%d2
48afa: d5a9 0010 addl %d2,%a1@(16)
if ( _Watchdog_Sync_count )
48afe: 2479 0005 ec96 moveal 5ec96 <_Watchdog_Sync_count>,%a2
48b04: 4a8a tstl %a2
48b06: 670c beqs 48b14 <_Watchdog_Remove+0x5c>
_Watchdog_Sync_level = _ISR_Nest_level;
48b08: 45f9 0005 eff6 lea 5eff6 <_Per_CPU_Information+0x8>,%a2
48b0e: 23d2 0005 ec3c movel %a2@,5ec3c <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
48b14: 2468 0004 moveal %a0@(4),%a2
next->previous = previous;
48b18: 234a 0004 movel %a2,%a1@(4)
previous->next = next;
48b1c: 2489 movel %a1,%a2@
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
48b1e: 2279 0005 ec9a moveal 5ec9a <_Watchdog_Ticks_since_boot>,%a1
48b24: 2149 0018 movel %a1,%a0@(24)
_ISR_Enable( level );
48b28: 46c1 movew %d1,%sr
return( previous_state );
}
48b2a: 241f movel %sp@+,%d2
48b2c: 245f moveal %sp@+,%a2
48b2e: 4e5e unlk %fp
...
0005a794 <_calloc_r>:
void *_calloc_r(
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
5a794: 4e56 0000 linkw %fp,#0
5a798: 202e 000c movel %fp@(12),%d0
return calloc( elements, size );
5a79c: 2d6e 0010 000c movel %fp@(16),%fp@(12)
5a7a2: 2d40 0008 movel %d0,%fp@(8)
}
5a7a6: 4e5e unlk %fp
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
return calloc( elements, size );
5a7a8: 4ef9 0004 27cc jmp 427cc <calloc>
...
00049d48 <_close_r>:
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
49d48: 4e56 0000 linkw %fp,#0
return close( fd );
49d4c: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
49d52: 4e5e unlk %fp
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return close( fd );
49d54: 4ef9 0004 9cd8 jmp 49cd8 <close>
...
00043334 <_exit>:
extern void FINI_SYMBOL( void );
#endif
void EXIT_SYMBOL(int status)
{
43334: 4e56 0000 linkw %fp,#0
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(FINI_SYMBOL)
FINI_SYMBOL();
43338: 4eb9 0005 b2bc jsr 5b2bc <_fini>
* We need to do the exit processing on the global reentrancy structure.
* This has already been done on the per task reentrancy structure
* associated with this task.
*/
libc_wrapup();
4333e: 4eb9 0004 32d0 jsr 432d0 <libc_wrapup>
rtems_shutdown_executive(status);
43344: 2f2e 0008 movel %fp@(8),%sp@-
43348: 4eb9 0004 6030 jsr 46030 <rtems_shutdown_executive>
...
000508b2 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
508b2: 4e56 ffd4 linkw %fp,#-44
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
508b6: 206e 0008 moveal %fp@(8),%a0
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
508ba: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
508be: 244e moveal %fp,%a2
void *buff
)
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
508c0: 4283 clrl %d3
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
508c2: 4bf9 0005 05a0 lea 505a0 <fat_buf_access>,%a5
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
508c8: 49f9 0005 950c lea 5950c <memcpy>,%a4
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
508ce: 282e 0014 movel %fp@(20),%d4
508d2: 2e2e 0018 movel %fp@(24),%d7
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
508d6: 2668 0034 moveal %a0@(52),%a3
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
508da: 42a2 clrl %a2@-
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
508dc: 2c2e 0010 movel %fp@(16),%d6
)
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
508e0: 2a2e 000c movel %fp@(12),%d5
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
508e4: 6040 bras 50926 <_fat_block_read+0x74>
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
508e6: 2f0a movel %a2,%sp@-
508e8: 4878 0001 pea 1 <ADD>
508ec: 2f05 movel %d5,%sp@-
508ee: 2f0b movel %a3,%sp@-
508f0: 4e95 jsr %a5@
if (rc != RC_OK)
508f2: 4fef 0010 lea %sp@(16),%sp
508f6: 4a80 tstl %d0
508f8: 6632 bnes 5092c <_fat_block_read+0x7a> <== NEVER TAKEN
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
508fa: 4282 clrl %d2
508fc: 3413 movew %a3@,%d2
508fe: 9486 subl %d6,%d2
50900: b882 cmpl %d2,%d4
50902: 6402 bccs 50906 <_fat_block_read+0x54>
50904: 2404 movel %d4,%d2
memcpy((buff + cmpltd), (block->buffer + ofs), c);
50906: 206e fffc moveal %fp@(-4),%a0
count -= c;
5090a: 9882 subl %d2,%d4
cmpltd += c;
blk++;
5090c: 5285 addql #1,%d5
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
5090e: 2f02 movel %d2,%sp@-
50910: dca8 001e addl %a0@(30),%d6
50914: 2047 moveal %d7,%a0
50916: 2f06 movel %d6,%sp@-
50918: 4870 3800 pea %a0@(00000000,%d3:l)
count -= c;
cmpltd += c;
blk++;
ofs = 0;
5091c: 4286 clrl %d6
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
count -= c;
cmpltd += c;
5091e: d682 addl %d2,%d3
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
50920: 4e94 jsr %a4@
count -= c;
cmpltd += c;
blk++;
ofs = 0;
50922: 4fef 000c lea %sp@(12),%sp
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
50926: 4a84 tstl %d4
50928: 66bc bnes 508e6 <_fat_block_read+0x34>
5092a: 6002 bras 5092e <_fat_block_read+0x7c>
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
5092c: 76ff moveq #-1,%d3 <== NOT EXECUTED
cmpltd += c;
blk++;
ofs = 0;
}
return cmpltd;
}
5092e: 2003 movel %d3,%d0
50930: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
50936: 4e5e unlk %fp <== NOT EXECUTED
000509d6 <_fat_block_release>:
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
509d6: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
509da: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
509de: 2d68 0034 0008 movel %a0@(52),%fp@(8) <== NOT EXECUTED
}
509e4: 4e5e unlk %fp <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
509e6: 4ef9 0005 0780 jmp 50780 <fat_buf_release> <== NOT EXECUTED
0005093a <_fat_block_write>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
5093a: 4e56 ffd4 linkw %fp,#-44
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
5093e: 206e 0008 moveal %fp@(8),%a0
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
50942: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
50946: 244e moveal %fp,%a2
uint32_t count,
const void *buff)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
50948: 4283 clrl %d3
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
5094a: 49f9 0005 05a0 lea 505a0 <fat_buf_access>,%a4
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
50950: 4bf9 0005 950c lea 5950c <memcpy>,%a5
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
50956: 282e 0014 movel %fp@(20),%d4
5095a: 2e2e 0018 movel %fp@(24),%d7
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
5095e: 2668 0034 moveal %a0@(52),%a3
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
50962: 42a2 clrl %a2@-
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
50964: 2c2e 0010 movel %fp@(16),%d6
const void *buff)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
50968: 2a2e 000c movel %fp@(12),%d5
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
5096c: 6054 bras 509c2 <_fat_block_write+0x88>
{
c = MIN(count, (fs_info->vol.bps - ofs));
5096e: 4280 clrl %d0
50970: 3013 movew %a3@,%d0
50972: 2400 movel %d0,%d2
50974: 9486 subl %d6,%d2
50976: b882 cmpl %d2,%d4
50978: 6402 bccs 5097c <_fat_block_write+0x42>
5097a: 2404 movel %d4,%d2
if (c == fs_info->vol.bps)
5097c: b082 cmpl %d2,%d0
5097e: 6608 bnes 50988 <_fat_block_write+0x4e>
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
50980: 2f0a movel %a2,%sp@-
50982: 4878 0002 pea 2 <DOUBLE_FLOAT>
50986: 6006 bras 5098e <_fat_block_write+0x54>
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
50988: 2f0a movel %a2,%sp@-
5098a: 4878 0001 pea 1 <ADD>
5098e: 2f05 movel %d5,%sp@-
50990: 2f0b movel %a3,%sp@-
50992: 4e94 jsr %a4@
50994: 4fef 0010 lea %sp@(16),%sp
if (rc != RC_OK)
50998: 4a80 tstl %d0
5099a: 662c bnes 509c8 <_fat_block_write+0x8e> <== NEVER TAKEN
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
5099c: 2f02 movel %d2,%sp@-
5099e: 2047 moveal %d7,%a0
509a0: 4870 3800 pea %a0@(00000000,%d3:l)
fat_buf_mark_modified(fs_info);
count -= c;
509a4: 9882 subl %d2,%d4
cmpltd +=c;
509a6: d682 addl %d2,%d3
blk++;
509a8: 5285 addql #1,%d5
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
509aa: 206e fffc moveal %fp@(-4),%a0
509ae: dca8 001e addl %a0@(30),%d6
509b2: 2f06 movel %d6,%sp@-
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
ofs = 0;
509b4: 4286 clrl %d6
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
509b6: 4e95 jsr %a5@
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
ofs = 0;
509b8: 4fef 000c lea %sp@(12),%sp
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
509bc: 7001 moveq #1,%d0
509be: 1740 0076 moveb %d0,%a3@(118)
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
509c2: 4a84 tstl %d4
509c4: 66a8 bnes 5096e <_fat_block_write+0x34>
509c6: 6002 bras 509ca <_fat_block_write+0x90>
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
509c8: 76ff moveq #-1,%d3 <== NOT EXECUTED
cmpltd +=c;
blk++;
ofs = 0;
}
return cmpltd;
}
509ca: 2003 movel %d3,%d0
509cc: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
509d2: 4e5e unlk %fp <== NOT EXECUTED
0005bdf0 <_fcntl_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
int cmd,
int arg
)
{
5bdf0: 4e56 0000 linkw %fp,#0
5bdf4: 222e 0010 movel %fp@(16),%d1
5bdf8: 202e 000c movel %fp@(12),%d0
return fcntl( fd, cmd, arg );
5bdfc: 2d6e 0014 0010 movel %fp@(20),%fp@(16)
5be02: 2d41 000c movel %d1,%fp@(12)
5be06: 2d40 0008 movel %d0,%fp@(8)
}
5be0a: 4e5e unlk %fp
int fd,
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
5be0c: 4ef9 0005 bc88 jmp 5bc88 <fcntl>
...
0005a7b0 <_free_r>:
void _free_r(
struct _reent *ignored __attribute__((unused)),
void *ptr
)
{
5a7b0: 4e56 0000 linkw %fp,#0
free( ptr );
5a7b4: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
5a7ba: 4e5e unlk %fp
void _free_r(
struct _reent *ignored __attribute__((unused)),
void *ptr
)
{
free( ptr );
5a7bc: 4ef9 0004 2b68 jmp 42b68 <free>
...
0004fab6 <_hash_search>:
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
4fab6: 7001 moveq #1,%d0
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
4fab8: 4e56 ffe8 linkw %fp,#-24
4fabc: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
4fac0: 242e 0010 movel %fp@(16),%d2
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
4fac4: 49fa ff9e lea %pc@(4fa64 <fat_construct_key>),%a4
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
4fac8: c082 andl %d2,%d0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4faca: 266e 000c moveal %fp@(12),%a3
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4face: 2200 movel %d0,%d1
4fad0: e988 lsll #4,%d0
4fad2: e589 lsll #2,%d1
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
4fad4: 282e 0008 movel %fp@(8),%d4
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4fad8: 9081 subl %d1,%d0
4fada: d7c0 addal %d0,%a3
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
4fadc: 262e 0014 movel %fp@(20),%d3
4fae0: 245b moveal %a3@+,%a2
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4fae2: 6024 bras 4fb08 <_hash_search+0x52>
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
4fae4: 486a 0020 pea %a2@(32)
4fae8: 2f04 movel %d4,%sp@-
4faea: 4e94 jsr %a4@
4faec: 508f addql #8,%sp
if ( (key1) == ck)
4faee: b082 cmpl %d2,%d0
4faf0: 6614 bnes 4fb06 <_hash_search+0x50>
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
4faf2: 4a83 tstl %d3
4faf4: 6706 beqs 4fafc <_hash_search+0x46> <== ALWAYS TAKEN
4faf6: b6aa 000c cmpl %a2@(12),%d3 <== NOT EXECUTED
4fafa: 660a bnes 4fb06 <_hash_search+0x50> <== NOT EXECUTED
{
*ret = (void *)the_node;
4fafc: 206e 0018 moveal %fp@(24),%a0
return 0;
4fb00: 4280 clrl %d0
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
{
*ret = (void *)the_node;
4fb02: 208a movel %a2,%a0@
return 0;
4fb04: 6008 bras 4fb0e <_hash_search+0x58>
}
}
the_node = the_node->next;
4fb06: 2452 moveal %a2@,%a2
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4fb08: b7ca cmpal %a2,%a3
4fb0a: 66d8 bnes 4fae4 <_hash_search+0x2e>
return 0;
}
}
the_node = the_node->next;
}
return -1;
4fb0c: 70ff moveq #-1,%d0
}
4fb0e: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
4fb14: 4e5e unlk %fp <== NOT EXECUTED
0005a884 <_isatty_r>:
int _isatty_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
5a884: 4e56 0000 linkw %fp,#0
return isatty( fd );
5a888: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
5a88e: 4e5e unlk %fp
int _isatty_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return isatty( fd );
5a890: 4ef9 0005 b214 jmp 5b214 <isatty>
...
0005a964 <_lseek_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
off_t offset,
int whence
)
{
5a964: 4e56 0000 linkw %fp,#0
5a968: 206e 000c moveal %fp@(12),%a0
5a96c: 202e 0010 movel %fp@(16),%d0
5a970: 222e 0014 movel %fp@(20),%d1
return lseek( fd, offset, whence );
5a974: 2d6e 0018 0014 movel %fp@(24),%fp@(20)
5a97a: 2d40 000c movel %d0,%fp@(12)
5a97e: 2d41 0010 movel %d1,%fp@(16)
5a982: 2d48 0008 movel %a0,%fp@(8)
}
5a986: 4e5e unlk %fp
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
5a988: 4ef9 0005 a898 jmp 5a898 <lseek>
...
0005a990 <_malloc_r>:
void *_malloc_r(
struct _reent *ignored __attribute__((unused)),
size_t size
)
{
5a990: 4e56 0000 linkw %fp,#0
return malloc( size );
5a994: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
5a99a: 4e5e unlk %fp
void *_malloc_r(
struct _reent *ignored __attribute__((unused)),
size_t size
)
{
return malloc( size );
5a99c: 4ef9 0004 2e54 jmp 42e54 <malloc>
...
0005aa40 <_read_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
void *buf,
size_t nbytes
)
{
5aa40: 4e56 0000 linkw %fp,#0
5aa44: 222e 0010 movel %fp@(16),%d1
5aa48: 202e 000c movel %fp@(12),%d0
return read( fd, buf, nbytes );
5aa4c: 2d6e 0014 0010 movel %fp@(20),%fp@(16)
5aa52: 2d41 000c movel %d1,%fp@(12)
5aa56: 2d40 0008 movel %d0,%fp@(8)
}
5aa5a: 4e5e unlk %fp
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
5aa5c: 4ef9 0005 a9a4 jmp 5a9a4 <read>
...
0005aa64 <_realloc_r>:
void *_realloc_r(
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
5aa64: 4e56 0000 linkw %fp,#0
5aa68: 202e 000c movel %fp@(12),%d0
return realloc( ptr, size );
5aa6c: 2d6e 0010 000c movel %fp@(16),%fp@(12)
5aa72: 2d40 0008 movel %d0,%fp@(8)
}
5aa76: 4e5e unlk %fp
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
5aa78: 4ef9 0005 aac4 jmp 5aac4 <realloc>
...
00043514 <_stat_r>:
int _STAT_R_NAME(
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
43514: 4e56 0000 linkw %fp,#0
43518: 202e 000c movel %fp@(12),%d0
return _STAT_NAME( path, buf );
4351c: 2d6e 0010 000c movel %fp@(16),%fp@(12)
43522: 2d40 0008 movel %d0,%fp@(8)
}
43526: 4e5e unlk %fp
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
43528: 4ef9 0004 348c jmp 4348c <stat>
...
000451d4 <_times_r>:
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
451d4: 4e56 0000 linkw %fp,#0
return _times( ptms );
451d8: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
451de: 4e5e unlk %fp
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
return _times( ptms );
451e0: 4ef9 0004 5130 jmp 45130 <_times>
...
0005aa80 <_write_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
const void *buf,
size_t nbytes
)
{
5aa80: 4e56 0000 linkw %fp,#0
5aa84: 222e 0010 movel %fp@(16),%d1
5aa88: 202e 000c movel %fp@(12),%d0
return write( fd, buf, nbytes );
5aa8c: 2d6e 0014 0010 movel %fp@(20),%fp@(16)
5aa92: 2d41 000c movel %d1,%fp@(12)
5aa96: 2d40 0008 movel %d0,%fp@(8)
}
5aa9a: 4e5e unlk %fp
int fd,
const void *buf,
size_t nbytes
)
{
return write( fd, buf, nbytes );
5aa9c: 4ef9 0005 aba8 jmp 5aba8 <write>
...
00045f10 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
45f10: 4e56 ffe8 linkw %fp,#-24
45f14: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
45f18: 4879 0006 12c8 pea 612c8 <aio_request_queue>
45f1e: 49f9 0004 6fe0 lea 46fe0 <pthread_mutex_lock>,%a4
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
45f24: 242e 0008 movel %fp@(8),%d2
45f28: 246e 000c moveal %fp@(12),%a2
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
45f2c: 4e94 jsr %a4@
if (fcntl (fildes, F_GETFD) < 0) {
45f2e: 4878 0001 pea 1 <ADD>
45f32: 2f02 movel %d2,%sp@-
45f34: 4eb9 0004 c41c jsr 4c41c <fcntl>
45f3a: 4fef 000c lea %sp@(12),%sp
45f3e: 4a80 tstl %d0
45f40: 6c1c bges 45f5e <aio_cancel+0x4e>
pthread_mutex_unlock(&aio_request_queue.mutex);
45f42: 4879 0006 12c8 pea 612c8 <aio_request_queue>
45f48: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
45f4e: 4eb9 0004 f1bc jsr 4f1bc <__errno>
45f54: 7209 moveq #9,%d1
45f56: 2040 moveal %d0,%a0
45f58: 2081 movel %d1,%a0@
45f5a: 6000 00f6 braw 46052 <aio_cancel+0x142>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
45f5e: 4a8a tstl %a2
45f60: 6600 00d2 bnew 46034 <aio_cancel+0x124>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
45f64: 42a7 clrl %sp@-
45f66: 47f9 0004 62ba lea 462ba <rtems_aio_search_fd>,%a3
45f6c: 2f02 movel %d2,%sp@-
45f6e: 4879 0006 1310 pea 61310 <aio_request_queue+0x48>
45f74: 4e93 jsr %a3@
if (r_chain == NULL) {
45f76: 4fef 000c lea %sp@(12),%sp
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
45f7a: 2440 moveal %d0,%a2
if (r_chain == NULL) {
45f7c: 4a80 tstl %d0
45f7e: 667c bnes 45ffc <aio_cancel+0xec>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
45f80: 203c 0006 1320 movel #398112,%d0
45f86: b0b9 0006 131c cmpl 6131c <aio_request_queue+0x54>,%d0
45f8c: 6700 012c beqw 460ba <aio_cancel+0x1aa>
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
45f90: 42a7 clrl %sp@-
45f92: 2f02 movel %d2,%sp@-
45f94: 4879 0006 131c pea 6131c <aio_request_queue+0x54>
45f9a: 4e93 jsr %a3@
if (r_chain == NULL) {
45f9c: 4fef 000c lea %sp@(12),%sp
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
45fa0: 2400 movel %d0,%d2
if (r_chain == NULL) {
45fa2: 6616 bnes 45fba <aio_cancel+0xaa>
pthread_mutex_unlock(&aio_request_queue.mutex);
45fa4: 4879 0006 12c8 pea 612c8 <aio_request_queue>
return AIO_ALLDONE;
45faa: 143c 0002 moveb #2,%d2
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
45fae: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return AIO_ALLDONE;
45fb4: 588f addql #4,%sp
45fb6: 6000 0144 braw 460fc <aio_cancel+0x1ec>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
45fba: 2f00 movel %d0,%sp@-
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
45fbc: 2602 movel %d2,%d3
45fbe: 0683 0000 001c addil #28,%d3
45fc4: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
45fca: 2f02 movel %d2,%sp@-
45fcc: 4eb9 0004 660c jsr 4660c <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
45fd2: 2f03 movel %d3,%sp@-
45fd4: 4eb9 0004 6da8 jsr 46da8 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
45fda: 2f03 movel %d3,%sp@-
45fdc: 4eb9 0004 6a94 jsr 46a94 <pthread_cond_destroy>
free (r_chain);
45fe2: 2f02 movel %d2,%sp@-
45fe4: 4eb9 0004 33b4 jsr 433b4 <free>
pthread_mutex_unlock (&aio_request_queue.mutex);
45fea: 4879 0006 12c8 pea 612c8 <aio_request_queue>
45ff0: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return AIO_CANCELED;
45ff6: 4fef 0018 lea %sp@(24),%sp
45ffa: 6032 bras 4602e <aio_cancel+0x11e>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
45ffc: 2400 movel %d0,%d2
45ffe: 0682 0000 001c addil #28,%d2
46004: 2f02 movel %d2,%sp@-
46006: 4e94 jsr %a4@
46008: 2f0a movel %a2,%sp@-
4600a: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
46010: 2f0a movel %a2,%sp@-
pthread_mutex_unlock (&r_chain->mutex);
46012: 45f9 0004 7078 lea 47078 <pthread_mutex_unlock>,%a2
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
46018: 4eb9 0004 660c jsr 4660c <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
4601e: 2f02 movel %d2,%sp@-
46020: 4e92 jsr %a2@
pthread_mutex_unlock (&aio_request_queue.mutex);
46022: 4879 0006 12c8 pea 612c8 <aio_request_queue>
46028: 4e92 jsr %a2@
return AIO_CANCELED;
4602a: 4fef 0014 lea %sp@(20),%sp
4602e: 4282 clrl %d2
46030: 6000 00ca braw 460fc <aio_cancel+0x1ec>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
46034: 2612 movel %a2@,%d3
46036: b483 cmpl %d3,%d2
46038: 6720 beqs 4605a <aio_cancel+0x14a>
pthread_mutex_unlock (&aio_request_queue.mutex);
4603a: 4879 0006 12c8 pea 612c8 <aio_request_queue>
46040: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
46046: 4eb9 0004 f1bc jsr 4f1bc <__errno>
4604c: 2040 moveal %d0,%a0
4604e: 7016 moveq #22,%d0
46050: 2080 movel %d0,%a0@
46052: 588f addql #4,%sp
46054: 74ff moveq #-1,%d2
46056: 6000 00a4 braw 460fc <aio_cancel+0x1ec>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
4605a: 42a7 clrl %sp@-
4605c: 4bf9 0004 62ba lea 462ba <rtems_aio_search_fd>,%a5
46062: 2f03 movel %d3,%sp@-
46064: 4879 0006 1310 pea 61310 <aio_request_queue+0x48>
4606a: 4e95 jsr %a5@
if (r_chain == NULL) {
4606c: 4fef 000c lea %sp@(12),%sp
if (aiocbp->aio_fildes != fildes) {
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
46070: 2640 moveal %d0,%a3
if (r_chain == NULL) {
46072: 4a80 tstl %d0
46074: 6656 bnes 460cc <aio_cancel+0x1bc>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
46076: 203c 0006 1320 movel #398112,%d0
4607c: b0b9 0006 131c cmpl 6131c <aio_request_queue+0x54>,%d0
46082: 6736 beqs 460ba <aio_cancel+0x1aa> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
46084: 42a7 clrl %sp@-
46086: 2f03 movel %d3,%sp@-
46088: 4879 0006 131c pea 6131c <aio_request_queue+0x54>
4608e: 4e95 jsr %a5@
if (r_chain == NULL) {
46090: 4fef 000c lea %sp@(12),%sp
46094: 4a80 tstl %d0
46096: 67a2 beqs 4603a <aio_cancel+0x12a>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
46098: 2f0a movel %a2,%sp@-
4609a: 2040 moveal %d0,%a0
4609c: 4868 0008 pea %a0@(8)
460a0: 4eb9 0004 6662 jsr 46662 <rtems_aio_remove_req>
pthread_mutex_unlock (&aio_request_queue.mutex);
460a6: 4879 0006 12c8 pea 612c8 <aio_request_queue>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
460ac: 2400 movel %d0,%d2
pthread_mutex_unlock (&aio_request_queue.mutex);
460ae: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return result;
460b4: 4fef 000c lea %sp@(12),%sp
460b8: 6042 bras 460fc <aio_cancel+0x1ec>
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
460ba: 4879 0006 12c8 pea 612c8 <aio_request_queue> <== NOT EXECUTED
return AIO_ALLDONE;
460c0: 7402 moveq #2,%d2 <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
460c2: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
460c8: 588f addql #4,%sp <== NOT EXECUTED
460ca: 6030 bras 460fc <aio_cancel+0x1ec> <== NOT EXECUTED
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
460cc: 2600 movel %d0,%d3
460ce: 0683 0000 001c addil #28,%d3
460d4: 2f03 movel %d3,%sp@-
460d6: 4e94 jsr %a4@
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
460d8: 2f0a movel %a2,%sp@-
460da: 486b 0008 pea %a3@(8)
pthread_mutex_unlock (&r_chain->mutex);
460de: 45f9 0004 7078 lea 47078 <pthread_mutex_unlock>,%a2
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
460e4: 4eb9 0004 6662 jsr 46662 <rtems_aio_remove_req>
460ea: 2400 movel %d0,%d2
pthread_mutex_unlock (&r_chain->mutex);
460ec: 2f03 movel %d3,%sp@-
460ee: 4e92 jsr %a2@
pthread_mutex_unlock (&aio_request_queue.mutex);
460f0: 4879 0006 12c8 pea 612c8 <aio_request_queue>
460f6: 4e92 jsr %a2@
return result;
460f8: 4fef 0014 lea %sp@(20),%sp
}
return AIO_ALLDONE;
}
460fc: 2002 movel %d2,%d0
460fe: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
46104: 4e5e unlk %fp <== NOT EXECUTED
00046118 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
46118: 203c 0000 2000 movel #8192,%d0
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
4611e: 4e56 0000 linkw %fp,#0
46122: 2f0a movel %a2,%sp@-
46124: 246e 000c moveal %fp@(12),%a2
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
46128: b0ae 0008 cmpl %fp@(8),%d0
4612c: 671a beqs 46148 <aio_fsync+0x30>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
4612e: 7216 moveq #22,%d1
46130: 70ff moveq #-1,%d0
46132: 2541 0030 movel %d1,%a2@(48)
46136: 2540 0034 movel %d0,%a2@(52)
4613a: 4eb9 0004 f1bc jsr 4f1bc <__errno>
46140: 2040 moveal %d0,%a0
46142: 7016 moveq #22,%d0
46144: 2080 movel %d0,%a0@
46146: 607e bras 461c6 <aio_fsync+0xae>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
46148: 4878 0003 pea 3 <DIVIDE>
4614c: 2f12 movel %a2@,%sp@-
4614e: 4eb9 0004 c41c jsr 4c41c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
46154: 508f addql #8,%sp
46156: 7203 moveq #3,%d1
46158: c081 andl %d1,%d0
4615a: 123c 0001 moveb #1,%d1
4615e: 5380 subql #1,%d0
46160: b280 cmpl %d0,%d1
46162: 641a bccs 4617e <aio_fsync+0x66>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
46164: 72ff moveq #-1,%d1
46166: 7009 moveq #9,%d0
46168: 2541 0034 movel %d1,%a2@(52)
4616c: 2540 0030 movel %d0,%a2@(48)
46170: 4eb9 0004 f1bc jsr 4f1bc <__errno>
46176: 7209 moveq #9,%d1
46178: 2040 moveal %d0,%a0
4617a: 2081 movel %d1,%a0@
4617c: 6048 bras 461c6 <aio_fsync+0xae>
req = malloc (sizeof (rtems_aio_request));
4617e: 4878 0018 pea 18 <OPER2+0x4>
46182: 4eb9 0004 38dc jsr 438dc <malloc>
if (req == NULL)
46188: 588f addql #4,%sp
4618a: 4a80 tstl %d0
4618c: 661c bnes 461aa <aio_fsync+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
4618e: 103c 000b moveb #11,%d0 <== NOT EXECUTED
46192: 72ff moveq #-1,%d1 <== NOT EXECUTED
46194: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED
46198: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED
4619c: 4eb9 0004 f1bc jsr 4f1bc <__errno> <== NOT EXECUTED
461a2: 2040 moveal %d0,%a0 <== NOT EXECUTED
461a4: 700b moveq #11,%d0 <== NOT EXECUTED
461a6: 2080 movel %d0,%a0@ <== NOT EXECUTED
461a8: 601c bras 461c6 <aio_fsync+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
461aa: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_SYNC;
461ac: 7203 moveq #3,%d1
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
461ae: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
461b2: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
461b6: 246e fffc moveal %fp@(-4),%a2
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
461ba: 2d40 0008 movel %d0,%fp@(8)
}
461be: 4e5e unlk %fp
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
461c0: 4ef9 0004 66bc jmp 466bc <rtems_aio_enqueue>
}
461c6: 246e fffc moveal %fp@(-4),%a2
461ca: 70ff moveq #-1,%d0
461cc: 4e5e unlk %fp <== NOT EXECUTED
000468a8 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
468a8: 4e56 0000 linkw %fp,#0
468ac: 2f0a movel %a2,%sp@-
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
468ae: 4878 0003 pea 3 <DIVIDE>
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
468b2: 246e 0008 moveal %fp@(8),%a2
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
468b6: 2f12 movel %a2@,%sp@-
468b8: 4eb9 0004 c41c jsr 4c41c <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
468be: 508f addql #8,%sp
468c0: 7203 moveq #3,%d1
468c2: c081 andl %d1,%d0
468c4: 6722 beqs 468e8 <aio_read+0x40> <== NEVER TAKEN
468c6: 123c 0002 moveb #2,%d1
468ca: b280 cmpl %d0,%d1
468cc: 671a beqs 468e8 <aio_read+0x40>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
468ce: 7009 moveq #9,%d0
468d0: 72ff moveq #-1,%d1
468d2: 2540 0030 movel %d0,%a2@(48)
468d6: 2541 0034 movel %d1,%a2@(52)
468da: 4eb9 0004 f1bc jsr 4f1bc <__errno>
468e0: 2040 moveal %d0,%a0
468e2: 7009 moveq #9,%d0
468e4: 2080 movel %d0,%a0@
468e6: 606e bras 46956 <aio_read+0xae>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
468e8: 4aaa 0014 tstl %a2@(20)
468ec: 6606 bnes 468f4 <aio_read+0x4c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
468ee: 4aaa 0004 tstl %a2@(4)
468f2: 6a1a bpls 4690e <aio_read+0x66>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
468f4: 72ff moveq #-1,%d1
468f6: 7016 moveq #22,%d0
468f8: 2541 0034 movel %d1,%a2@(52)
468fc: 2540 0030 movel %d0,%a2@(48)
46900: 4eb9 0004 f1bc jsr 4f1bc <__errno>
46906: 7216 moveq #22,%d1
46908: 2040 moveal %d0,%a0
4690a: 2081 movel %d1,%a0@
4690c: 6048 bras 46956 <aio_read+0xae>
req = malloc (sizeof (rtems_aio_request));
4690e: 4878 0018 pea 18 <OPER2+0x4>
46912: 4eb9 0004 38dc jsr 438dc <malloc>
if (req == NULL)
46918: 588f addql #4,%sp
4691a: 4a80 tstl %d0
4691c: 661c bnes 4693a <aio_read+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
4691e: 103c 000b moveb #11,%d0 <== NOT EXECUTED
46922: 72ff moveq #-1,%d1 <== NOT EXECUTED
46924: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED
46928: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED
4692c: 4eb9 0004 f1bc jsr 4f1bc <__errno> <== NOT EXECUTED
46932: 2040 moveal %d0,%a0 <== NOT EXECUTED
46934: 700b moveq #11,%d0 <== NOT EXECUTED
46936: 2080 movel %d0,%a0@ <== NOT EXECUTED
46938: 601c bras 46956 <aio_read+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
4693a: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_READ;
4693c: 7201 moveq #1,%d1
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
4693e: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_READ;
46942: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
46946: 246e fffc moveal %fp@(-4),%a2
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
4694a: 2d40 0008 movel %d0,%fp@(8)
}
4694e: 4e5e unlk %fp
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
46950: 4ef9 0004 66bc jmp 466bc <rtems_aio_enqueue>
}
46956: 246e fffc moveal %fp@(-4),%a2
4695a: 70ff moveq #-1,%d0
4695c: 4e5e unlk %fp <== NOT EXECUTED
00046970 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
46970: 4e56 0000 linkw %fp,#0
46974: 2f0a movel %a2,%sp@-
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
46976: 4878 0003 pea 3 <DIVIDE>
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
4697a: 246e 0008 moveal %fp@(8),%a2
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
4697e: 2f12 movel %a2@,%sp@-
46980: 4eb9 0004 c41c jsr 4c41c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
46986: 508f addql #8,%sp
46988: 7203 moveq #3,%d1
4698a: c081 andl %d1,%d0
4698c: 123c 0001 moveb #1,%d1
46990: 5380 subql #1,%d0
46992: b280 cmpl %d0,%d1
46994: 641a bccs 469b0 <aio_write+0x40>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
46996: 7009 moveq #9,%d0
46998: 72ff moveq #-1,%d1
4699a: 2540 0030 movel %d0,%a2@(48)
4699e: 2541 0034 movel %d1,%a2@(52)
469a2: 4eb9 0004 f1bc jsr 4f1bc <__errno>
469a8: 2040 moveal %d0,%a0
469aa: 7009 moveq #9,%d0
469ac: 2080 movel %d0,%a0@
469ae: 606e bras 46a1e <aio_write+0xae>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
469b0: 4aaa 0014 tstl %a2@(20)
469b4: 6606 bnes 469bc <aio_write+0x4c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
469b6: 4aaa 0004 tstl %a2@(4)
469ba: 6a1a bpls 469d6 <aio_write+0x66>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
469bc: 72ff moveq #-1,%d1
469be: 7016 moveq #22,%d0
469c0: 2541 0034 movel %d1,%a2@(52)
469c4: 2540 0030 movel %d0,%a2@(48)
469c8: 4eb9 0004 f1bc jsr 4f1bc <__errno>
469ce: 7216 moveq #22,%d1
469d0: 2040 moveal %d0,%a0
469d2: 2081 movel %d1,%a0@
469d4: 6048 bras 46a1e <aio_write+0xae>
req = malloc (sizeof (rtems_aio_request));
469d6: 4878 0018 pea 18 <OPER2+0x4>
469da: 4eb9 0004 38dc jsr 438dc <malloc>
if (req == NULL)
469e0: 588f addql #4,%sp
469e2: 4a80 tstl %d0
469e4: 661c bnes 46a02 <aio_write+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
469e6: 103c 000b moveb #11,%d0 <== NOT EXECUTED
469ea: 72ff moveq #-1,%d1 <== NOT EXECUTED
469ec: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED
469f0: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED
469f4: 4eb9 0004 f1bc jsr 4f1bc <__errno> <== NOT EXECUTED
469fa: 2040 moveal %d0,%a0 <== NOT EXECUTED
469fc: 700b moveq #11,%d0 <== NOT EXECUTED
469fe: 2080 movel %d0,%a0@ <== NOT EXECUTED
46a00: 601c bras 46a1e <aio_write+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
46a02: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_WRITE;
46a04: 7202 moveq #2,%d1
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
46a06: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
46a0a: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
46a0e: 246e fffc moveal %fp@(-4),%a2
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
46a12: 2d40 0008 movel %d0,%fp@(8)
}
46a16: 4e5e unlk %fp
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
46a18: 4ef9 0004 66bc jmp 466bc <rtems_aio_enqueue>
}
46a1e: 246e fffc moveal %fp@(-4),%a2
46a22: 70ff moveq #-1,%d0
46a24: 4e5e unlk %fp <== NOT EXECUTED
00044008 <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
44008: 4e56 ffe8 linkw %fp,#-24
4400c: 2f03 movel %d3,%sp@-
4400e: 262e 0008 movel %fp@(8),%d3
44012: 2f02 movel %d2,%sp@-
int status;
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
44014: 240e movel %fp,%d2
44016: 0682 ffff ffec addil #-20,%d2
4401c: 2f03 movel %d3,%sp@-
4401e: 4eb9 0005 0618 jsr 50618 <strlen>
44024: 7201 moveq #1,%d1
44026: 2e81 movel %d1,%sp@
44028: 2f02 movel %d2,%sp@-
4402a: 42a7 clrl %sp@-
4402c: 2f00 movel %d0,%sp@-
4402e: 2f03 movel %d3,%sp@-
44030: 4eb9 0004 44c0 jsr 444c0 <rtems_filesystem_evaluate_path>
if ( status != 0 )
44036: 4fef 0014 lea %sp@(20),%sp
4403a: 4a80 tstl %d0
4403c: 6626 bnes 44064 <chmod+0x5c> <== NEVER TAKEN
return -1;
result = (*loc.handlers->fchmod_h)( &loc, mode );
4403e: 2f2e 000c movel %fp@(12),%sp@-
44042: 206e fff4 moveal %fp@(-12),%a0
44046: 2f02 movel %d2,%sp@-
44048: 2068 001c moveal %a0@(28),%a0
4404c: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
4404e: 2f02 movel %d2,%sp@-
44050: 2d40 ffe8 movel %d0,%fp@(-24)
44054: 4eb9 0004 468c jsr 4468c <rtems_filesystem_freenode>
return result;
4405a: 202e ffe8 movel %fp@(-24),%d0
4405e: 4fef 000c lea %sp@(12),%sp
44062: 6002 bras 44066 <chmod+0x5e>
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
if ( status != 0 )
return -1;
44064: 70ff moveq #-1,%d0
result = (*loc.handlers->fchmod_h)( &loc, mode );
rtems_filesystem_freenode( &loc );
return result;
}
44066: 242e ffe0 movel %fp@(-32),%d2
4406a: 262e ffe4 movel %fp@(-28),%d3
4406e: 4e5e unlk %fp
...
00044640 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
44640: 4e56 ffe0 linkw %fp,#-32
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
44644: 203c 0006 16a4 movel #399012,%d0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
4464a: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
4464e: b0b9 0006 0030 cmpl 60030 <rtems_current_user_env>,%d0
44654: 6624 bnes 4467a <chroot+0x3a>
rtems_libio_set_private_env(); /* try to set a new private env*/
44656: 4eb9 0004 5c28 jsr 45c28 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
4465c: 41f9 0006 16a4 lea 616a4 <rtems_global_user_env>,%a0
44662: b1f9 0006 0030 cmpal 60030 <rtems_current_user_env>,%a0
44668: 6610 bnes 4467a <chroot+0x3a>
rtems_set_errno_and_return_minus_one( ENOTSUP );
4466a: 4eb9 0004 f51c jsr 4f51c <__errno>
44670: 2040 moveal %d0,%a0
44672: 20bc 0000 0086 movel #134,%a0@
44678: 6020 bras 4469a <chroot+0x5a>
}
result = chdir(pathname);
4467a: 2f2e 0008 movel %fp@(8),%sp@-
4467e: 4eb9 0004 458c jsr 4458c <chdir>
if (result) {
44684: 588f addql #4,%sp
44686: 4a80 tstl %d0
44688: 6714 beqs 4469e <chroot+0x5e>
rtems_set_errno_and_return_minus_one( errno );
4468a: 45f9 0004 f51c lea 4f51c <__errno>,%a2
44690: 4e92 jsr %a2@
44692: 2640 moveal %d0,%a3
44694: 4e92 jsr %a2@
44696: 2040 moveal %d0,%a0
44698: 2690 movel %a0@,%a3@
4469a: 70ff moveq #-1,%d0
4469c: 6056 bras 446f4 <chroot+0xb4>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
4469e: 42a7 clrl %sp@-
446a0: 240e movel %fp,%d2
446a2: 0682 ffff ffec addil #-20,%d2
446a8: 2f02 movel %d2,%sp@-
446aa: 42a7 clrl %sp@-
446ac: 4878 0001 pea 1 <ADD>
446b0: 4879 0005 de45 pea 5de45 <_rodata_start+0x1b5>
446b6: 4eb9 0004 49f4 jsr 449f4 <rtems_filesystem_evaluate_path>
446bc: 4fef 0014 lea %sp@(20),%sp
446c0: 4a80 tstl %d0
446c2: 66c6 bnes 4468a <chroot+0x4a> <== NEVER TAKEN
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
}
rtems_filesystem_freenode(&rtems_filesystem_root);
446c4: 2079 0006 0030 moveal 60030 <rtems_current_user_env>,%a0
446ca: 41e8 0018 lea %a0@(24),%a0
446ce: 2f08 movel %a0,%sp@-
446d0: 4eb9 0004 4bc0 jsr 44bc0 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
446d6: 4878 0014 pea 14 <OPER2>
446da: 2079 0006 0030 moveal 60030 <rtems_current_user_env>,%a0
446e0: 41e8 0018 lea %a0@(24),%a0
446e4: 2f02 movel %d2,%sp@-
446e6: 2f08 movel %a0,%sp@-
446e8: 4eb9 0004 fd3c jsr 4fd3c <memcpy>
return 0;
446ee: 4fef 0010 lea %sp@(16),%sp
446f2: 4280 clrl %d0
}
446f4: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3
446fa: 4e5e unlk %fp
...
00045694 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
45694: 4e56 0000 linkw %fp,#0
45698: 222e 0008 movel %fp@(8),%d1
4569c: 202e 000c movel %fp@(12),%d0
456a0: 2f02 movel %d2,%sp@-
if ( !tp )
456a2: 4a80 tstl %d0
456a4: 6608 bnes 456ae <clock_gettime+0x1a>
rtems_set_errno_and_return_minus_one( EINVAL );
456a6: 4eb9 0004 da30 jsr 4da30 <__errno>
456ac: 6042 bras 456f0 <clock_gettime+0x5c>
if ( clock_id == CLOCK_REALTIME ) {
456ae: 7401 moveq #1,%d2
456b0: b481 cmpl %d1,%d2
456b2: 660a bnes 456be <clock_gettime+0x2a>
_TOD_Get(tp);
456b4: 2f00 movel %d0,%sp@-
456b6: 4eb9 0004 7350 jsr 47350 <_TOD_Get>
456bc: 6014 bras 456d2 <clock_gettime+0x3e>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
456be: 7404 moveq #4,%d2
456c0: b481 cmpl %d1,%d2
456c2: 6706 beqs 456ca <clock_gettime+0x36> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
456c4: 7402 moveq #2,%d2
456c6: b481 cmpl %d1,%d2
456c8: 660e bnes 456d8 <clock_gettime+0x44>
_TOD_Get_uptime_as_timespec( tp );
456ca: 2f00 movel %d0,%sp@-
456cc: 4eb9 0004 73b4 jsr 473b4 <_TOD_Get_uptime_as_timespec>
return 0;
456d2: 588f addql #4,%sp
456d4: 4280 clrl %d0
456d6: 6020 bras 456f8 <clock_gettime+0x64>
456d8: 41f9 0004 da30 lea 4da30 <__errno>,%a0
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
456de: 7003 moveq #3,%d0
456e0: b081 cmpl %d1,%d0
456e2: 660a bnes 456ee <clock_gettime+0x5a>
rtems_set_errno_and_return_minus_one( ENOSYS );
456e4: 4e90 jsr %a0@
456e6: 7258 moveq #88,%d1
456e8: 2040 moveal %d0,%a0
456ea: 2081 movel %d1,%a0@
456ec: 6008 bras 456f6 <clock_gettime+0x62>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
456ee: 4e90 jsr %a0@
456f0: 2040 moveal %d0,%a0
456f2: 7016 moveq #22,%d0
456f4: 2080 movel %d0,%a0@
456f6: 70ff moveq #-1,%d0
return 0;
}
456f8: 242e fffc movel %fp@(-4),%d2
456fc: 4e5e unlk %fp <== NOT EXECUTED
00045700 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
45700: 4e56 0000 linkw %fp,#0
45704: 202e 0008 movel %fp@(8),%d0
45708: 206e 000c moveal %fp@(12),%a0
if ( !tp )
4570c: 4a88 tstl %a0
4570e: 6710 beqs 45720 <clock_settime+0x20> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
45710: 7201 moveq #1,%d1
45712: b280 cmpl %d0,%d1
45714: 663a bnes 45750 <clock_settime+0x50> <== NEVER TAKEN
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
45716: 203c 21da e4ff movel #567993599,%d0
4571c: b090 cmpl %a0@,%d0
4571e: 6508 bcss 45728 <clock_settime+0x28>
rtems_set_errno_and_return_minus_one( EINVAL );
45720: 4eb9 0004 da30 jsr 4da30 <__errno>
45726: 6046 bras 4576e <clock_settime+0x6e>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45728: 2039 0006 05c8 movel 605c8 <_Thread_Dispatch_disable_level>,%d0
4572e: 5280 addql #1,%d0
45730: 23c0 0006 05c8 movel %d0,605c8 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45736: 2039 0006 05c8 movel 605c8 <_Thread_Dispatch_disable_level>,%d0
_Thread_Disable_dispatch();
_TOD_Set( tp );
4573c: 2f08 movel %a0,%sp@-
4573e: 4eb9 0004 740c jsr 4740c <_TOD_Set>
_Thread_Enable_dispatch();
45744: 4eb9 0004 894c jsr 4894c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
4574a: 588f addql #4,%sp
4574c: 4280 clrl %d0
4574e: 6026 bras 45776 <clock_settime+0x76>
45750: 41f9 0004 da30 lea 4da30 <__errno>,%a0
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
45756: 7202 moveq #2,%d1
45758: b280 cmpl %d0,%d1
4575a: 6706 beqs 45762 <clock_settime+0x62>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
4575c: 7203 moveq #3,%d1
4575e: b280 cmpl %d0,%d1
45760: 660a bnes 4576c <clock_settime+0x6c>
rtems_set_errno_and_return_minus_one( ENOSYS );
45762: 4e90 jsr %a0@
45764: 7258 moveq #88,%d1
45766: 2040 moveal %d0,%a0
45768: 2081 movel %d1,%a0@
4576a: 6008 bras 45774 <clock_settime+0x74>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
4576c: 4e90 jsr %a0@
4576e: 2040 moveal %d0,%a0
45770: 7016 moveq #22,%d0
45772: 2080 movel %d0,%a0@
45774: 70ff moveq #-1,%d0
return 0;
}
45776: 4e5e unlk %fp
...
00042534 <create_disk>:
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
42534: 4e56 ffe0 linkw %fp,#-32
42538: 48d7 0cfc moveml %d2-%d7/%a2-%a3,%sp@
4253c: 242e 0008 movel %fp@(8),%d2
42540: 262e 000c movel %fp@(12),%d3
42544: 2e2e 0010 movel %fp@(16),%d7
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
42548: 2c02 movel %d2,%d6
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.minor;
4254a: 2a03 movel %d3,%d5
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
4254c: 2479 0006 15ca moveal 615ca <disktab_size>,%a2
42552: b5c6 cmpal %d6,%a2
42554: 6252 bhis 425a8 <create_disk+0x74>
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
42556: 280a movel %a2,%d4
42558: d884 addl %d4,%d4
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
4255a: 2039 0006 15ce movel 615ce <disktab>,%d0
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
if (major >= new_size) {
42560: b886 cmpl %d6,%d4
42562: 6204 bhis 42568 <create_disk+0x34> <== NEVER TAKEN
new_size = major + 1;
42564: 2806 movel %d6,%d4
42566: 5284 addql #1,%d4
}
table = realloc(table, new_size * sizeof(*table));
42568: 2204 movel %d4,%d1
4256a: e789 lsll #3,%d1
4256c: 2f01 movel %d1,%sp@-
4256e: 2f00 movel %d0,%sp@-
42570: 4eb9 0004 4308 jsr 44308 <realloc>
if (table == NULL) {
42576: 508f addql #8,%sp
if (major >= new_size) {
new_size = major + 1;
}
table = realloc(table, new_size * sizeof(*table));
42578: 2640 moveal %d0,%a3
if (table == NULL) {
4257a: 4a80 tstl %d0
4257c: 6700 0104 beqw 42682 <create_disk+0x14e>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
42580: 2004 movel %d4,%d0 <== NOT EXECUTED
42582: 908a subl %a2,%d0 <== NOT EXECUTED
42584: 220a movel %a2,%d1 <== NOT EXECUTED
42586: e788 lsll #3,%d0 <== NOT EXECUTED
42588: e789 lsll #3,%d1 <== NOT EXECUTED
4258a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4258c: 42a7 clrl %sp@- <== NOT EXECUTED
4258e: 4873 1800 pea %a3@(00000000,%d1:l) <== NOT EXECUTED
42592: 4eb9 0005 0c00 jsr 50c00 <memset> <== NOT EXECUTED
disktab = table;
disktab_size = new_size;
42598: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
if (table == NULL) {
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab = table;
4259c: 23cb 0006 15ce movel %a3,615ce <disktab> <== NOT EXECUTED
disktab_size = new_size;
425a2: 23c4 0006 15ca movel %d4,615ca <disktab_size> <== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
425a8: 2479 0006 15ce moveal 615ce <disktab>,%a2
425ae: e78e lsll #3,%d6
425b0: d5c6 addal %d6,%a2
425b2: 2012 movel %a2@,%d0
425b4: 6706 beqs 425bc <create_disk+0x88>
425b6: baaa 0004 cmpl %a2@(4),%d5
425ba: 654c bcss 42608 <create_disk+0xd4> <== ALWAYS TAKEN
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
425bc: 2c2a 0004 movel %a2@(4),%d6
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
425c0: 6706 beqs 425c8 <create_disk+0x94> <== ALWAYS TAKEN
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
425c2: 2806 movel %d6,%d4 <== NOT EXECUTED
425c4: d884 addl %d4,%d4 <== NOT EXECUTED
425c6: 6002 bras 425ca <create_disk+0x96> <== NOT EXECUTED
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
new_size = DISKTAB_INITIAL_SIZE;
425c8: 7808 moveq #8,%d4
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
425ca: b885 cmpl %d5,%d4
425cc: 6204 bhis 425d2 <create_disk+0x9e>
new_size = minor + 1;
425ce: 2805 movel %d5,%d4
425d0: 5284 addql #1,%d4
}
table = realloc(table, new_size * sizeof(*table));
425d2: 2204 movel %d4,%d1
425d4: e589 lsll #2,%d1
425d6: 2f01 movel %d1,%sp@-
425d8: 2f00 movel %d0,%sp@-
425da: 4eb9 0004 4308 jsr 44308 <realloc>
if (table == NULL) {
425e0: 508f addql #8,%sp
}
if (minor >= new_size) {
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
425e2: 2640 moveal %d0,%a3
if (table == NULL) {
425e4: 4a80 tstl %d0
425e6: 6700 009a beqw 42682 <create_disk+0x14e>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
425ea: 2004 movel %d4,%d0
425ec: 9086 subl %d6,%d0
425ee: e588 lsll #2,%d0
425f0: 2f00 movel %d0,%sp@-
425f2: 42a7 clrl %sp@-
425f4: 4873 6c00 pea %a3@(00000000,%d6:l:4)
425f8: 4eb9 0005 0c00 jsr 50c00 <memset>
disktab [major].minor = table;
disktab [major].size = new_size;
425fe: 4fef 000c lea %sp@(12),%sp
if (table == NULL) {
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab [major].minor = table;
42602: 248b movel %a3,%a2@
disktab [major].size = new_size;
42604: 2544 0004 movel %d4,%a2@(4)
}
return disktab [major].minor + minor;
42608: 2652 moveal %a2@,%a3
4260a: e58d lsll #2,%d5
4260c: d7c5 addal %d5,%a3
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
4260e: 4a8b tstl %a3
42610: 6770 beqs 42682 <create_disk+0x14e> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
42612: 4a93 tstl %a3@
42614: 6668 bnes 4267e <create_disk+0x14a>
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
42616: 4878 0032 pea 32 <OPER2+0x1e>
4261a: 4eb9 0004 391c jsr 4391c <malloc>
if (dd == NULL) {
42620: 588f addql #4,%sp
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
42622: 2440 moveal %d0,%a2
if (dd == NULL) {
42624: 4a80 tstl %d0
42626: 675a beqs 42682 <create_disk+0x14e> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
42628: 4a87 tstl %d7
4262a: 6730 beqs 4265c <create_disk+0x128>
alloc_name = strdup(name);
4262c: 2f07 movel %d7,%sp@-
4262e: 4eb9 0005 11f0 jsr 511f0 <strdup>
if (alloc_name == NULL) {
42634: 588f addql #4,%sp
if (dd == NULL) {
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
alloc_name = strdup(name);
42636: 2800 movel %d0,%d4
42638: 2a00 movel %d0,%d5
if (alloc_name == NULL) {
4263a: 6652 bnes 4268e <create_disk+0x15a> <== ALWAYS TAKEN
free(dd);
4263c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4263e: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
42644: 588f addql #4,%sp <== NOT EXECUTED
42646: 603a bras 42682 <create_disk+0x14e> <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
42648: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4264a: 47f9 0004 3630 lea 43630 <free>,%a3 <== NOT EXECUTED
42650: 4e93 jsr %a3@ <== NOT EXECUTED
free(dd);
42652: 2f0a movel %a2,%sp@- <== NOT EXECUTED
42654: 4e93 jsr %a3@ <== NOT EXECUTED
return RTEMS_UNSATISFIED;
42656: 508f addql #8,%sp <== NOT EXECUTED
42658: 700d moveq #13,%d0 <== NOT EXECUTED
4265a: 6028 bras 42684 <create_disk+0x150> <== NOT EXECUTED
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
4265c: 4285 clrl %d5
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
dd->name = alloc_name;
4265e: 2545 0010 movel %d5,%a2@(16)
dd->uses = 0;
dd->deleted = false;
*dd_entry = dd;
*dd_ptr = dd;
42662: 206e 0014 moveal %fp@(20),%a0
}
}
dd->dev = dev;
dd->name = alloc_name;
dd->uses = 0;
42666: 42aa 0014 clrl %a2@(20)
dd->deleted = false;
4266a: 4200 clrb %d0
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
4266c: 2482 movel %d2,%a2@
4266e: 2543 0004 movel %d3,%a2@(4)
dd->name = alloc_name;
dd->uses = 0;
dd->deleted = false;
42672: 1540 0030 moveb %d0,%a2@(48)
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
42676: 4280 clrl %d0
dd->dev = dev;
dd->name = alloc_name;
dd->uses = 0;
dd->deleted = false;
*dd_entry = dd;
42678: 268a movel %a2,%a3@
*dd_ptr = dd;
4267a: 208a movel %a2,%a0@
return RTEMS_SUCCESSFUL;
4267c: 6006 bras 42684 <create_disk+0x150>
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
4267e: 700c moveq #12,%d0
42680: 6002 bras 42684 <create_disk+0x150>
}
dd = malloc(sizeof(*dd));
if (dd == NULL) {
return RTEMS_NO_MEMORY;
42682: 701a moveq #26,%d0
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
}
42684: 4cee 0cfc ffe0 moveml %fp@(-32),%d2-%d7/%a2-%a3
4268a: 4e5e unlk %fp
4268c: 4e75 rts
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
4268e: 2f03 movel %d3,%sp@-
42690: 2f02 movel %d2,%sp@-
42692: 4878 61ff pea 61ff <D_MAX_EXP+0x5a00>
42696: 2f00 movel %d0,%sp@-
42698: 4eb9 0004 39e8 jsr 439e8 <mknod>
4269e: 4fef 0010 lea %sp@(16),%sp
426a2: 4a80 tstl %d0
426a4: 6cb8 bges 4265e <create_disk+0x12a> <== ALWAYS TAKEN
426a6: 60a0 bras 42648 <create_disk+0x114> <== NOT EXECUTED
0004a24c <devFS_evaluate_path>:
{
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
4a24c: 70f8 moveq #-8,%d0
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
4a24e: 4e56 ffe4 linkw %fp,#-28
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
4a252: c0ae 0010 andl %fp@(16),%d0
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
4a256: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
4a25a: 282e 0008 movel %fp@(8),%d4
4a25e: 262e 000c movel %fp@(12),%d3
4a262: 246e 0014 moveal %fp@(20),%a2
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
4a266: 4a80 tstl %d0
4a268: 670e beqs 4a278 <devFS_evaluate_path+0x2c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
4a26a: 4eb9 0004 c718 jsr 4c718 <__errno> <== NOT EXECUTED
4a270: 7401 moveq #1,%d2 <== NOT EXECUTED
4a272: 2040 moveal %d0,%a0 <== NOT EXECUTED
4a274: 2082 movel %d2,%a0@ <== NOT EXECUTED
4a276: 607a bras 4a2f2 <devFS_evaluate_path+0xa6> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
4a278: 2652 moveal %a2@,%a3
if (!device_name_table)
4a27a: 4a8b tstl %a3
4a27c: 670a beqs 4a288 <devFS_evaluate_path+0x3c>
4a27e: 4282 clrl %d2
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
4a280: 4bf9 0004 e038 lea 4e038 <strncmp>,%a5
4a286: 6056 bras 4a2de <devFS_evaluate_path+0x92>
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
4a288: 4eb9 0004 c718 jsr 4c718 <__errno>
4a28e: 720e moveq #14,%d1
4a290: 2040 moveal %d0,%a0
4a292: 2081 movel %d1,%a0@
4a294: 605c bras 4a2f2 <devFS_evaluate_path+0xa6>
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
4a296: 2853 moveal %a3@,%a4
4a298: 4a8c tstl %a4
4a29a: 673c beqs 4a2d8 <devFS_evaluate_path+0x8c>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
4a29c: 2f03 movel %d3,%sp@-
4a29e: 2f0c movel %a4,%sp@-
4a2a0: 2f04 movel %d4,%sp@-
4a2a2: 4e95 jsr %a5@
4a2a4: 4fef 000c lea %sp@(12),%sp
4a2a8: 4a80 tstl %d0
4a2aa: 662c bnes 4a2d8 <devFS_evaluate_path+0x8c>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
4a2ac: 4a34 3800 tstb %a4@(00000000,%d3:l)
4a2b0: 6626 bnes 4a2d8 <devFS_evaluate_path+0x8c> <== NEVER TAKEN
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
4a2b2: 41f9 0005 bfa0 lea 5bfa0 <devFS_ops>,%a0
4a2b8: 2548 000c movel %a0,%a2@(12)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
4a2bc: 2079 0005 c104 moveal 5c104 <rtems_current_user_env>,%a0
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
4a2c2: 203c 0005 bf68 movel #376680,%d0
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
4a2c8: 2568 0028 0010 movel %a0@(40),%a2@(16)
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
4a2ce: 2540 0008 movel %d0,%a2@(8)
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
4a2d2: 4280 clrl %d0
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
4a2d4: 248b movel %a3,%a2@
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
4a2d6: 601c bras 4a2f4 <devFS_evaluate_path+0xa8>
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
4a2d8: 5282 addql #1,%d2
4a2da: 47eb 0014 lea %a3@(20),%a3
4a2de: b4b9 0005 bf26 cmpl 5bf26 <rtems_device_table_size>,%d2
4a2e4: 65b0 bcss 4a296 <devFS_evaluate_path+0x4a>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
4a2e6: 4eb9 0004 c718 jsr 4c718 <__errno>
4a2ec: 2040 moveal %d0,%a0
4a2ee: 7002 moveq #2,%d0
4a2f0: 2080 movel %d0,%a0@
4a2f2: 70ff moveq #-1,%d0
}
4a2f4: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
4a2fa: 4e5e unlk %fp <== NOT EXECUTED
00043944 <devFS_mknod>:
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
43944: 7264 moveq #100,%d1
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
43946: 4e56 ffdc linkw %fp,#-36
4394a: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4394e: 246e 0008 moveal %fp@(8),%a2
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
43952: 1012 moveb %a2@,%d0
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
43954: 282e 000c movel %fp@(12),%d4
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
43958: 49c0 extbl %d0
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
4395a: 2c2e 0010 movel %fp@(16),%d6
4395e: 2a2e 0014 movel %fp@(20),%d5
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
43962: b280 cmpl %d0,%d1
43964: 6624 bnes 4398a <devFS_mknod+0x46>
43966: 123c 0065 moveb #101,%d1
4396a: 102a 0001 moveb %a2@(1),%d0
4396e: 49c0 extbl %d0
43970: b280 cmpl %d0,%d1
43972: 6616 bnes 4398a <devFS_mknod+0x46> <== NEVER TAKEN
43974: 123c 0076 moveb #118,%d1
43978: 102a 0002 moveb %a2@(2),%d0
4397c: 49c0 extbl %d0
4397e: b280 cmpl %d0,%d1
43980: 6608 bnes 4398a <devFS_mknod+0x46> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
43982: 4a2a 0003 tstb %a2@(3)
43986: 6700 00c8 beqw 43a50 <devFS_mknod+0x10c>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
4398a: 2004 movel %d4,%d0
4398c: 0280 0000 f000 andil #61440,%d0
43992: 0c80 0000 6000 cmpil #24576,%d0
43998: 6716 beqs 439b0 <devFS_mknod+0x6c>
4399a: 0c80 0000 2000 cmpil #8192,%d0
439a0: 670e beqs 439b0 <devFS_mknod+0x6c>
rtems_set_errno_and_return_minus_one( EINVAL );
439a2: 4eb9 0004 c718 jsr 4c718 <__errno>
439a8: 7616 moveq #22,%d3
439aa: 2040 moveal %d0,%a0
439ac: 2083 movel %d3,%a0@
439ae: 6066 bras 43a16 <devFS_mknod+0xd2>
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
439b0: 206e 0018 moveal %fp@(24),%a0
439b4: 2650 moveal %a0@,%a3
if (!device_name_table)
439b6: 4a8b tstl %a3
439b8: 670e beqs 439c8 <devFS_mknod+0x84>
439ba: 284b moveal %a3,%a4
439bc: 74ff moveq #-1,%d2
439be: 4283 clrl %d3
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
439c0: 4bf9 0004 dae4 lea 4dae4 <strcmp>,%a5
439c6: 6034 bras 439fc <devFS_mknod+0xb8>
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
439c8: 4eb9 0004 c718 jsr 4c718 <__errno>
439ce: 740e moveq #14,%d2
439d0: 2240 moveal %d0,%a1
439d2: 2282 movel %d2,%a1@
439d4: 6040 bras 43a16 <devFS_mknod+0xd2>
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
439d6: 2014 movel %a4@,%d0
439d8: 671a beqs 439f4 <devFS_mknod+0xb0>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
439da: 2f00 movel %d0,%sp@-
439dc: 2f0a movel %a2,%sp@-
439de: 4e95 jsr %a5@
439e0: 508f addql #8,%sp
439e2: 4a80 tstl %d0
439e4: 6610 bnes 439f6 <devFS_mknod+0xb2>
rtems_set_errno_and_return_minus_one( EEXIST );
439e6: 4eb9 0004 c718 jsr 4c718 <__errno>
439ec: 7211 moveq #17,%d1
439ee: 2040 moveal %d0,%a0
439f0: 2081 movel %d1,%a0@
439f2: 6022 bras 43a16 <devFS_mknod+0xd2>
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
439f4: 2403 movel %d3,%d2
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
439f6: 5283 addql #1,%d3
439f8: 49ec 0014 lea %a4@(20),%a4
439fc: b6b9 0005 bf26 cmpl 5bf26 <rtems_device_table_size>,%d3
43a02: 65d2 bcss 439d6 <devFS_mknod+0x92>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
43a04: 70ff moveq #-1,%d0
43a06: b082 cmpl %d2,%d0
43a08: 6610 bnes 43a1a <devFS_mknod+0xd6>
rtems_set_errno_and_return_minus_one( ENOMEM );
43a0a: 4eb9 0004 c718 jsr 4c718 <__errno>
43a10: 2040 moveal %d0,%a0
43a12: 700c moveq #12,%d0
43a14: 2080 movel %d0,%a0@
43a16: 70ff moveq #-1,%d0
43a18: 6038 bras 43a52 <devFS_mknod+0x10e>
_ISR_Disable(level);
43a1a: 203c 0000 0700 movel #1792,%d0
43a20: 40c3 movew %sr,%d3
43a22: 8083 orl %d3,%d0
43a24: 46c0 movew %d0,%sr
device_name_table[slot].device_name = (char *)path;
43a26: 2002 movel %d2,%d0
43a28: e988 lsll #4,%d0
43a2a: 2240 moveal %d0,%a1
43a2c: 41f1 2c00 lea %a1@(00000000,%d2:l:4),%a0
43a30: d7c8 addal %a0,%a3
43a32: 268a movel %a2,%a3@
device_name_table[slot].device_name_length = strlen(path);
43a34: 2f0a movel %a2,%sp@-
43a36: 4eb9 0004 e01c jsr 4e01c <strlen>
43a3c: 588f addql #4,%sp
43a3e: 2740 0004 movel %d0,%a3@(4)
device_name_table[slot].major = major;
43a42: 2746 0008 movel %d6,%a3@(8)
device_name_table[slot].minor = minor;
43a46: 2745 000c movel %d5,%a3@(12)
device_name_table[slot].mode = mode;
43a4a: 2744 0010 movel %d4,%a3@(16)
_ISR_Enable(level);
43a4e: 46c3 movew %d3,%sr
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
(path[2] == 'v') && (path[3] == '\0'))
return 0;
43a50: 4280 clrl %d0
device_name_table[slot].minor = minor;
device_name_table[slot].mode = mode;
_ISR_Enable(level);
return 0;
}
43a52: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
43a58: 4e5e unlk %fp <== NOT EXECUTED
000424d8 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
424d8: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
424dc: 42a7 clrl %sp@-
424de: 42a7 clrl %sp@-
424e0: 2f39 0006 15c6 movel 615c6 <diskdevs_mutex>,%sp@-
424e6: 4eb9 0004 66c8 jsr 466c8 <rtems_semaphore_obtain>
if (sc == RTEMS_SUCCESSFUL) {
424ec: 4fef 000c lea %sp@(12),%sp
424f0: 4a80 tstl %d0
424f2: 660c bnes 42500 <disk_lock+0x28> <== NEVER TAKEN
diskdevs_protected = true;
424f4: 7001 moveq #1,%d0
424f6: 13c0 0006 15c4 moveb %d0,615c4 <diskdevs_protected>
return RTEMS_SUCCESSFUL;
424fc: 4280 clrl %d0
424fe: 6002 bras 42502 <disk_lock+0x2a>
} else {
return RTEMS_NOT_CONFIGURED;
42500: 7016 moveq #22,%d0 <== NOT EXECUTED
}
}
42502: 4e5e unlk %fp <== NOT EXECUTED
00042506 <disk_unlock>:
static void
disk_unlock(void)
{
42506: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
4250a: 4200 clrb %d0
sc = rtems_semaphore_release(diskdevs_mutex);
4250c: 2f39 0006 15c6 movel 615c6 <diskdevs_mutex>,%sp@-
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
42512: 13c0 0006 15c4 moveb %d0,615c4 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
42518: 4eb9 0004 67d4 jsr 467d4 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
4251e: 588f addql #4,%sp
42520: 4a80 tstl %d0
42522: 670c beqs 42530 <disk_unlock+0x2a> <== ALWAYS TAKEN
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
42524: 2f3c dead beef movel #-559038737,%sp@- <== NOT EXECUTED
4252a: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
42530: 4e5e unlk %fp <== NOT EXECUTED
0004393c <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
4393c: 4e56 fff4 linkw %fp,#-12
43940: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
43944: 246e 0008 moveal %fp@(8),%a2
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
43948: 243c 0000 0700 movel #1792,%d2
4394e: 2202 movel %d2,%d1
43950: 40c0 movew %sr,%d0
43952: 8280 orl %d0,%d1
43954: 46c1 movew %d1,%sr
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
43956: 47f9 0004 59e0 lea 459e0 <rtems_semaphore_obtain>,%a3
4395c: 602a bras 43988 <drainOutput.part.0+0x4c>
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
4395e: 7202 moveq #2,%d1
43960: 2541 0094 movel %d1,%a2@(148)
rtems_interrupt_enable (level);
43964: 46c0 movew %d0,%sr
sc = rtems_semaphore_obtain(
43966: 42a7 clrl %sp@-
43968: 42a7 clrl %sp@-
4396a: 2f2a 008c movel %a2@(140),%sp@-
4396e: 4e93 jsr %a3@
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
43970: 4fef 000c lea %sp@(12),%sp
43974: 4a80 tstl %d0
43976: 6708 beqs 43980 <drainOutput.part.0+0x44> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
43978: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4397a: 4eb9 0004 60a4 jsr 460a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
43980: 2202 movel %d2,%d1
43982: 40c0 movew %sr,%d0
43984: 8280 orl %d0,%d1
43986: 46c1 movew %d1,%sr
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
43988: 206a 0084 moveal %a2@(132),%a0
4398c: 222a 0080 movel %a2@(128),%d1
43990: b288 cmpl %a0,%d1
43992: 66ca bnes 4395e <drainOutput.part.0+0x22>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
43994: 46c0 movew %d0,%sr
}
}
43996: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
4399c: 4e5e unlk %fp <== NOT EXECUTED
00044460 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
44460: 4e56 fff0 linkw %fp,#-16
44464: 48d7 040c moveml %d2-%d3/%a2,%sp@
44468: 246e 000c moveal %fp@(12),%a2
if ((tty->termios.c_lflag & ECHOCTL) &&
4446c: 202a 003c movel %a2@(60),%d0
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
44470: 242e 0008 movel %fp@(8),%d2
if ((tty->termios.c_lflag & ECHOCTL) &&
44474: 0280 0000 0200 andil #512,%d0
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
4447a: 1202 moveb %d2,%d1
if ((tty->termios.c_lflag & ECHOCTL) &&
4447c: 4a80 tstl %d0
4447e: 674e beqs 444ce <echo+0x6e> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
44480: 4280 clrl %d0
44482: 1002 moveb %d2,%d0
44484: 2079 0005 d4e4 moveal 5d4e4 <__ctype_ptr__>,%a0
4448a: 1630 0801 moveb %a0@(00000001,%d0:l),%d3
4448e: 49c3 extbl %d3
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
44490: 0803 0005 btst #5,%d3
44494: 6738 beqs 444ce <echo+0x6e>
iscntrl(c) && (c != '\t') && (c != '\n')) {
44496: 7609 moveq #9,%d3
44498: b680 cmpl %d0,%d3
4449a: 6732 beqs 444ce <echo+0x6e>
4449c: 163c 000a moveb #10,%d3
444a0: b680 cmpl %d0,%d3
444a2: 672a beqs 444ce <echo+0x6e>
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
444a4: 2f0a movel %a2,%sp@-
444a6: 4878 0002 pea 2 <DOUBLE_FLOAT>
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
444aa: 163c 0040 moveb #64,%d3
rtems_termios_puts (echobuf, 2, tty);
444ae: 486e fffe pea %fp@(-2)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
444b2: 705e moveq #94,%d0
echobuf[1] = c ^ 0x40;
444b4: b782 eorl %d3,%d2
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
444b6: 1d40 fffe moveb %d0,%fp@(-2)
echobuf[1] = c ^ 0x40;
444ba: 1d42 ffff moveb %d2,%fp@(-1)
rtems_termios_puts (echobuf, 2, tty);
444be: 4eb9 0004 4230 jsr 44230 <rtems_termios_puts>
tty->column += 2;
444c4: 4fef 000c lea %sp@(12),%sp
444c8: 54aa 0028 addql #2,%a2@(40)
444cc: 6010 bras 444de <echo+0x7e>
} else {
oproc (c, tty);
444ce: 2f0a movel %a2,%sp@-
444d0: 0281 0000 00ff andil #255,%d1
444d6: 2f01 movel %d1,%sp@-
444d8: 4eba fe44 jsr %pc@(4431e <oproc>)
444dc: 508f addql #8,%sp
}
}
444de: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
444e4: 4e5e unlk %fp <== NOT EXECUTED
000437d2 <endgrent>:
void endgrent(void)
{
437d2: 4e56 0000 linkw %fp,#0
if (group_fp != NULL)
437d6: 2039 0005 fb00 movel 5fb00 <group_fp>,%d0
437dc: 670a beqs 437e8 <endgrent+0x16> <== NEVER TAKEN
fclose(group_fp);
437de: 2f00 movel %d0,%sp@-
437e0: 4eb9 0004 da30 jsr 4da30 <fclose>
437e6: 588f addql #4,%sp
}
437e8: 4e5e unlk %fp <== NOT EXECUTED
0004368c <endpwent>:
void endpwent(void)
{
4368c: 4e56 0000 linkw %fp,#0
if (passwd_fp != NULL)
43690: 2039 0005 fa26 movel 5fa26 <passwd_fp>,%d0
43696: 670a beqs 436a2 <endpwent+0x16> <== NEVER TAKEN
fclose(passwd_fp);
43698: 2f00 movel %d0,%sp@-
4369a: 4eb9 0004 da30 jsr 4da30 <fclose>
436a0: 588f addql #4,%sp
}
436a2: 4e5e unlk %fp <== NOT EXECUTED
000444e8 <erase>:
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
444e8: 4e56 ffe4 linkw %fp,#-28
444ec: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@
444f0: 246e 0008 moveal %fp@(8),%a2
444f4: 262e 000c movel %fp@(12),%d3
if (tty->ccount == 0)
444f8: 4aaa 0020 tstl %a2@(32)
444fc: 6700 0172 beqw 44670 <erase+0x188>
return;
if (lineFlag) {
44500: 4a83 tstl %d3
44502: 6700 015c beqw 44660 <erase+0x178>
if (!(tty->termios.c_lflag & ECHO)) {
44506: 202a 003c movel %a2@(60),%d0
4450a: 44c0 movew %d0,%ccr
4450c: 6b08 bmis 44516 <erase+0x2e> <== ALWAYS TAKEN
tty->ccount = 0;
4450e: 42aa 0020 clrl %a2@(32) <== NOT EXECUTED
return;
44512: 6000 015c braw 44670 <erase+0x188> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
44516: 0800 0004 btst #4,%d0
4451a: 6600 0144 bnew 44660 <erase+0x178>
tty->ccount = 0;
4451e: 42aa 0020 clrl %a2@(32) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
44522: 4280 clrl %d0 <== NOT EXECUTED
44524: 2f0a movel %a2,%sp@- <== NOT EXECUTED
44526: 102a 0044 moveb %a2@(68),%d0 <== NOT EXECUTED
4452a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4452c: 4eba ff32 jsr %pc@(44460 <echo>) <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
44530: 508f addql #8,%sp <== NOT EXECUTED
44532: 7020 moveq #32,%d0 <== NOT EXECUTED
44534: c0aa 003c andl %a2@(60),%d0 <== NOT EXECUTED
44538: 6700 0136 beqw 44670 <erase+0x188> <== NOT EXECUTED
echo ('\n', tty);
4453c: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED
44540: 700a moveq #10,%d0 <== NOT EXECUTED
44542: 602c bras 44570 <erase+0x88> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
44544: 5388 subql #1,%a0
44546: 286a 001c moveal %a2@(28),%a4
if (tty->termios.c_lflag & ECHO) {
4454a: 202a 003c movel %a2@(60),%d0
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4454e: 2548 0020 movel %a0,%a2@(32)
44552: 1434 8800 moveb %a4@(00000000,%a0:l),%d2
if (tty->termios.c_lflag & ECHO) {
44556: 44c0 movew %d0,%ccr
44558: 6a00 0100 bplw 4465a <erase+0x172>
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
4455c: 4a83 tstl %d3
4455e: 6620 bnes 44580 <erase+0x98>
44560: 0800 0004 btst #4,%d0
44564: 661a bnes 44580 <erase+0x98> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
44566: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED
4456a: 4280 clrl %d0 <== NOT EXECUTED
4456c: 102a 0043 moveb %a2@(67),%d0 <== NOT EXECUTED
44570: 2d40 0008 movel %d0,%fp@(8) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
44574: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4 <== NOT EXECUTED
4457a: 4e5e unlk %fp <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
4457c: 6000 fee2 braw 44460 <echo> <== NOT EXECUTED
44580: 2279 0005 d4e4 moveal 5d4e4 <__ctype_ptr__>,%a1
} else if (c == '\t') {
44586: 7209 moveq #9,%d1
44588: 0282 0000 00ff andil #255,%d2
4458e: b282 cmpl %d2,%d1
44590: 665a bnes 445ec <erase+0x104>
int col = tty->read_start_column;
44592: 242a 002c movel %a2@(44),%d2
int i = 0;
44596: 4201 clrb %d1
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
44598: 0280 0000 0200 andil #512,%d0
4459e: 6028 bras 445c8 <erase+0xe0>
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
445a0: 4284 clrl %d4
445a2: 181c moveb %a4@+,%d4
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
445a4: 5281 addql #1,%d1
if (c == '\t') {
445a6: 7a09 moveq #9,%d5
445a8: ba84 cmpl %d4,%d5
445aa: 6606 bnes 445b2 <erase+0xca>
col = (col | 7) + 1;
445ac: 7807 moveq #7,%d4
445ae: 8484 orl %d4,%d2
445b0: 6014 bras 445c6 <erase+0xde>
} else if (iscntrl (c)) {
445b2: 1831 4801 moveb %a1@(00000001,%d4:l),%d4
445b6: 49c4 extbl %d4
445b8: 0804 0005 btst #5,%d4
445bc: 6708 beqs 445c6 <erase+0xde> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
445be: 4a80 tstl %d0 <== NOT EXECUTED
445c0: 6706 beqs 445c8 <erase+0xe0> <== NOT EXECUTED
col += 2;
445c2: 5482 addql #2,%d2 <== NOT EXECUTED
445c4: 6002 bras 445c8 <erase+0xe0> <== NOT EXECUTED
} else {
col++;
445c6: 5282 addql #1,%d2
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
445c8: b1c1 cmpal %d1,%a0
445ca: 66d4 bnes 445a0 <erase+0xb8>
445cc: 6016 bras 445e4 <erase+0xfc>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
445ce: 2f0a movel %a2,%sp@-
445d0: 4878 0001 pea 1 <ADD>
445d4: 4879 0005 c32f pea 5c32f <rtems_filesystem_default_pathconf+0xb3>
445da: 4e93 jsr %a3@
tty->column--;
445dc: 4fef 000c lea %sp@(12),%sp
445e0: 53aa 0028 subql #1,%a2@(40)
}
/*
* Back up over the tab
*/
while (tty->column > col) {
445e4: b4aa 0028 cmpl %a2@(40),%d2
445e8: 6de4 blts 445ce <erase+0xe6>
445ea: 606e bras 4465a <erase+0x172>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
445ec: 5282 addql #1,%d2
445ee: 1231 2800 moveb %a1@(00000000,%d2:l),%d1
445f2: 49c1 extbl %d1
445f4: 0801 0005 btst #5,%d1
445f8: 6724 beqs 4461e <erase+0x136> <== ALWAYS TAKEN
445fa: 0800 0009 btst #9,%d0 <== NOT EXECUTED
445fe: 671e beqs 4461e <erase+0x136> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
44600: 2f0a movel %a2,%sp@- <== NOT EXECUTED
44602: 4878 0003 pea 3 <DIVIDE> <== NOT EXECUTED
44606: 4879 0005 c32d pea 5c32d <rtems_filesystem_default_pathconf+0xb1><== NOT EXECUTED
4460c: 4e93 jsr %a3@ <== NOT EXECUTED
if (tty->column)
4460e: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED
44612: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44616: 6706 beqs 4461e <erase+0x136> <== NOT EXECUTED
tty->column--;
44618: 5380 subql #1,%d0 <== NOT EXECUTED
4461a: 2540 0028 movel %d0,%a2@(40) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
4461e: 2079 0005 d4e4 moveal 5d4e4 <__ctype_ptr__>,%a0
44624: 1030 2800 moveb %a0@(00000000,%d2:l),%d0
44628: 49c0 extbl %d0
4462a: 0800 0005 btst #5,%d0
4462e: 670c beqs 4463c <erase+0x154> <== ALWAYS TAKEN
44630: 202a 003c movel %a2@(60),%d0 <== NOT EXECUTED
44634: 0280 0000 0200 andil #512,%d0 <== NOT EXECUTED
4463a: 671e beqs 4465a <erase+0x172> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
4463c: 2f0a movel %a2,%sp@-
4463e: 4878 0003 pea 3 <DIVIDE>
44642: 4879 0005 c32d pea 5c32d <rtems_filesystem_default_pathconf+0xb1>
44648: 4e93 jsr %a3@
if (tty->column)
4464a: 202a 0028 movel %a2@(40),%d0
4464e: 4fef 000c lea %sp@(12),%sp
44652: 6706 beqs 4465a <erase+0x172> <== NEVER TAKEN
tty->column--;
44654: 5380 subql #1,%d0
44656: 2540 0028 movel %d0,%a2@(40)
}
}
}
if (!lineFlag)
4465a: 4a83 tstl %d3
4465c: 6608 bnes 44666 <erase+0x17e>
4465e: 6010 bras 44670 <erase+0x188>
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
44660: 47f9 0004 4230 lea 44230 <rtems_termios_puts>,%a3
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
44666: 206a 0020 moveal %a2@(32),%a0
4466a: 4a88 tstl %a0
4466c: 6600 fed6 bnew 44544 <erase+0x5c>
}
}
if (!lineFlag)
break;
}
}
44670: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
44676: 4e5e unlk %fp <== NOT EXECUTED
000505a0 <fat_buf_access>:
#include "fat_fat_operations.h"
int
fat_buf_access(fat_fs_info_t *fs_info, uint32_t blk, int op_type,
rtems_bdbuf_buffer **buf)
{
505a0: 4e56 ffdc linkw %fp,#-36
505a4: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
505a8: 246e 0008 moveal %fp@(8),%a2
505ac: 242e 000c movel %fp@(12),%d2
505b0: 282e 0010 movel %fp@(16),%d4
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
505b4: 4a2a 0077 tstb %a2@(119)
505b8: 664e bnes 50608 <fat_buf_access+0x68>
505ba: 200a movel %a2,%d0
505bc: 0680 0000 0078 addil #120,%d0
{
if (op_type == FAT_OP_TYPE_READ)
505c2: 7201 moveq #1,%d1
505c4: b284 cmpl %d4,%d1
505c6: 6614 bnes 505dc <fat_buf_access+0x3c>
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
505c8: 2f00 movel %d0,%sp@-
505ca: 2f02 movel %d2,%sp@-
505cc: 2f2a 004e movel %a2@(78),%sp@-
505d0: 2f2a 004a movel %a2@(74),%sp@-
505d4: 4eb9 0004 efec jsr 4efec <rtems_bdbuf_read>
505da: 6012 bras 505ee <fat_buf_access+0x4e>
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
505dc: 2f00 movel %d0,%sp@-
505de: 2f02 movel %d2,%sp@-
505e0: 2f2a 004e movel %a2@(78),%sp@-
505e4: 2f2a 004a movel %a2@(74),%sp@-
505e8: 4eb9 0004 ef28 jsr 4ef28 <rtems_bdbuf_get>
505ee: 4fef 0010 lea %sp@(16),%sp
if (sc != RTEMS_SUCCESSFUL)
505f2: 4a80 tstl %d0
505f4: 6600 015c bnew 50752 <fat_buf_access+0x1b2>
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
505f8: 2542 0072 movel %d2,%a2@(114)
fs_info->c.modified = 0;
505fc: 4200 clrb %d0
fs_info->c.state = FAT_CACHE_ACTUAL;
505fe: 7201 moveq #1,%d1
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
50600: 1540 0076 moveb %d0,%a2@(118)
fs_info->c.state = FAT_CACHE_ACTUAL;
50604: 1541 0077 moveb %d1,%a2@(119)
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
50608: 4281 clrl %d1
5060a: 322a 0014 movew %a2@(20),%d1
5060e: 202a 0072 movel %a2@(114),%d0
50612: b280 cmpl %d0,%d1
50614: 620c bhis 50622 <fat_buf_access+0x82> <== NEVER TAKEN
50616: b0aa 001a cmpl %a2@(26),%d0
5061a: 55c3 scs %d3
5061c: 49c3 extbl %d3
5061e: 4483 negl %d3
50620: 6002 bras 50624 <fat_buf_access+0x84>
50622: 4283 clrl %d3 <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.blk_num != blk)
50624: b480 cmpl %d0,%d2
50626: 6700 0144 beqw 5076c <fat_buf_access+0x1cc>
{
if (fs_info->c.modified)
5062a: 4a2a 0076 tstb %a2@(118)
5062e: 6700 00d0 beqw 50700 <fat_buf_access+0x160>
{
if (sec_of_fat && !fs_info->vol.mirror)
50632: 4a03 tstb %d3
50634: 6722 beqs 50658 <fat_buf_access+0xb8> <== ALWAYS TAKEN
50636: 4a2a 0042 tstb %a2@(66) <== NOT EXECUTED
5063a: 661c bnes 50658 <fat_buf_access+0xb8> <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
5063c: 4280 clrl %d0 <== NOT EXECUTED
5063e: 206a 0078 moveal %a2@(120),%a0 <== NOT EXECUTED
50642: 3012 movew %a2@,%d0 <== NOT EXECUTED
50644: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50646: 2f28 001e movel %a0@(30),%sp@- <== NOT EXECUTED
5064a: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
5064e: 4eb9 0005 950c jsr 5950c <memcpy> <== NOT EXECUTED
50654: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
50658: 2f2a 0078 movel %a2@(120),%sp@-
5065c: 47f9 0004 f2b0 lea 4f2b0 <rtems_bdbuf_release_modified>,%a3
50662: 4e93 jsr %a3@
fs_info->c.state = FAT_CACHE_EMPTY;
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
50664: 588f addql #4,%sp
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
50666: 4201 clrb %d1
50668: 1541 0077 moveb %d1,%a2@(119)
fs_info->c.modified = 0;
5066c: 1541 0076 moveb %d1,%a2@(118)
if (sc != RTEMS_SUCCESSFUL)
50670: 4a80 tstl %d0
50672: 6600 00de bnew 50752 <fat_buf_access+0x1b2>
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
50676: 4a03 tstb %d3
50678: 6700 009c beqw 50716 <fat_buf_access+0x176>
5067c: 4a2a 0042 tstb %a2@(66) <== NOT EXECUTED
50680: 675c beqs 506de <fat_buf_access+0x13e> <== NOT EXECUTED
50682: 6000 0092 braw 50716 <fat_buf_access+0x176> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
50686: 2f05 movel %d5,%sp@- <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
50688: 41ea 0016 lea %a2@(22),%a0 <== NOT EXECUTED
5068c: 4c10 0800 mulsl %a0@,%d0 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
50690: d0aa 0072 addl %a2@(114),%d0 <== NOT EXECUTED
50694: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50696: 2f2a 004e movel %a2@(78),%sp@- <== NOT EXECUTED
5069a: 2f2a 004a movel %a2@(74),%sp@- <== NOT EXECUTED
5069e: 4e95 jsr %a5@ <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
506a0: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
506a4: 4a80 tstl %d0 <== NOT EXECUTED
506a6: 6622 bnes 506ca <fat_buf_access+0x12a> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
506a8: 4280 clrl %d0 <== NOT EXECUTED
506aa: 3012 movew %a2@,%d0 <== NOT EXECUTED
506ac: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
506b0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
506b2: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
506b6: 2f28 001e movel %a0@(30),%sp@- <== NOT EXECUTED
506ba: 4e94 jsr %a4@ <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
506bc: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
506c0: 4e93 jsr %a3@ <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
506c2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
506c6: 4a80 tstl %d0 <== NOT EXECUTED
506c8: 6710 beqs 506da <fat_buf_access+0x13a> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
506ca: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
506d0: 720c moveq #12,%d1 <== NOT EXECUTED
506d2: 2040 moveal %d0,%a0 <== NOT EXECUTED
506d4: 2081 movel %d1,%a0@ <== NOT EXECUTED
506d6: 6000 0086 braw 5075e <fat_buf_access+0x1be> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
506da: 5283 addql #1,%d3 <== NOT EXECUTED
506dc: 6012 bras 506f0 <fat_buf_access+0x150> <== NOT EXECUTED
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
506de: 2a0e movel %fp,%d5 <== NOT EXECUTED
506e0: 5985 subql #4,%d5 <== NOT EXECUTED
506e2: 4bf9 0004 ef28 lea 4ef28 <rtems_bdbuf_get>,%a5 <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
506e8: 49f9 0005 950c lea 5950c <memcpy>,%a4 <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
506ee: 7601 moveq #1,%d3 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
506f0: 4281 clrl %d1 <== NOT EXECUTED
506f2: 122a 0009 moveb %a2@(9),%d1 <== NOT EXECUTED
506f6: 4280 clrl %d0 <== NOT EXECUTED
506f8: 1003 moveb %d3,%d0 <== NOT EXECUTED
506fa: b280 cmpl %d0,%d1 <== NOT EXECUTED
506fc: 6288 bhis 50686 <fat_buf_access+0xe6> <== NOT EXECUTED
506fe: 6016 bras 50716 <fat_buf_access+0x176> <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
50700: 2f2a 0078 movel %a2@(120),%sp@-
50704: 4eb9 0004 f206 jsr 4f206 <rtems_bdbuf_release>
fs_info->c.state = FAT_CACHE_EMPTY;
if (sc != RTEMS_SUCCESSFUL)
5070a: 588f addql #4,%sp
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
5070c: 4201 clrb %d1
5070e: 1541 0077 moveb %d1,%a2@(119)
if (sc != RTEMS_SUCCESSFUL)
50712: 4a80 tstl %d0
50714: 663c bnes 50752 <fat_buf_access+0x1b2> <== NEVER TAKEN
50716: 200a movel %a2,%d0
50718: 0680 0000 0078 addil #120,%d0
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
5071e: 7201 moveq #1,%d1
50720: b284 cmpl %d4,%d1
50722: 6614 bnes 50738 <fat_buf_access+0x198>
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
50724: 2f00 movel %d0,%sp@-
50726: 2f02 movel %d2,%sp@-
50728: 2f2a 004e movel %a2@(78),%sp@-
5072c: 2f2a 004a movel %a2@(74),%sp@-
50730: 4eb9 0004 efec jsr 4efec <rtems_bdbuf_read>
50736: 6012 bras 5074a <fat_buf_access+0x1aa>
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
50738: 2f00 movel %d0,%sp@-
5073a: 2f02 movel %d2,%sp@-
5073c: 2f2a 004e movel %a2@(78),%sp@-
50740: 2f2a 004a movel %a2@(74),%sp@-
50744: 4eb9 0004 ef28 jsr 4ef28 <rtems_bdbuf_get>
5074a: 4fef 0010 lea %sp@(16),%sp
if (sc != RTEMS_SUCCESSFUL)
5074e: 4a80 tstl %d0
50750: 6710 beqs 50762 <fat_buf_access+0x1c2> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
50752: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50758: 2040 moveal %d0,%a0 <== NOT EXECUTED
5075a: 7005 moveq #5,%d0 <== NOT EXECUTED
5075c: 2080 movel %d0,%a0@ <== NOT EXECUTED
5075e: 70ff moveq #-1,%d0 <== NOT EXECUTED
50760: 6014 bras 50776 <fat_buf_access+0x1d6> <== NOT EXECUTED
fs_info->c.blk_num = blk;
50762: 2542 0072 movel %d2,%a2@(114)
fs_info->c.state = FAT_CACHE_ACTUAL;
50766: 7001 moveq #1,%d0
50768: 1540 0077 moveb %d0,%a2@(119)
}
*buf = fs_info->c.buf;
5076c: 206e 0014 moveal %fp@(20),%a0
return RC_OK;
50770: 4280 clrl %d0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
*buf = fs_info->c.buf;
50772: 20aa 0078 movel %a2@(120),%a0@
return RC_OK;
}
50776: 4cee 3c3c ffdc moveml %fp@(-36),%d2-%d5/%a2-%a5
5077c: 4e5e unlk %fp <== NOT EXECUTED
00050780 <fat_buf_release>:
int
fat_buf_release(fat_fs_info_t *fs_info)
{
50780: 4e56 ffe4 linkw %fp,#-28
50784: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
50788: 246e 0008 moveal %fp@(8),%a2
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
5078c: 4a2a 0077 tstb %a2@(119)
50790: 6700 0114 beqw 508a6 <fat_buf_release+0x126>
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
50794: 4281 clrl %d1
50796: 322a 0014 movew %a2@(20),%d1
5079a: 202a 0072 movel %a2@(114),%d0
5079e: b280 cmpl %d0,%d1
507a0: 620c bhis 507ae <fat_buf_release+0x2e> <== NEVER TAKEN
*buf = fs_info->c.buf;
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
507a2: b0aa 001a cmpl %a2@(26),%d0
507a6: 55c2 scs %d2
507a8: 49c2 extbl %d2
507aa: 4482 negl %d2
507ac: 6002 bras 507b0 <fat_buf_release+0x30>
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
507ae: 4282 clrl %d2 <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
507b0: 4a2a 0076 tstb %a2@(118)
507b4: 6700 00ca beqw 50880 <fat_buf_release+0x100>
{
if (sec_of_fat && !fs_info->vol.mirror)
507b8: 4a02 tstb %d2
507ba: 6722 beqs 507de <fat_buf_release+0x5e>
507bc: 4a2a 0042 tstb %a2@(66)
507c0: 661c bnes 507de <fat_buf_release+0x5e> <== NEVER TAKEN
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
507c2: 4280 clrl %d0
507c4: 206a 0078 moveal %a2@(120),%a0
507c8: 3012 movew %a2@,%d0
507ca: 2f00 movel %d0,%sp@-
507cc: 2f28 001e movel %a0@(30),%sp@-
507d0: 2f2a 007c movel %a2@(124),%sp@-
507d4: 4eb9 0005 950c jsr 5950c <memcpy>
507da: 4fef 000c lea %sp@(12),%sp
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
507de: 2f2a 0078 movel %a2@(120),%sp@-
507e2: 47f9 0004 f2b0 lea 4f2b0 <rtems_bdbuf_release_modified>,%a3
507e8: 4e93 jsr %a3@
if (sc != RTEMS_SUCCESSFUL)
507ea: 588f addql #4,%sp
507ec: 4a80 tstl %d0
507ee: 6600 00a0 bnew 50890 <fat_buf_release+0x110>
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
507f2: 4200 clrb %d0
507f4: 1540 0076 moveb %d0,%a2@(118)
if (sec_of_fat && !fs_info->vol.mirror)
507f8: 4a02 tstb %d2
507fa: 6700 00a4 beqw 508a0 <fat_buf_release+0x120>
507fe: 4a2a 0042 tstb %a2@(66)
50802: 675a beqs 5085e <fat_buf_release+0xde> <== ALWAYS TAKEN
50804: 6000 009a braw 508a0 <fat_buf_release+0x120> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
50808: 2f03 movel %d3,%sp@-
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
5080a: 41ea 0016 lea %a2@(22),%a0
5080e: 4c10 0800 mulsl %a0@,%d0
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
50812: d0aa 0072 addl %a2@(114),%d0
50816: 2f00 movel %d0,%sp@-
50818: 2f2a 004e movel %a2@(78),%sp@-
5081c: 2f2a 004a movel %a2@(74),%sp@-
50820: 4e95 jsr %a5@
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
50822: 4fef 0010 lea %sp@(16),%sp
50826: 4a80 tstl %d0
50828: 6622 bnes 5084c <fat_buf_release+0xcc> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
5082a: 4280 clrl %d0
5082c: 3012 movew %a2@,%d0
5082e: 206e fffc moveal %fp@(-4),%a0
50832: 2f00 movel %d0,%sp@-
50834: 2f2a 007c movel %a2@(124),%sp@-
50838: 2f28 001e movel %a0@(30),%sp@-
5083c: 4e94 jsr %a4@
sc = rtems_bdbuf_release_modified(b);
5083e: 2f2e fffc movel %fp@(-4),%sp@-
50842: 4e93 jsr %a3@
if ( sc != RTEMS_SUCCESSFUL)
50844: 4fef 0010 lea %sp@(16),%sp
50848: 4a80 tstl %d0
5084a: 670e beqs 5085a <fat_buf_release+0xda> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
5084c: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50852: 760c moveq #12,%d3 <== NOT EXECUTED
50854: 2040 moveal %d0,%a0 <== NOT EXECUTED
50856: 2083 movel %d3,%a0@ <== NOT EXECUTED
50858: 6042 bras 5089c <fat_buf_release+0x11c> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
5085a: 5282 addql #1,%d2
5085c: 6012 bras 50870 <fat_buf_release+0xf0>
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
5085e: 260e movel %fp,%d3
50860: 5983 subql #4,%d3
50862: 4bf9 0004 ef28 lea 4ef28 <rtems_bdbuf_get>,%a5
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
50868: 49f9 0005 950c lea 5950c <memcpy>,%a4
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
5086e: 7401 moveq #1,%d2
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
50870: 4281 clrl %d1
50872: 122a 0009 moveb %a2@(9),%d1
50876: 4280 clrl %d0
50878: 1002 moveb %d2,%d0
5087a: b280 cmpl %d0,%d1
5087c: 628a bhis 50808 <fat_buf_release+0x88>
5087e: 6020 bras 508a0 <fat_buf_release+0x120>
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
50880: 2f2a 0078 movel %a2@(120),%sp@-
50884: 4eb9 0004 f206 jsr 4f206 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
5088a: 588f addql #4,%sp
5088c: 4a80 tstl %d0
5088e: 6710 beqs 508a0 <fat_buf_release+0x120> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
50890: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50896: 7405 moveq #5,%d2 <== NOT EXECUTED
50898: 2040 moveal %d0,%a0 <== NOT EXECUTED
5089a: 2082 movel %d2,%a0@ <== NOT EXECUTED
5089c: 70ff moveq #-1,%d0 <== NOT EXECUTED
5089e: 6008 bras 508a8 <fat_buf_release+0x128> <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
508a0: 4200 clrb %d0
508a2: 1540 0077 moveb %d0,%a2@(119)
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
return RC_OK;
508a6: 4280 clrl %d0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
return RC_OK;
}
508a8: 4cee 3c0c ffe4 moveml %fp@(-28),%d2-%d3/%a2-%a5
508ae: 4e5e unlk %fp <== NOT EXECUTED
0004fa2c <fat_cluster_num_to_sector_num.isra.0>:
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
}
static inline uint32_t
fat_cluster_num_to_sector_num(
4fa2c: 4e56 0000 linkw %fp,#0
4fa30: 206e 0008 moveal %fp@(8),%a0
4fa34: 202e 000c movel %fp@(12),%d0
4fa38: 2f02 movel %d2,%sp@-
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4fa3a: 4a80 tstl %d0
4fa3c: 6612 bnes 4fa50 <fat_cluster_num_to_sector_num.isra.0+0x24>
4fa3e: 4281 clrl %d1
4fa40: 1228 000a moveb %a0@(10),%d1
4fa44: 7403 moveq #3,%d2
4fa46: c282 andl %d2,%d1
4fa48: 6706 beqs 4fa50 <fat_cluster_num_to_sector_num.isra.0+0x24><== NEVER TAKEN
return fs_info->vol.rdir_loc;
4fa4a: 2028 001a movel %a0@(26),%d0
4fa4e: 600e bras 4fa5e <fat_cluster_num_to_sector_num.isra.0+0x32>
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4fa50: 4281 clrl %d1
4fa52: 1228 0005 moveb %a0@(5),%d1
4fa56: 5580 subql #2,%d0
4fa58: e3a8 lsll %d1,%d0
4fa5a: d0a8 002c addl %a0@(44),%d0
fs_info->vol.data_fsec);
}
4fa5e: 241f movel %sp@+,%d2
4fa60: 4e5e unlk %fp <== NOT EXECUTED
000509ec <fat_cluster_read>:
fat_cluster_read(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
509ec: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
509f0: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
509f4: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
509f8: 4282 clrl %d2 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
509fa: 246b 0034 moveal %a3@(52),%a2 <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
509fe: 2f2e 000c movel %fp@(12),%sp@- <== NOT EXECUTED
50a02: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50a04: 4eba fb62 jsr %pc@(50568 <fat_cluster_num_to_sector_num.isra.0>)<== NOT EXECUTED
return _fat_block_read(mt_entry, fsec, 0,
50a08: 588f addql #4,%sp <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
50a0a: 4281 clrl %d1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
50a0c: 2eae 0010 movel %fp@(16),%sp@ <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
50a10: 122a 0004 moveb %a2@(4),%d1 <== NOT EXECUTED
50a14: 142a 0002 moveb %a2@(2),%d2 <== NOT EXECUTED
50a18: e5a9 lsll %d2,%d1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
50a1a: 2f01 movel %d1,%sp@- <== NOT EXECUTED
50a1c: 42a7 clrl %sp@- <== NOT EXECUTED
50a1e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50a20: 2f0b movel %a3,%sp@- <== NOT EXECUTED
50a22: 4eb9 0005 08b2 jsr 508b2 <_fat_block_read> <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
50a28: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
50a2e: 4e5e unlk %fp <== NOT EXECUTED
00050c16 <fat_fat32_update_fsinfo_sector>:
fat_fat32_update_fsinfo_sector(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t free_count,
uint32_t next_free
)
{
50c16: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED
50c1a: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED
50c1e: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
50c22: 47fa f90c lea %pc@(50530 <m68k_swap_u32>),%a3 <== NOT EXECUTED
uint32_t free_count,
uint32_t next_free
)
{
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
50c26: 286a 0034 moveal %a2@(52),%a4 <== NOT EXECUTED
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
50c2a: 2f2e 000c movel %fp@(12),%sp@- <== NOT EXECUTED
50c2e: 4e93 jsr %a3@ <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
50c30: 2eae 0010 movel %fp@(16),%sp@ <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
50c34: 2d40 fff8 movel %d0,%fp@(-8) <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
50c38: 4e93 jsr %a3@ <== NOT EXECUTED
50c3a: 588f addql #4,%sp <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
50c3c: 47f9 0005 093a lea 5093a <_fat_block_write>,%a3 <== NOT EXECUTED
50c42: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
50c46: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
50c4a: 4878 01e8 pea 1e8 <DBL_MANT_DIG+0x1b3> <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
50c4e: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
50c52: 4280 clrl %d0 <== NOT EXECUTED
50c54: 302c 0038 movew %a4@(56),%d0 <== NOT EXECUTED
50c58: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50c5a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50c5c: 4e93 jsr %a3@ <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
50c5e: 486e fffc pea %fp@(-4) <== NOT EXECUTED
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
ret1 = _fat_block_write(mt_entry,
50c62: 2400 movel %d0,%d2 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
50c64: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
50c68: 4280 clrl %d0 <== NOT EXECUTED
50c6a: 4878 01ec pea 1ec <DBL_MANT_DIG+0x1b7> <== NOT EXECUTED
50c6e: 302c 0038 movew %a4@(56),%d0 <== NOT EXECUTED
50c72: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50c74: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50c76: 4e93 jsr %a3@ <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,
4,
(char *)(&le_next_free));
if ( (ret1 < 0) || (ret2 < 0) )
50c78: 4fef 0028 lea %sp@(40),%sp <== NOT EXECUTED
50c7c: 4a82 tstl %d2 <== NOT EXECUTED
50c7e: 6d08 blts 50c88 <fat_fat32_update_fsinfo_sector+0x72><== NOT EXECUTED
return -1;
50c80: 4a80 tstl %d0 <== NOT EXECUTED
50c82: 5dc0 slt %d0 <== NOT EXECUTED
50c84: 49c0 extbl %d0 <== NOT EXECUTED
50c86: 6002 bras 50c8a <fat_fat32_update_fsinfo_sector+0x74><== NOT EXECUTED
50c88: 70ff moveq #-1,%d0 <== NOT EXECUTED
return RC_OK;
}
50c8a: 4cee 1c04 ffe8 moveml %fp@(-24),%d2/%a2-%a4 <== NOT EXECUTED
50c90: 4e5e unlk %fp <== NOT EXECUTED
0004feb6 <fat_file_close>:
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
4feb6: 7201 moveq #1,%d1
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
4feb8: 4e56 fff4 linkw %fp,#-12
4febc: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4fec0: 266e 0008 moveal %fp@(8),%a3
4fec4: 246e 000c moveal %fp@(12),%a2
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fec8: 242b 0034 movel %a3@(52),%d2
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
4fecc: 202a 0008 movel %a2@(8),%d0
4fed0: b280 cmpl %d0,%d1
4fed2: 640c bccs 4fee0 <fat_file_close+0x2a>
{
fat_fd->links_num--;
4fed4: 5380 subql #1,%d0
4fed6: 2540 0008 movel %d0,%a2@(8)
return rc;
4feda: 4280 clrl %d0
4fedc: 6000 0094 braw 4ff72 <fat_file_close+0xbc>
}
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
4fee0: 4280 clrl %d0
4fee2: 102a 0030 moveb %a2@(48),%d0
4fee6: 0800 0000 btst #0,%d0
4feea: 674a beqs 4ff36 <fat_file_close+0x80> <== ALWAYS TAKEN
{
rc = fat_file_truncate(mt_entry, fat_fd, 0);
4feec: 42a7 clrl %sp@- <== NOT EXECUTED
4feee: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4fef0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fef2: 4eb9 0004 fdcc jsr 4fdcc <fat_file_truncate> <== NOT EXECUTED
if ( rc != RC_OK )
4fef8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4fefc: 4a80 tstl %d0 <== NOT EXECUTED
4fefe: 6672 bnes 4ff72 <fat_file_close+0xbc> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4ff00: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ff02: 4eb9 0004 9a3c jsr 49a3c <_Chain_Extract> <== NOT EXECUTED
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )
4ff08: 2f2a 000c movel %a2@(12),%sp@- <== NOT EXECUTED
4ff0c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ff0e: 4eb9 0005 0bfa jsr 50bfa <fat_ino_is_unique> <== NOT EXECUTED
4ff14: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4ff18: 4a00 tstb %d0 <== NOT EXECUTED
4ff1a: 670e beqs 4ff2a <fat_file_close+0x74> <== NOT EXECUTED
fat_free_unique_ino(mt_entry, fat_fd->ino);
4ff1c: 2f2a 000c movel %a2@(12),%sp@- <== NOT EXECUTED
4ff20: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ff22: 4eb9 0005 0bc8 jsr 50bc8 <fat_free_unique_ino> <== NOT EXECUTED
4ff28: 508f addql #8,%sp <== NOT EXECUTED
free(fat_fd);
4ff2a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ff2c: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
4ff32: 588f addql #4,%sp <== NOT EXECUTED
4ff34: 602a bras 4ff60 <fat_file_close+0xaa> <== NOT EXECUTED
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
4ff36: 2f2a 000c movel %a2@(12),%sp@-
4ff3a: 2f0b movel %a3,%sp@-
4ff3c: 4eb9 0005 0bfa jsr 50bfa <fat_ino_is_unique>
4ff42: 508f addql #8,%sp
4ff44: 4a00 tstb %d0
4ff46: 6706 beqs 4ff4e <fat_file_close+0x98> <== ALWAYS TAKEN
{
fat_fd->links_num = 0;
4ff48: 42aa 0008 clrl %a2@(8) <== NOT EXECUTED
4ff4c: 6012 bras 4ff60 <fat_file_close+0xaa> <== NOT EXECUTED
4ff4e: 2f0a movel %a2,%sp@-
4ff50: 4eb9 0004 9a3c jsr 49a3c <_Chain_Extract>
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
4ff56: 2f0a movel %a2,%sp@-
4ff58: 4eb9 0004 54d0 jsr 454d0 <free>
4ff5e: 508f addql #8,%sp
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
4ff60: 2d42 0008 movel %d2,%fp@(8)
return rc;
}
4ff64: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
4ff6a: 4e5e unlk %fp
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
4ff6c: 4ef9 0005 0780 jmp 50780 <fat_buf_release>
return rc;
}
4ff72: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
4ff78: 4e5e unlk %fp <== NOT EXECUTED
000503b8 <fat_file_datasync>:
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
503b8: 4e56 ffcc linkw %fp,#-52 <== NOT EXECUTED
503bc: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
503c0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
503c4: 286e 0008 moveal %fp@(8),%a4 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
503c8: 2d68 001c fff8 movel %a0@(28),%fp@(-8) <== NOT EXECUTED
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
503ce: 246c 0034 moveal %a4@(52),%a2 <== NOT EXECUTED
uint32_t cur_cln = fat_fd->cln;
rtems_bdbuf_buffer *block = NULL;
503d2: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
503d6: 4aa8 0018 tstl %a0@(24) <== NOT EXECUTED
503da: 6700 00b8 beqw 50494 <fat_file_datasync+0xdc> <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
503de: 2f0a movel %a2,%sp@- <== NOT EXECUTED
503e0: 4eb9 0005 0780 jsr 50780 <fat_buf_release> <== NOT EXECUTED
if (rc != RC_OK)
503e6: 588f addql #4,%sp <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
503e8: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
503ea: 6774 beqs 50460 <fat_file_datasync+0xa8> <== NOT EXECUTED
503ec: 6000 00ac braw 5049a <fat_file_datasync+0xe2> <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
503f0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
503f2: 2f2c 0034 movel %a4@(52),%sp@- <== NOT EXECUTED
503f6: 2047 moveal %d7,%a0 <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
503f8: 97cb subal %a3,%a3 <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
503fa: 4e90 jsr %a0@ <== NOT EXECUTED
503fc: 508f addql #8,%sp <== NOT EXECUTED
503fe: 2d40 fff4 movel %d0,%fp@(-12) <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
50402: 603e bras 50442 <fat_file_datasync+0x8a> <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
50404: 206e fff4 moveal %fp@(-12),%a0 <== NOT EXECUTED
50408: 2f06 movel %d6,%sp@- <== NOT EXECUTED
5040a: 4873 8800 pea %a3@(00000000,%a0:l) <== NOT EXECUTED
5040e: 2045 moveal %d5,%a0 <== NOT EXECUTED
50410: 2f2a 004e movel %a2@(78),%sp@- <== NOT EXECUTED
50414: 2f2a 004a movel %a2@(74),%sp@- <== NOT EXECUTED
50418: 4e90 jsr %a0@ <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
5041a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5041e: 4a80 tstl %d0 <== NOT EXECUTED
50420: 660e bnes 50430 <fat_file_datasync+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
50422: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
50426: 2044 moveal %d4,%a0 <== NOT EXECUTED
50428: 4e90 jsr %a0@ <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
5042a: 588f addql #4,%sp <== NOT EXECUTED
5042c: 4a80 tstl %d0 <== NOT EXECUTED
5042e: 6710 beqs 50440 <fat_file_datasync+0x88> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
50430: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50436: 7605 moveq #5,%d3 <== NOT EXECUTED
50438: 74ff moveq #-1,%d2 <== NOT EXECUTED
5043a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5043c: 2083 movel %d3,%a0@ <== NOT EXECUTED
5043e: 605a bras 5049a <fat_file_datasync+0xe2> <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
50440: 528b addql #1,%a3 <== NOT EXECUTED
50442: 4280 clrl %d0 <== NOT EXECUTED
50444: 102a 0004 moveb %a2@(4),%d0 <== NOT EXECUTED
50448: b08b cmpl %a3,%d0 <== NOT EXECUTED
5044a: 62b8 bhis 50404 <fat_file_datasync+0x4c> <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
5044c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5044e: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
50452: 2f0c movel %a4,%sp@- <== NOT EXECUTED
50454: 4e95 jsr %a5@ <== NOT EXECUTED
if ( rc != RC_OK )
50456: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5045a: 4a80 tstl %d0 <== NOT EXECUTED
5045c: 6722 beqs 50480 <fat_file_datasync+0xc8> <== NOT EXECUTED
5045e: 6038 bras 50498 <fat_file_datasync+0xe0> <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
50460: 2c0e movel %fp,%d6 <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50462: 260e movel %fp,%d3 <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
50464: 2e3c 0004 fa2c movel #326188,%d7 <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
5046a: 5986 subql #4,%d6 <== NOT EXECUTED
5046c: 2a3c 0004 efec movel #323564,%d5 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
50472: 283c 0004 f31e movel #324382,%d4 <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50478: 5183 subql #8,%d3 <== NOT EXECUTED
5047a: 4bf9 0005 708c lea 5708c <fat_get_fat_cluster>,%a5 <== NOT EXECUTED
rc = fat_buf_release(fs_info);
if (rc != RC_OK)
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
50480: 202e fff8 movel %fp@(-8),%d0 <== NOT EXECUTED
50484: 2200 movel %d0,%d1 <== NOT EXECUTED
50486: c2aa 000c andl %a2@(12),%d1 <== NOT EXECUTED
5048a: b2aa 0010 cmpl %a2@(16),%d1 <== NOT EXECUTED
5048e: 6500 ff60 bcsw 503f0 <fat_file_datasync+0x38> <== NOT EXECUTED
50492: 6006 bras 5049a <fat_file_datasync+0xe2> <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
return RC_OK;
50494: 4282 clrl %d2 <== NOT EXECUTED
50496: 6002 bras 5049a <fat_file_datasync+0xe2> <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50498: 2400 movel %d0,%d2 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
return rc;
}
5049a: 2002 movel %d2,%d0 <== NOT EXECUTED
5049c: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5 <== NOT EXECUTED
504a2: 4e5e unlk %fp <== NOT EXECUTED
00050014 <fat_file_extend>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
50014: 4e56 ffcc linkw %fp,#-52
50018: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
5001c: 266e 0008 moveal %fp@(8),%a3
50020: 262e 0010 movel %fp@(16),%d3
50024: 2a6e 0014 moveal %fp@(20),%a5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
50028: 286b 0034 moveal %a3@(52),%a4
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
5002c: 246e 000c moveal %fp@(12),%a2
uint32_t old_last_cl;
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
50030: 2a83 movel %d3,%a5@
if (new_length <= fat_fd->fat_file_size)
50032: 202a 0018 movel %a2@(24),%d0
uint32_t *a_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
50036: 42ae fff0 clrl %fp@(-16)
uint32_t bytes2add = 0;
uint32_t cls2add = 0;
uint32_t old_last_cl;
uint32_t last_cl = 0;
5003a: 42ae fff8 clrl %fp@(-8)
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
5003e: b083 cmpl %d3,%d0
50040: 6400 0152 bccw 50194 <fat_file_extend+0x180>
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
50044: 7201 moveq #1,%d1
50046: b2aa 0020 cmpl %a2@(32),%d1
5004a: 6612 bnes 5005e <fat_file_extend+0x4a> <== ALWAYS TAKEN
5004c: 4aaa 0024 tstl %a2@(36) <== NOT EXECUTED
50050: 660c bnes 5005e <fat_file_extend+0x4a> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
50052: 4281 clrl %d1 <== NOT EXECUTED
50054: 122c 000a moveb %a4@(10),%d1 <== NOT EXECUTED
50058: 7403 moveq #3,%d2 <== NOT EXECUTED
5005a: c282 andl %d2,%d1 <== NOT EXECUTED
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
5005c: 665a bnes 500b8 <fat_file_extend+0xa4> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
5005e: 4284 clrl %d4
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
50060: 2a03 movel %d3,%d5
50062: 9a80 subl %d0,%d5
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
50064: 382c 0006 movew %a4@(6),%d4
50068: 2204 movel %d4,%d1
5006a: 5381 subql #1,%d1
5006c: 2401 movel %d1,%d2
5006e: c480 andl %d0,%d2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
50070: 9882 subl %d2,%d4
50072: c881 andl %d1,%d4
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
if (bytes2add > bytes_remain)
50074: b885 cmpl %d5,%d4
50076: 6400 011c bccw 50194 <fat_file_extend+0x180>
bytes2add -= bytes_remain;
5007a: 9a84 subl %d4,%d5
/*
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
5007c: 6700 0116 beqw 50194 <fat_file_extend+0x180>
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
50080: 4280 clrl %d0
50082: 102c 0008 moveb %a4@(8),%d0
50086: 2c05 movel %d5,%d6
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
50088: 486e fff8 pea %fp@(-8)
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
5008c: 5386 subql #1,%d6
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
5008e: 486e fffc pea %fp@(-4)
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
50092: e0ae lsrl %d0,%d6
50094: 5286 addql #1,%d6
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
50096: 2f06 movel %d6,%sp@-
50098: 486e fff0 pea %fp@(-16)
5009c: 2f0b movel %a3,%sp@-
5009e: 4eb9 0005 750c jsr 5750c <fat_scan_fat_for_free_clusters>
&cls_added, &last_cl);
/* this means that low level I/O error occured */
if (rc != RC_OK)
500a4: 4fef 0014 lea %sp@(20),%sp
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
500a8: 2400 movel %d0,%d2
&cls_added, &last_cl);
/* this means that low level I/O error occured */
if (rc != RC_OK)
500aa: 6600 00ea bnew 50196 <fat_file_extend+0x182>
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
500ae: 202e fffc movel %fp@(-4),%d0
500b2: 6616 bnes 500ca <fat_file_extend+0xb6> <== ALWAYS TAKEN
500b4: 4a84 tstl %d4 <== NOT EXECUTED
500b6: 6612 bnes 500ca <fat_file_extend+0xb6> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
500b8: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
500be: 74ff moveq #-1,%d2 <== NOT EXECUTED
500c0: 721c moveq #28,%d1 <== NOT EXECUTED
500c2: 2040 moveal %d0,%a0 <== NOT EXECUTED
500c4: 2081 movel %d1,%a0@ <== NOT EXECUTED
500c6: 6000 00ce braw 50196 <fat_file_extend+0x182> <== NOT EXECUTED
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
500ca: b086 cmpl %d6,%d0
500cc: 671e beqs 500ec <fat_file_extend+0xd8> <== ALWAYS TAKEN
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
500ce: 4680 notl %d0 <== NOT EXECUTED
500d0: dc80 addl %d0,%d6 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
500d2: 4281 clrl %d1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
500d4: 4280 clrl %d0 <== NOT EXECUTED
500d6: 102c 0008 moveb %a4@(8),%d0 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
500da: 322c 0006 movew %a4@(6),%d1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
500de: e1ae lsll %d0,%d6 <== NOT EXECUTED
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
500e0: 2003 movel %d3,%d0 <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
500e2: 5381 subql #1,%d1 <== NOT EXECUTED
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
500e4: 9086 subl %d6,%d0 <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
500e6: ca81 andl %d1,%d5 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
500e8: 9085 subl %d5,%d0 <== NOT EXECUTED
500ea: 2a80 movel %d0,%a5@ <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
500ec: 206a 0018 moveal %a2@(24),%a0
500f0: 4a88 tstl %a0
500f2: 6612 bnes 50106 <fat_file_extend+0xf2>
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
500f4: 202e fff0 movel %fp@(-16),%d0
fat_fd->map.file_cln = 0;
500f8: 42aa 0032 clrl %a2@(50)
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
500fc: 2540 001c movel %d0,%a2@(28)
50100: 2540 0036 movel %d0,%a2@(54)
50104: 6050 bras 50156 <fat_file_extend+0x142>
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
50106: 202a 003a movel %a2@(58),%d0
5010a: 72ff moveq #-1,%d1
5010c: b280 cmpl %d0,%d1
5010e: 6706 beqs 50116 <fat_file_extend+0x102> <== NEVER TAKEN
{
old_last_cl = fat_fd->map.last_cln;
50110: 2d40 fff4 movel %d0,%fp@(-12)
50114: 601e bras 50134 <fat_file_extend+0x120>
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
50116: 486e fff4 pea %fp@(-12) <== NOT EXECUTED
5011a: 4868 ffff pea %a0@(-1) <== NOT EXECUTED
5011e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
50122: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50124: 2f0b movel %a3,%sp@- <== NOT EXECUTED
50126: 4eb9 0004 ff7c jsr 4ff7c <fat_file_ioctl> <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
5012c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
50130: 2800 movel %d0,%d4 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
50132: 6648 bnes 5017c <fat_file_extend+0x168> <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
50134: 2f2e fff0 movel %fp@(-16),%sp@-
50138: 2f2e fff4 movel %fp@(-12),%sp@-
5013c: 2f0b movel %a3,%sp@-
5013e: 4eb9 0005 7204 jsr 57204 <fat_set_fat_cluster>
if ( rc != RC_OK )
50144: 4fef 000c lea %sp@(12),%sp
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
50148: 2800 movel %d0,%d4
if ( rc != RC_OK )
5014a: 6630 bnes 5017c <fat_file_extend+0x168> <== NEVER TAKEN
{
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
fat_buf_release(fs_info);
5014c: 2f0c movel %a4,%sp@-
5014e: 4eb9 0005 0780 jsr 50780 <fat_buf_release>
50154: 588f addql #4,%sp
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
50156: 4aae fffc tstl %fp@(-4)
5015a: 6732 beqs 5018e <fat_file_extend+0x17a> <== NEVER TAKEN
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
5015c: 7001 moveq #1,%d0
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
5015e: 256e fff8 003a movel %fp@(-8),%a2@(58)
if (fat_fd->fat_file_type == FAT_DIRECTORY)
50164: b0aa 0010 cmpl %a2@(16),%d0
50168: 6624 bnes 5018e <fat_file_extend+0x17a>
{
rc = fat_init_clusters_chain(mt_entry, chain);
5016a: 2f2e fff0 movel %fp@(-16),%sp@-
5016e: 2f0b movel %a3,%sp@-
50170: 4eb9 0005 0a78 jsr 50a78 <fat_init_clusters_chain>
if ( rc != RC_OK )
50176: 508f addql #8,%sp
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(mt_entry, chain);
50178: 2800 movel %d0,%d4
if ( rc != RC_OK )
5017a: 6712 beqs 5018e <fat_file_extend+0x17a> <== ALWAYS TAKEN
{
fat_free_fat_clusters_chain(mt_entry, chain);
5017c: 2f2e fff0 movel %fp@(-16),%sp@- <== NOT EXECUTED
return rc;
50180: 2404 movel %d4,%d2 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(mt_entry, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(mt_entry, chain);
50182: 2f0b movel %a3,%sp@- <== NOT EXECUTED
50184: 4eb9 0005 7462 jsr 57462 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
5018a: 508f addql #8,%sp <== NOT EXECUTED
5018c: 6008 bras 50196 <fat_file_extend+0x182> <== NOT EXECUTED
}
}
}
fat_fd->fat_file_size = new_length;
5018e: 2543 0018 movel %d3,%a2@(24)
return RC_OK;
50192: 6002 bras 50196 <fat_file_extend+0x182>
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
50194: 4282 clrl %d2
}
fat_fd->fat_file_size = new_length;
return RC_OK;
}
50196: 2002 movel %d2,%d0
50198: 4cee 3c7c ffcc moveml %fp@(-52),%d2-%d6/%a2-%a5
5019e: 4e5e unlk %fp <== NOT EXECUTED
0004ff7c <fat_file_ioctl>:
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
4ff7c: 7001 moveq #1,%d0
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
4ff7e: 4e56 fff0 linkw %fp,#-16
4ff82: 226e 0008 moveal %fp@(8),%a1
4ff86: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4ff8a: 206e 000c moveal %fp@(12),%a0
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4ff8e: 2669 0034 moveal %a1@(52),%a3
uint32_t cur_cln = 0;
4ff92: 42ae fffc clrl %fp@(-4)
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
4ff96: b0ae 0010 cmpl %fp@(16),%d0
4ff9a: 6660 bnes 4fffc <fat_file_ioctl+0x80> <== NEVER TAKEN
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
4ff9c: 222e 0014 movel %fp@(20),%d1
ret = va_arg(ap, uint32_t *);
4ffa0: 246e 0018 moveal %fp@(24),%a2
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
4ffa4: b2a8 0018 cmpl %a0@(24),%d1
4ffa8: 650e bcss 4ffb8 <fat_file_ioctl+0x3c> <== ALWAYS TAKEN
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
4ffaa: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4ffb0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ffb2: 7005 moveq #5,%d0 <== NOT EXECUTED
4ffb4: 2080 movel %d0,%a0@ <== NOT EXECUTED
4ffb6: 6050 bras 50008 <fat_file_ioctl+0x8c> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4ffb8: 7001 moveq #1,%d0
4ffba: b0a8 0020 cmpl %a0@(32),%d0
4ffbe: 6618 bnes 4ffd8 <fat_file_ioctl+0x5c>
4ffc0: 4aa8 0024 tstl %a0@(36)
4ffc4: 6612 bnes 4ffd8 <fat_file_ioctl+0x5c> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
4ffc6: 4280 clrl %d0
4ffc8: 102b 000a moveb %a3@(10),%d0
4ffcc: 7403 moveq #3,%d2
4ffce: c082 andl %d2,%d0
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4ffd0: 6706 beqs 4ffd8 <fat_file_ioctl+0x5c> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
4ffd2: 4292 clrl %a2@
rc = RC_OK;
4ffd4: 4280 clrl %d0
break;
4ffd6: 6032 bras 5000a <fat_file_ioctl+0x8e>
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4ffd8: 486e fffc pea %fp@(-4)
*ret = 0;
rc = RC_OK;
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
4ffdc: 4280 clrl %d0
4ffde: 102b 0008 moveb %a3@(8),%d0
4ffe2: e0a9 lsrl %d0,%d1
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4ffe4: 2f01 movel %d1,%sp@-
4ffe6: 2f08 movel %a0,%sp@-
4ffe8: 2f09 movel %a1,%sp@-
4ffea: 4eba f9b8 jsr %pc@(4f9a4 <fat_file_lseek>)
if ( rc != RC_OK )
4ffee: 4fef 0010 lea %sp@(16),%sp
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fff2: 2001 movel %d1,%d0
if ( rc != RC_OK )
4fff4: 6614 bnes 5000a <fat_file_ioctl+0x8e> <== NEVER TAKEN
break;
*ret = cur_cln;
4fff6: 24ae fffc movel %fp@(-4),%a2@
break;
4fffa: 600e bras 5000a <fat_file_ioctl+0x8e>
default:
errno = EINVAL;
4fffc: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50002: 7416 moveq #22,%d2 <== NOT EXECUTED
50004: 2040 moveal %d0,%a0 <== NOT EXECUTED
50006: 2082 movel %d2,%a0@ <== NOT EXECUTED
rc = -1;
50008: 70ff moveq #-1,%d0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
5000a: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
50010: 4e5e unlk %fp <== NOT EXECUTED
0004f9a4 <fat_file_lseek>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
4f9a4: 4e56 ffdc linkw %fp,#-36
4f9a8: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@
4f9ac: 246e 000c moveal %fp@(12),%a2
4f9b0: 2c2e 0008 movel %fp@(8),%d6
4f9b4: 242e 0010 movel %fp@(16),%d2
4f9b8: 266e 0014 moveal %fp@(20),%a3
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
4f9bc: 202a 0032 movel %a2@(50),%d0
4f9c0: b082 cmpl %d2,%d0
4f9c2: 6606 bnes 4f9ca <fat_file_lseek+0x26> <== NEVER TAKEN
*disk_cln = fat_fd->map.disk_cln;
4f9c4: 26aa 0036 movel %a2@(54),%a3@
4f9c8: 6054 bras 4fa1e <fat_file_lseek+0x7a>
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
4f9ca: b082 cmpl %d2,%d0 <== NOT EXECUTED
4f9cc: 640c bccs 4f9da <fat_file_lseek+0x36> <== NOT EXECUTED
{
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
4f9ce: 2802 movel %d2,%d4 <== NOT EXECUTED
4f9d0: 9880 subl %d0,%d4 <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
4f9d2: 2d6a 0036 fffc movel %a2@(54),%fp@(-4) <== NOT EXECUTED
4f9d8: 6008 bras 4f9e2 <fat_file_lseek+0x3e> <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
4f9da: 2802 movel %d2,%d4 <== NOT EXECUTED
4f9dc: 2d6a 001c fffc movel %a2@(28),%fp@(-4) <== NOT EXECUTED
}
/* skip over the clusters */
for (i = 0; i < count; i++)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4f9e2: 2a0e movel %fp,%d5 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
4f9e4: 4283 clrl %d3 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4f9e6: 5985 subql #4,%d5 <== NOT EXECUTED
4f9e8: 49f9 0005 708c lea 5708c <fat_get_fat_cluster>,%a4 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
4f9ee: 601c bras 4fa0c <fat_file_lseek+0x68> <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4f9f0: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4f9f2: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4f9f6: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4f9f8: 4e94 jsr %a4@ <== NOT EXECUTED
if ( rc != RC_OK )
4f9fa: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4f9fe: 4a80 tstl %d0 <== NOT EXECUTED
4fa00: 6708 beqs 4fa0a <fat_file_lseek+0x66> <== NOT EXECUTED
return rc;
4fa02: 2200 movel %d0,%d1 <== NOT EXECUTED
4fa04: 5bc0 smi %d0 <== NOT EXECUTED
4fa06: 49c0 extbl %d0 <== NOT EXECUTED
4fa08: 6018 bras 4fa22 <fat_file_lseek+0x7e> <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
4fa0a: 5283 addql #1,%d3 <== NOT EXECUTED
4fa0c: b883 cmpl %d3,%d4 <== NOT EXECUTED
4fa0e: 66e0 bnes 4f9f0 <fat_file_lseek+0x4c> <== NOT EXECUTED
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
4fa10: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
4fa14: 2542 0032 movel %d2,%a2@(50) <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
4fa18: 2540 0036 movel %d0,%a2@(54) <== NOT EXECUTED
*disk_cln = cur_cln;
4fa1c: 2680 movel %d0,%a3@ <== NOT EXECUTED
}
return RC_OK;
4fa1e: 4280 clrl %d0
4fa20: 4281 clrl %d1
}
4fa22: 4cee 1c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a4
4fa28: 4e5e unlk %fp <== NOT EXECUTED
0005035a <fat_file_mark_removed>:
void
fat_file_mark_removed(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
5035a: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
5035e: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
50362: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
50366: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
5036a: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
uint32_t key = 0;
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
5036e: 486a 0020 pea %a2@(32) <== NOT EXECUTED
50372: 2f08 movel %a0,%sp@- <== NOT EXECUTED
50374: 4eba f6ee jsr %pc@(4fa64 <fat_construct_key>) <== NOT EXECUTED
50378: 508f addql #8,%sp <== NOT EXECUTED
5037a: 2400 movel %d0,%d2 <== NOT EXECUTED
5037c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5037e: 4eb9 0004 9a3c jsr 49a3c <_Chain_Extract> <== NOT EXECUTED
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
50384: 7001 moveq #1,%d0 <== NOT EXECUTED
50386: c082 andl %d2,%d0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
50388: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5038a: 2200 movel %d0,%d1 <== NOT EXECUTED
5038c: e988 lsll #4,%d0 <== NOT EXECUTED
5038e: e589 lsll #2,%d1 <== NOT EXECUTED
50390: 9081 subl %d1,%d0 <== NOT EXECUTED
50392: d0ab 005e addl %a3@(94),%d0 <== NOT EXECUTED
50396: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50398: 4eb9 0004 9a04 jsr 49a04 <_Chain_Append> <== NOT EXECUTED
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
_hash_insert(fs_info->rhash, key, fat_fd->ino, fat_fd);
fat_fd->flags |= FAT_FILE_REMOVED;
5039e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
503a2: 7201 moveq #1,%d1 <== NOT EXECUTED
503a4: 102a 0030 moveb %a2@(48),%d0 <== NOT EXECUTED
503a8: 8081 orl %d1,%d0 <== NOT EXECUTED
503aa: 1540 0030 moveb %d0,%a2@(48) <== NOT EXECUTED
}
503ae: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
503b4: 4e5e unlk %fp <== NOT EXECUTED
0004fb18 <fat_file_open>:
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
4fb18: 4e56 ffe0 linkw %fp,#-32
4fb1c: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
4fb20: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
4fb24: 244e moveal %fp,%a2
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
4fb26: 283c 0004 fab6 movel #326326,%d4
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fb2c: 286b 0034 moveal %a3@(52),%a4
fat_file_fd_t *lfat_fd = NULL;
4fb30: 42a2 clrl %a2@-
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
4fb32: 262e 000c movel %fp@(12),%d3
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
4fb36: 2f03 movel %d3,%sp@-
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
4fb38: 2a6e 0010 moveal %fp@(16),%a5
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
4fb3c: 2f0b movel %a3,%sp@-
4fb3e: 4eba ff24 jsr %pc@(4fa64 <fat_construct_key>)
4fb42: 508f addql #8,%sp
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
4fb44: 2044 moveal %d4,%a0
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
4fb46: 2400 movel %d0,%d2
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
4fb48: 2f0a movel %a2,%sp@-
4fb4a: 42a7 clrl %sp@-
4fb4c: 2f00 movel %d0,%sp@-
4fb4e: 2f2c 005a movel %a4@(90),%sp@-
4fb52: 2f0b movel %a3,%sp@-
4fb54: 4e90 jsr %a0@
if ( rc == RC_OK )
4fb56: 4fef 0014 lea %sp@(20),%sp
4fb5a: 4a80 tstl %d0
4fb5c: 660e bnes 4fb6c <fat_file_open+0x54>
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
4fb5e: 206e fffc moveal %fp@(-4),%a0
4fb62: 2a88 movel %a0,%a5@
lfat_fd->links_num++;
4fb64: 52a8 0008 addql #1,%a0@(8)
return rc;
4fb68: 6000 00d0 braw 4fc3a <fat_file_open+0x122>
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
4fb6c: 2f0a movel %a2,%sp@-
4fb6e: 2044 moveal %d4,%a0
4fb70: 2f02 movel %d2,%sp@-
4fb72: 2f02 movel %d2,%sp@-
4fb74: 2f2c 005e movel %a4@(94),%sp@-
4fb78: 2f0b movel %a3,%sp@-
4fb7a: 4e90 jsr %a0@
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
4fb7c: 4878 0042 pea 42 <DBL_MANT_DIG+0xd>
lfat_fd->links_num++;
return rc;
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
4fb80: 2800 movel %d0,%d4
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
4fb82: 4eb9 0004 5af0 jsr 45af0 <malloc>
if ( lfat_fd == NULL )
4fb88: 4fef 0018 lea %sp@(24),%sp
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
4fb8c: 2440 moveal %d0,%a2
4fb8e: 2a80 movel %d0,%a5@
4fb90: 2d40 fffc movel %d0,%fp@(-4)
if ( lfat_fd == NULL )
4fb94: 660e bnes 4fba4 <fat_file_open+0x8c>
rtems_set_errno_and_return_minus_one( ENOMEM );
4fb96: 4eb9 0005 8b98 jsr 58b98 <__errno>
4fb9c: 720c moveq #12,%d1
4fb9e: 2040 moveal %d0,%a0
4fba0: 2081 movel %d1,%a0@
4fba2: 6072 bras 4fc16 <fat_file_open+0xfe>
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
4fba4: 4878 0042 pea 42 <DBL_MANT_DIG+0xd>
4fba8: 42a7 clrl %sp@-
4fbaa: 2f00 movel %d0,%sp@-
4fbac: 4eb9 0005 957c jsr 5957c <memset>
lfat_fd->links_num = 1;
4fbb2: 7001 moveq #1,%d0
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4fbb4: 72fe moveq #-2,%d1
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
4fbb6: 2540 0008 movel %d0,%a2@(8)
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4fbba: 102a 0030 moveb %a2@(48),%d0
4fbbe: c081 andl %d1,%d0
4fbc0: 1540 0030 moveb %d0,%a2@(48)
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4fbc4: 70ff moveq #-1,%d0
4fbc6: 2540 003a movel %d0,%a2@(58)
lfat_fd->dir_pos = *dir_pos;
4fbca: 4878 0010 pea 10 <INVALID_OPERATION>
4fbce: 2f03 movel %d3,%sp@-
4fbd0: 486a 0020 pea %a2@(32)
4fbd4: 4eb9 0005 950c jsr 5950c <memcpy>
if ( rc != RC_OK )
4fbda: 4fef 0018 lea %sp@(24),%sp
4fbde: 4a84 tstl %d4
4fbe0: 6706 beqs 4fbe8 <fat_file_open+0xd0> <== NEVER TAKEN
lfat_fd->ino = key;
4fbe2: 2542 000c movel %d2,%a2@(12)
4fbe6: 6032 bras 4fc1a <fat_file_open+0x102>
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
4fbe8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fbea: 4eb9 0005 0b30 jsr 50b30 <fat_get_unique_ino> <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
4fbf0: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
4fbf4: 588f addql #4,%sp <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
4fbf6: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
4fbfa: 4aa8 000c tstl %a0@(12) <== NOT EXECUTED
4fbfe: 661a bnes 4fc1a <fat_file_open+0x102> <== NOT EXECUTED
{
free((*fat_fd));
4fc00: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
4fc02: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
/*
* XXX: kernel resource is unsufficient, but not the memory,
* but there is no suitable errno :(
*/
rtems_set_errno_and_return_minus_one( ENOMEM );
4fc08: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4fc0e: 588f addql #4,%sp <== NOT EXECUTED
4fc10: 2040 moveal %d0,%a0 <== NOT EXECUTED
4fc12: 700c moveq #12,%d0 <== NOT EXECUTED
4fc14: 2080 movel %d0,%a0@ <== NOT EXECUTED
4fc16: 70ff moveq #-1,%d0
4fc18: 6020 bras 4fc3a <fat_file_open+0x122>
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
4fc1a: 7001 moveq #1,%d0
4fc1c: c480 andl %d0,%d2
4fc1e: 2f2e fffc movel %fp@(-4),%sp@-
4fc22: 2002 movel %d2,%d0
4fc24: e98a lsll #4,%d2
4fc26: e588 lsll #2,%d0
4fc28: 9480 subl %d0,%d2
4fc2a: d4ac 005a addl %a4@(90),%d2
4fc2e: 2f02 movel %d2,%sp@-
4fc30: 4eb9 0004 9a04 jsr 49a04 <_Chain_Append>
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
4fc36: 508f addql #8,%sp
4fc38: 4280 clrl %d0
}
4fc3a: 4cee 3c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a5
4fc40: 4e5e unlk %fp <== NOT EXECUTED
0004fc56 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
4fc56: 4e56 ffd4 linkw %fp,#-44
4fc5a: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4fc5e: 286e 0008 moveal %fp@(8),%a4
4fc62: 266e 000c moveal %fp@(12),%a3
4fc66: 2e2e 0010 movel %fp@(16),%d7
4fc6a: 242e 0014 movel %fp@(20),%d2
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fc6e: 246c 0034 moveal %a4@(52),%a2
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
4fc72: 42ae fffc clrl %fp@(-4)
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
4fc76: 4a82 tstl %d2
4fc78: 6700 013e beqw 4fdb8 <fat_file_read+0x162>
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
4fc7c: 202b 0018 movel %a3@(24),%d0
4fc80: b087 cmpl %d7,%d0
4fc82: 6300 0134 blsw 4fdb8 <fat_file_read+0x162>
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
4fc86: b082 cmpl %d2,%d0
4fc88: 6508 bcss 4fc92 <fat_file_read+0x3c> <== NEVER TAKEN
(start > fat_fd->fat_file_size - count))
4fc8a: 2200 movel %d0,%d1
4fc8c: 9282 subl %d2,%d1
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
4fc8e: b287 cmpl %d7,%d1
4fc90: 6404 bccs 4fc96 <fat_file_read+0x40> <== ALWAYS TAKEN
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
4fc92: 2400 movel %d0,%d2 <== NOT EXECUTED
4fc94: 9487 subl %d7,%d2 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4fc96: 7001 moveq #1,%d0
4fc98: b0ab 0020 cmpl %a3@(32),%d0
4fc9c: 6652 bnes 4fcf0 <fat_file_read+0x9a>
4fc9e: 4aab 0024 tstl %a3@(36)
4fca2: 664c bnes 4fcf0 <fat_file_read+0x9a> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
4fca4: 4280 clrl %d0
4fca6: 102a 000a moveb %a2@(10),%d0
4fcaa: 7203 moveq #3,%d1
4fcac: c081 andl %d1,%d0
if ((count > fat_fd->fat_file_size) ||
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4fcae: 6740 beqs 4fcf0 <fat_file_read+0x9a> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
4fcb0: 2f2b 001c movel %a3@(28),%sp@-
4fcb4: 2f0a movel %a2,%sp@-
4fcb6: 4eba fd74 jsr %pc@(4fa2c <fat_cluster_num_to_sector_num.isra.0>)
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
4fcba: 588f addql #4,%sp
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
4fcbc: 4281 clrl %d1
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
4fcbe: 2040 moveal %d0,%a0
4fcc0: 2eae 0018 movel %fp@(24),%sp@
4fcc4: 2f02 movel %d2,%sp@-
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
4fcc6: 3212 movew %a2@,%d1
4fcc8: 5381 subql #1,%d1
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
4fcca: c287 andl %d7,%d1
4fccc: 2f01 movel %d1,%sp@-
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
4fcce: 4281 clrl %d1
4fcd0: 122a 0002 moveb %a2@(2),%d1
4fcd4: e2af lsrl %d1,%d7
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
4fcd6: 4870 7800 pea %a0@(00000000,%d7:l)
4fcda: 2f0c movel %a4,%sp@-
4fcdc: 4eb9 0005 08b2 jsr 508b2 <_fat_block_read>
if ( ret < 0 )
4fce2: 4fef 0014 lea %sp@(20),%sp
4fce6: 4a80 tstl %d0
4fce8: 6c00 00d8 bgew 4fdc2 <fat_file_read+0x16c>
4fcec: 6000 00d2 braw 4fdc0 <fat_file_read+0x16a> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
4fcf0: 4280 clrl %d0
4fcf2: 102a 0008 moveb %a2@(8),%d0
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fcf6: 280e movel %fp,%d4
4fcf8: 5984 subql #4,%d4
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
4fcfa: 2607 movel %d7,%d3
4fcfc: e0ab lsrl %d0,%d3
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4fcfe: 3a2a 0006 movew %a2@(6),%d5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fd02: 2f04 movel %d4,%sp@-
4fd04: 2f03 movel %d3,%sp@-
4fd06: 2f0b movel %a3,%sp@-
4fd08: 2f0c movel %a4,%sp@-
4fd0a: 4eba fc98 jsr %pc@(4f9a4 <fat_file_lseek>)
if (rc != RC_OK)
4fd0e: 4fef 0010 lea %sp@(16),%sp
4fd12: 4a81 tstl %d1
4fd14: 6600 00a6 bnew 4fdbc <fat_file_read+0x166>
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4fd18: 4286 clrl %d6
4fd1a: 9bcd subal %a5,%a5
4fd1c: 0285 0000 ffff andil #65535,%d5
4fd22: 5385 subql #1,%d5
4fd24: ce85 andl %d5,%d7
4fd26: 2a07 movel %d7,%d5
4fd28: 606e bras 4fd98 <fat_file_read+0x142>
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
4fd2a: 4284 clrl %d4
4fd2c: 382a 0006 movew %a2@(6),%d4
4fd30: 9885 subl %d5,%d4
4fd32: b484 cmpl %d4,%d2
4fd34: 6402 bccs 4fd38 <fat_file_read+0xe2>
4fd36: 2802 movel %d2,%d4
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
4fd38: 2f2e fffc movel %fp@(-4),%sp@-
4fd3c: 2f2c 0034 movel %a4@(52),%sp@-
4fd40: 4eba fcea jsr %pc@(4fa2c <fat_cluster_num_to_sector_num.isra.0>)
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fd44: 206e 0018 moveal %fp@(24),%a0
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
4fd48: 508f addql #8,%sp
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fd4a: 4870 d800 pea %a0@(00000000,%a5:l)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
4fd4e: 4281 clrl %d1
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fd50: 2040 moveal %d0,%a0
4fd52: 2f04 movel %d4,%sp@-
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
4fd54: 3212 movew %a2@,%d1
4fd56: 5381 subql #1,%d1
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fd58: c285 andl %d5,%d1
4fd5a: 2f01 movel %d1,%sp@-
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
4fd5c: 4281 clrl %d1
4fd5e: 122a 0002 moveb %a2@(2),%d1
4fd62: e2ad lsrl %d1,%d5
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fd64: 4870 5800 pea %a0@(00000000,%d5:l)
4fd68: 2f0c movel %a4,%sp@-
4fd6a: 4eb9 0005 08b2 jsr 508b2 <_fat_block_read>
if ( ret < 0 )
4fd70: 4fef 0014 lea %sp@(20),%sp
4fd74: 4a80 tstl %d0
4fd76: 6d48 blts 4fdc0 <fat_file_read+0x16a> <== NEVER TAKEN
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4fd78: 486e fffc pea %fp@(-4)
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
4fd7c: 9484 subl %d4,%d2
cmpltd += c;
4fd7e: dbc4 addal %d4,%a5
save_cln = cur_cln;
4fd80: 2c2e fffc movel %fp@(-4),%d6
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4fd84: 2f06 movel %d6,%sp@-
4fd86: 2f0c movel %a4,%sp@-
4fd88: 4eb9 0005 708c jsr 5708c <fat_get_fat_cluster>
if ( rc != RC_OK )
4fd8e: 4fef 000c lea %sp@(12),%sp
4fd92: 4a80 tstl %d0
4fd94: 662c bnes 4fdc2 <fat_file_read+0x16c> <== NEVER TAKEN
return rc;
ofs = 0;
4fd96: 4285 clrl %d5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
4fd98: 4a82 tstl %d2
4fd9a: 668e bnes 4fd2a <fat_file_read+0xd4>
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4fd9c: 4281 clrl %d1
4fd9e: 122a 0008 moveb %a2@(8),%d1
4fda2: 41f5 78ff lea %a5@(ffffffff,%d7:l),%a0
fat_fd->map.disk_cln = save_cln;
4fda6: 2746 0036 movel %d6,%a3@(54)
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4fdaa: 2008 movel %a0,%d0
4fdac: e2a8 lsrl %d1,%d0
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
4fdae: d083 addl %d3,%d0
4fdb0: 2740 0032 movel %d0,%a3@(50)
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
4fdb4: 200d movel %a5,%d0
4fdb6: 600a bras 4fdc2 <fat_file_read+0x16c>
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
4fdb8: 4280 clrl %d0 <== NOT EXECUTED
4fdba: 6006 bras 4fdc2 <fat_file_read+0x16c> <== NOT EXECUTED
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
4fdbc: 2001 movel %d1,%d0 <== NOT EXECUTED
4fdbe: 6002 bras 4fdc2 <fat_file_read+0x16c> <== NOT EXECUTED
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
4fdc0: 70ff moveq #-1,%d0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
4fdc2: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4fdc8: 4e5e unlk %fp <== NOT EXECUTED
000504a6 <fat_file_size>:
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
504a6: 7001 moveq #1,%d0
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
504a8: 4e56 ffe4 linkw %fp,#-28
504ac: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
504b0: 286e 0008 moveal %fp@(8),%a4
504b4: 246e 000c moveal %fp@(12),%a2
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
504b8: 266c 0034 moveal %a4@(52),%a3
uint32_t cur_cln = fat_fd->cln;
504bc: 2d6a 001c fffc movel %a2@(28),%fp@(-4)
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
504c2: b0aa 0020 cmpl %a2@(32),%d0
504c6: 661a bnes 504e2 <fat_file_size+0x3c> <== ALWAYS TAKEN
504c8: 4aaa 0024 tstl %a2@(36) <== NOT EXECUTED
504cc: 6614 bnes 504e2 <fat_file_size+0x3c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
504ce: 4280 clrl %d0 <== NOT EXECUTED
504d0: 102b 000a moveb %a3@(10),%d0 <== NOT EXECUTED
504d4: 7203 moveq #3,%d1 <== NOT EXECUTED
504d6: c081 andl %d1,%d0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
504d8: 6708 beqs 504e2 <fat_file_size+0x3c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
504da: 256b 0024 0018 movel %a3@(36),%a2@(24) <== NOT EXECUTED
504e0: 6042 bras 50524 <fat_file_size+0x7e> <== NOT EXECUTED
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
504e2: 260e movel %fp,%d3
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
504e4: 4280 clrl %d0
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
504e6: 5983 subql #4,%d3
504e8: 4bf9 0005 708c lea 5708c <fat_get_fat_cluster>,%a5
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
return rc;
}
fat_fd->fat_file_size = 0;
504ee: 42aa 0018 clrl %a2@(24)
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
504f2: 601c bras 50510 <fat_file_size+0x6a>
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
504f4: 2f03 movel %d3,%sp@-
504f6: 2f02 movel %d2,%sp@-
504f8: 2f0c movel %a4,%sp@-
504fa: 4e95 jsr %a5@
if ( rc != RC_OK )
504fc: 4fef 000c lea %sp@(12),%sp
50500: 4a80 tstl %d0
50502: 6622 bnes 50526 <fat_file_size+0x80> <== NEVER TAKEN
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
50504: 4280 clrl %d0
50506: 302b 0006 movew %a3@(6),%d0
5050a: d1aa 0018 addl %d0,%a2@(24)
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
5050e: 2002 movel %d2,%d0
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
50510: 242e fffc movel %fp@(-4),%d2
50514: 2202 movel %d2,%d1
50516: c2ab 000c andl %a3@(12),%d1
5051a: b2ab 0010 cmpl %a3@(16),%d1
5051e: 65d4 bcss 504f4 <fat_file_size+0x4e>
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
50520: 2540 003a movel %d0,%a2@(58)
return rc;
50524: 4280 clrl %d0
}
50526: 4cee 3c0c ffe4 moveml %fp@(-28),%d2-%d3/%a2-%a5
5052c: 4e5e unlk %fp <== NOT EXECUTED
0004fdcc <fat_file_truncate>:
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
4fdcc: 70ff moveq #-1,%d0
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
4fdce: 4e56 ffe8 linkw %fp,#-24
4fdd2: 206e 0010 moveal %fp@(16),%a0
4fdd6: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4fdda: 266e 0008 moveal %fp@(8),%a3
4fdde: 246e 000c moveal %fp@(12),%a2
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
4fde2: 2d40 fffc movel %d0,%fp@(-4)
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fde6: 226b 0034 moveal %a3@(52),%a1
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
4fdea: 202a 0018 movel %a2@(24),%d0
uint32_t new_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
4fdee: 42ae fff8 clrl %fp@(-8)
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
4fdf2: b088 cmpl %a0,%d0
4fdf4: 6300 00b4 blsw 4feaa <fat_file_truncate+0xde>
return rc;
assert(fat_fd->fat_file_size);
4fdf8: 4a80 tstl %d0
4fdfa: 661c bnes 4fe18 <fat_file_truncate+0x4c> <== ALWAYS TAKEN
4fdfc: 4879 0006 8a62 pea 68a62 <rtems_filesystem_handlers_default+0x38><== NOT EXECUTED
4fe02: 4879 0006 8ac0 pea 68ac0 <__FUNCTION__.6164> <== NOT EXECUTED
4fe08: 4878 026d pea 26d <DBL_MANT_DIG+0x238> <== NOT EXECUTED
4fe0c: 4879 0006 8a78 pea 68a78 <rtems_filesystem_handlers_default+0x4e><== NOT EXECUTED
4fe12: 4eb9 0005 2244 jsr 52244 <__assert_func> <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
4fe18: 4282 clrl %d2
4fe1a: 4281 clrl %d1
4fe1c: 1229 0008 moveb %a1@(8),%d1
4fe20: 3429 0006 movew %a1@(6),%d2
4fe24: 41f0 28ff lea %a0@(ffffffff,%d2:l),%a0
4fe28: 2408 movel %a0,%d2
4fe2a: e2aa lsrl %d1,%d2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
4fe2c: 2602 movel %d2,%d3
4fe2e: e3ab lsll %d1,%d3
4fe30: b083 cmpl %d3,%d0
4fe32: 6376 blss 4feaa <fat_file_truncate+0xde> <== NEVER TAKEN
return RC_OK;
if (cl_start != 0)
4fe34: 4a82 tstl %d2
4fe36: 671a beqs 4fe52 <fat_file_truncate+0x86> <== ALWAYS TAKEN
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
4fe38: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4fe3c: 2042 moveal %d2,%a0 <== NOT EXECUTED
4fe3e: 4868 ffff pea %a0@(-1) <== NOT EXECUTED
4fe42: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4fe44: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fe46: 4eba fb5c jsr %pc@(4f9a4 <fat_file_lseek>) <== NOT EXECUTED
if (rc != RC_OK)
4fe4a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
return RC_OK;
if (cl_start != 0)
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
4fe4e: 2001 movel %d1,%d0 <== NOT EXECUTED
if (rc != RC_OK)
4fe50: 665a bnes 4feac <fat_file_truncate+0xe0> <== NOT EXECUTED
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fe52: 486e fff8 pea %fp@(-8)
4fe56: 2f02 movel %d2,%sp@-
4fe58: 2f0a movel %a2,%sp@-
4fe5a: 2f0b movel %a3,%sp@-
4fe5c: 4eba fb46 jsr %pc@(4f9a4 <fat_file_lseek>)
if (rc != RC_OK)
4fe60: 4fef 0010 lea %sp@(16),%sp
if (rc != RC_OK)
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fe64: 2001 movel %d1,%d0
if (rc != RC_OK)
4fe66: 6644 bnes 4feac <fat_file_truncate+0xe0> <== NEVER TAKEN
return rc;
rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
4fe68: 2f2e fff8 movel %fp@(-8),%sp@-
4fe6c: 2f0b movel %a3,%sp@-
4fe6e: 4eb9 0005 7462 jsr 57462 <fat_free_fat_clusters_chain>
if (rc != RC_OK)
4fe74: 508f addql #8,%sp
4fe76: 4a80 tstl %d0
4fe78: 6632 bnes 4feac <fat_file_truncate+0xe0> <== NEVER TAKEN
return rc;
if (cl_start != 0)
4fe7a: 4a82 tstl %d2
4fe7c: 672e beqs 4feac <fat_file_truncate+0xe0> <== ALWAYS TAKEN
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
4fe7e: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
4fe82: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4fe86: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fe88: 4eb9 0005 7204 jsr 57204 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
4fe8e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4fe92: 4a80 tstl %d0 <== NOT EXECUTED
4fe94: 6616 bnes 4feac <fat_file_truncate+0xe0> <== NOT EXECUTED
return rc;
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
4fe96: 222e fffc movel %fp@(-4),%d1 <== NOT EXECUTED
if (cl_start != 0)
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
4fe9a: 5382 subql #1,%d2 <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
4fe9c: 2541 0036 movel %d1,%a2@(54) <== NOT EXECUTED
if (cl_start != 0)
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
4fea0: 2542 0032 movel %d2,%a2@(50) <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
4fea4: 2541 003a movel %d1,%a2@(58) <== NOT EXECUTED
4fea8: 6002 bras 4feac <fat_file_truncate+0xe0> <== NOT EXECUTED
assert(fat_fd->fat_file_size);
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
return RC_OK;
4feaa: 4280 clrl %d0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
}
return RC_OK;
}
4feac: 4cee 0c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a3
4feb2: 4e5e unlk %fp <== NOT EXECUTED
000501a2 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
501a2: 4e56 ffd0 linkw %fp,#-48
501a6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
501aa: 286e 0008 moveal %fp@(8),%a4
501ae: 246e 000c moveal %fp@(12),%a2
501b2: 2e2e 0010 movel %fp@(16),%d7
501b6: 242e 0014 movel %fp@(20),%d2
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
501ba: 266c 0034 moveal %a4@(52),%a3
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
501be: 42ae fff8 clrl %fp@(-8)
uint32_t cl_start = 0;
uint32_t ofs = 0;
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
501c2: 42ae fffc clrl %fp@(-4)
if ( count == 0 )
501c6: 4a82 tstl %d2
501c8: 6700 0180 beqw 5034a <fat_file_write+0x1a8>
return cmpltd;
if ( start > fat_fd->fat_file_size )
501cc: beaa 0018 cmpl %a2@(24),%d7
501d0: 620e bhis 501e0 <fat_file_write+0x3e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
501d2: 202a 0014 movel %a2@(20),%d0
501d6: b082 cmpl %d2,%d0
501d8: 6506 bcss 501e0 <fat_file_write+0x3e> <== NEVER TAKEN
(start > fat_fd->size_limit - count))
501da: 9082 subl %d2,%d0
return cmpltd;
if ( start > fat_fd->fat_file_size )
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
501dc: b087 cmpl %d7,%d0
501de: 6410 bccs 501f0 <fat_file_write+0x4e> <== ALWAYS TAKEN
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
501e0: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
501e6: 7405 moveq #5,%d2 <== NOT EXECUTED
501e8: 2040 moveal %d0,%a0 <== NOT EXECUTED
501ea: 2082 movel %d2,%a0@ <== NOT EXECUTED
501ec: 6000 0160 braw 5034e <fat_file_write+0x1ac> <== NOT EXECUTED
rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);
501f0: 486e fffc pea %fp@(-4)
501f4: 2602 movel %d2,%d3
501f6: d687 addl %d7,%d3
501f8: 2f03 movel %d3,%sp@-
501fa: 2f0a movel %a2,%sp@-
501fc: 2f0c movel %a4,%sp@-
501fe: 4eb9 0005 0014 jsr 50014 <fat_file_extend>
if (rc != RC_OK)
50204: 4fef 0010 lea %sp@(16),%sp
50208: 4a80 tstl %d0
5020a: 6600 0144 bnew 50350 <fat_file_write+0x1ae>
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
5020e: 202e fffc movel %fp@(-4),%d0
50212: b680 cmpl %d0,%d3
50214: 6704 beqs 5021a <fat_file_write+0x78> <== ALWAYS TAKEN
count = c - start;
50216: 2400 movel %d0,%d2 <== NOT EXECUTED
50218: 9487 subl %d7,%d2 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
5021a: 7001 moveq #1,%d0
5021c: b0aa 0020 cmpl %a2@(32),%d0
50220: 6654 bnes 50276 <fat_file_write+0xd4>
50222: 4aaa 0024 tstl %a2@(36)
50226: 664e bnes 50276 <fat_file_write+0xd4> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
50228: 4280 clrl %d0
5022a: 102b 000a moveb %a3@(10),%d0
5022e: 7203 moveq #3,%d1
50230: c081 andl %d1,%d0
* file of 'start + count' bytes
*/
if (c != (start + count))
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
50232: 6742 beqs 50276 <fat_file_write+0xd4> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
50234: 2f2a 001c movel %a2@(28),%sp@-
50238: 2f2c 0034 movel %a4@(52),%sp@-
5023c: 4eba f7ee jsr %pc@(4fa2c <fat_cluster_num_to_sector_num.isra.0>)
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
50240: 588f addql #4,%sp
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
50242: 4281 clrl %d1
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
50244: 2040 moveal %d0,%a0
50246: 2eae 0018 movel %fp@(24),%sp@
5024a: 2f02 movel %d2,%sp@-
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
5024c: 3213 movew %a3@,%d1
5024e: 5381 subql #1,%d1
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
50250: c287 andl %d7,%d1
50252: 2f01 movel %d1,%sp@-
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
50254: 4281 clrl %d1
50256: 122b 0002 moveb %a3@(2),%d1
5025a: e2af lsrl %d1,%d7
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
5025c: 4870 7800 pea %a0@(00000000,%d7:l)
50260: 2f0c movel %a4,%sp@-
50262: 4eb9 0005 093a jsr 5093a <_fat_block_write>
if ( ret < 0 )
50268: 4fef 0014 lea %sp@(20),%sp
5026c: 4a80 tstl %d0
5026e: 6c00 00e0 bgew 50350 <fat_file_write+0x1ae>
50272: 6000 00da braw 5034e <fat_file_write+0x1ac> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
50276: 4280 clrl %d0
50278: 102b 0008 moveb %a3@(8),%d0
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
5027c: 280e movel %fp,%d4
5027e: 5184 subql #8,%d4
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
50280: 2607 movel %d7,%d3
50282: e0ab lsrl %d0,%d3
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
50284: 3a2b 0006 movew %a3@(6),%d5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
50288: 2f04 movel %d4,%sp@-
5028a: 2f03 movel %d3,%sp@-
5028c: 2f0a movel %a2,%sp@-
5028e: 2f0c movel %a4,%sp@-
50290: 4eba f712 jsr %pc@(4f9a4 <fat_file_lseek>)
if (rc != RC_OK)
50294: 4fef 0010 lea %sp@(16),%sp
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
50298: 2001 movel %d1,%d0
if (rc != RC_OK)
5029a: 6600 00b4 bnew 50350 <fat_file_write+0x1ae>
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
5029e: 4286 clrl %d6
502a0: 9bcd subal %a5,%a5
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
502a2: 283c 0005 708c movel #356492,%d4
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
502a8: 0285 0000 ffff andil #65535,%d5
502ae: 5385 subql #1,%d5
502b0: ce85 andl %d5,%d7
502b2: 2a07 movel %d7,%d5
502b4: 6074 bras 5032a <fat_file_write+0x188>
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
502b6: 4286 clrl %d6
502b8: 3c2b 0006 movew %a3@(6),%d6
502bc: 9c85 subl %d5,%d6
502be: b486 cmpl %d6,%d2
502c0: 6402 bccs 502c4 <fat_file_write+0x122>
502c2: 2c02 movel %d2,%d6
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
502c4: 2f2e fff8 movel %fp@(-8),%sp@-
502c8: 2f2c 0034 movel %a4@(52),%sp@-
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
502cc: 2d46 fffc movel %d6,%fp@(-4)
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
502d0: 4eba f75a jsr %pc@(4fa2c <fat_cluster_num_to_sector_num.isra.0>)
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
502d4: 206e 0018 moveal %fp@(24),%a0
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
502d8: 508f addql #8,%sp
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
502da: 4870 d800 pea %a0@(00000000,%a5:l)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
502de: 4281 clrl %d1
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
502e0: 2040 moveal %d0,%a0
502e2: 2f06 movel %d6,%sp@-
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
502e4: 3213 movew %a3@,%d1
502e6: 5381 subql #1,%d1
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
502e8: c285 andl %d5,%d1
502ea: 2f01 movel %d1,%sp@-
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
502ec: 4281 clrl %d1
502ee: 122b 0002 moveb %a3@(2),%d1
502f2: e2ad lsrl %d1,%d5
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
502f4: 4870 5800 pea %a0@(00000000,%d5:l)
502f8: 2f0c movel %a4,%sp@-
502fa: 4eb9 0005 093a jsr 5093a <_fat_block_write>
if ( ret < 0 )
50300: 4fef 0014 lea %sp@(20),%sp
50304: 4a80 tstl %d0
50306: 6d46 blts 5034e <fat_file_write+0x1ac> <== NEVER TAKEN
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50308: 486e fff8 pea %fp@(-8)
5030c: 2044 moveal %d4,%a0
if ( ret < 0 )
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
5030e: 2c2e fff8 movel %fp@(-8),%d6
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50312: 2f06 movel %d6,%sp@-
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
50314: 202e fffc movel %fp@(-4),%d0
50318: 9480 subl %d0,%d2
cmpltd += c;
5031a: dbc0 addal %d0,%a5
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
5031c: 2f0c movel %a4,%sp@-
5031e: 4e90 jsr %a0@
if ( rc != RC_OK )
50320: 4fef 000c lea %sp@(12),%sp
50324: 4a80 tstl %d0
50326: 6628 bnes 50350 <fat_file_write+0x1ae> <== NEVER TAKEN
return rc;
ofs = 0;
50328: 4285 clrl %d5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
5032a: 4a82 tstl %d2
5032c: 6688 bnes 502b6 <fat_file_write+0x114>
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
5032e: 4281 clrl %d1
50330: 122b 0008 moveb %a3@(8),%d1
50334: 41f5 78ff lea %a5@(ffffffff,%d7:l),%a0
fat_fd->map.disk_cln = save_cln;
50338: 2546 0036 movel %d6,%a2@(54)
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
5033c: 2008 movel %a0,%d0
5033e: e2a8 lsrl %d1,%d0
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
50340: d083 addl %d3,%d0
50342: 2540 0032 movel %d0,%a2@(50)
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
50346: 200d movel %a5,%d0
50348: 6006 bras 50350 <fat_file_write+0x1ae>
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
return cmpltd;
5034a: 4280 clrl %d0 <== NOT EXECUTED
5034c: 6002 bras 50350 <fat_file_write+0x1ae> <== NOT EXECUTED
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
5034e: 70ff moveq #-1,%d0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
50350: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
50356: 4e5e unlk %fp <== NOT EXECUTED
00057462 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
57462: 4e56 ffd4 linkw %fp,#-44
57466: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
5746a: 286e 0008 moveal %fp@(8),%a4
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
5746e: 264e moveal %fp,%a3
uint32_t freed_cls_cnt = 0;
57470: 4282 clrl %d2
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
57472: 4285 clrl %d5
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
57474: 2e3c 0005 708c movel #356492,%d7
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
5747a: 4bf9 0005 7204 lea 57204 <fat_set_fat_cluster>,%a5
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
57480: 2c2e 000c movel %fp@(12),%d6
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
57484: 2606 movel %d6,%d3
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
57486: 246c 0034 moveal %a4@(52),%a2
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
5748a: 42a3 clrl %a3@-
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
5748c: 6046 bras 574d4 <fat_free_fat_clusters_chain+0x72>
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
5748e: 2f0b movel %a3,%sp@-
57490: 2047 moveal %d7,%a0
57492: 2f03 movel %d3,%sp@-
57494: 2f0c movel %a4,%sp@-
57496: 4e90 jsr %a0@
if ( rc != RC_OK )
57498: 4fef 000c lea %sp@(12),%sp
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
5749c: 2800 movel %d0,%d4
if ( rc != RC_OK )
5749e: 671c beqs 574bc <fat_free_fat_clusters_chain+0x5a><== ALWAYS TAKEN
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
574a0: 202a 003a movel %a2@(58),%d0 <== NOT EXECUTED
574a4: 72ff moveq #-1,%d1 <== NOT EXECUTED
574a6: b280 cmpl %d0,%d1 <== NOT EXECUTED
574a8: 6706 beqs 574b0 <fat_free_fat_clusters_chain+0x4e><== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
574aa: d480 addl %d0,%d2 <== NOT EXECUTED
574ac: 2542 003a movel %d2,%a2@(58) <== NOT EXECUTED
fat_buf_release(fs_info);
574b0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
574b2: 4eb9 0005 0780 jsr 50780 <fat_buf_release> <== NOT EXECUTED
return rc;
574b8: 588f addql #4,%sp <== NOT EXECUTED
574ba: 6044 bras 57500 <fat_free_fat_clusters_chain+0x9e><== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
574bc: 42a7 clrl %sp@-
574be: 2f03 movel %d3,%sp@-
574c0: 2f0c movel %a4,%sp@-
574c2: 4e95 jsr %a5@
if ( rc != RC_OK )
574c4: 4fef 000c lea %sp@(12),%sp
574c8: 4a80 tstl %d0
574ca: 6702 beqs 574ce <fat_free_fat_clusters_chain+0x6c><== ALWAYS TAKEN
574cc: 2a00 movel %d0,%d5 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
574ce: 262e fffc movel %fp@(-4),%d3
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
574d2: 5282 addql #1,%d2
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
574d4: 2003 movel %d3,%d0
574d6: c0aa 000c andl %a2@(12),%d0
574da: b0aa 0010 cmpl %a2@(16),%d0
574de: 65ae bcss 5748e <fat_free_fat_clusters_chain+0x2c>
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
574e0: 202a 003a movel %a2@(58),%d0
574e4: 72ff moveq #-1,%d1
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
574e6: 2546 003e movel %d6,%a2@(62)
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
574ea: b280 cmpl %d0,%d1
574ec: 6706 beqs 574f4 <fat_free_fat_clusters_chain+0x92><== ALWAYS TAKEN
fs_info->vol.free_cls += freed_cls_cnt;
574ee: d480 addl %d0,%d2 <== NOT EXECUTED
574f0: 2542 003a movel %d2,%a2@(58) <== NOT EXECUTED
fat_buf_release(fs_info);
574f4: 2f0a movel %a2,%sp@-
574f6: 2805 movel %d5,%d4
574f8: 4eb9 0005 0780 jsr 50780 <fat_buf_release>
574fe: 588f addql #4,%sp
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
57500: 2004 movel %d4,%d0
57502: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
57508: 4e5e unlk %fp <== NOT EXECUTED
00050bc8 <fat_free_unique_ino>:
void
fat_free_unique_ino(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
50bc8: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
50bcc: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
50bd0: 202e 000c movel %fp@(12),%d0 <== NOT EXECUTED
fat_free_unique_ino(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
50bd4: 2268 0034 moveal %a0@(52),%a1 <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
50bd8: 90a9 006e subl %a1@(110),%d0 <== NOT EXECUTED
50bdc: 2200 movel %d0,%d1 <== NOT EXECUTED
50bde: e689 lsrl #3,%d1 <== NOT EXECUTED
50be0: 2069 0062 moveal %a1@(98),%a0 <== NOT EXECUTED
50be4: d1c1 addal %d1,%a0 <== NOT EXECUTED
50be6: 7207 moveq #7,%d1 <== NOT EXECUTED
50be8: c280 andl %d0,%d1 <== NOT EXECUTED
50bea: 7001 moveq #1,%d0 <== NOT EXECUTED
50bec: e3a8 lsll %d1,%d0 <== NOT EXECUTED
50bee: 1210 moveb %a0@,%d1 <== NOT EXECUTED
50bf0: 4680 notl %d0 <== NOT EXECUTED
50bf2: c081 andl %d1,%d0 <== NOT EXECUTED
50bf4: 1080 moveb %d0,%a0@ <== NOT EXECUTED
}
50bf6: 4e5e unlk %fp <== NOT EXECUTED
0005708c <fat_get_fat_cluster>:
rtems_bdbuf_buffer *block0 = NULL;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
5708c: 7001 moveq #1,%d0
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
5708e: 4e56 ffd8 linkw %fp,#-40
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
57092: 206e 0008 moveal %fp@(8),%a0
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
57096: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
5709a: 242e 000c movel %fp@(12),%d2
5709e: 246e 0010 moveal %fp@(16),%a2
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
570a2: 2668 0034 moveal %a0@(52),%a3
rtems_bdbuf_buffer *block0 = NULL;
570a6: 42ae fffc clrl %fp@(-4)
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
570aa: b082 cmpl %d2,%d0
570ac: 6400 0138 bccw 571e6 <fat_get_fat_cluster+0x15a>
570b0: 202b 0030 movel %a3@(48),%d0
570b4: 5280 addql #1,%d0
570b6: b082 cmpl %d2,%d0
570b8: 6500 012c bcsw 571e6 <fat_get_fat_cluster+0x15a>
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
570bc: 4280 clrl %d0
570be: 102b 000a moveb %a3@(10),%d0
570c2: 7201 moveq #1,%d1
570c4: 2802 movel %d2,%d4
570c6: c280 andl %d0,%d1
570c8: 6706 beqs 570d0 <fat_get_fat_cluster+0x44> <== NEVER TAKEN
570ca: e28c lsrl #1,%d4
570cc: d882 addl %d2,%d4
570ce: 600c bras 570dc <fat_get_fat_cluster+0x50>
570d0: 0800 0001 btst #1,%d0 <== NOT EXECUTED
570d4: 6704 beqs 570da <fat_get_fat_cluster+0x4e> <== NOT EXECUTED
570d6: d884 addl %d4,%d4 <== NOT EXECUTED
570d8: 6002 bras 570dc <fat_get_fat_cluster+0x50> <== NOT EXECUTED
570da: e58c lsll #2,%d4 <== NOT EXECUTED
570dc: 4283 clrl %d3
570de: 162b 0002 moveb %a3@(2),%d3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
570e2: 2a02 movel %d2,%d5
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
570e4: e6ac lsrl %d3,%d4
570e6: d8ab 0044 addl %a3@(68),%d4
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
570ea: 4a81 tstl %d1
570ec: 6706 beqs 570f4 <fat_get_fat_cluster+0x68> <== NEVER TAKEN
570ee: e28d lsrl #1,%d5
570f0: da82 addl %d2,%d5
570f2: 600c bras 57100 <fat_get_fat_cluster+0x74>
570f4: 0800 0001 btst #1,%d0 <== NOT EXECUTED
570f8: 6704 beqs 570fe <fat_get_fat_cluster+0x72> <== NOT EXECUTED
570fa: da85 addl %d5,%d5 <== NOT EXECUTED
570fc: 6002 bras 57100 <fat_get_fat_cluster+0x74> <== NOT EXECUTED
570fe: e58d lsll #2,%d5 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
57100: 2c0e movel %fp,%d6
57102: 5986 subql #4,%d6
57104: 49f9 0005 05a0 lea 505a0 <fat_buf_access>,%a4
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
5710a: 3e13 movew %a3@,%d7
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
5710c: 2f06 movel %d6,%sp@-
5710e: 4878 0001 pea 1 <ADD>
57112: 2f04 movel %d4,%sp@-
57114: 2f0b movel %a3,%sp@-
57116: 4e94 jsr %a4@
if (rc != RC_OK)
57118: 4fef 0010 lea %sp@(16),%sp
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
5711c: 2600 movel %d0,%d3
if (rc != RC_OK)
5711e: 6600 00d8 bnew 571f8 <fat_get_fat_cluster+0x16c>
return rc;
switch ( fs_info->vol.type )
57122: 4280 clrl %d0
57124: 102b 000a moveb %a3@(10),%d0
57128: 7202 moveq #2,%d1
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
5712a: 0287 0000 ffff andil #65535,%d7
57130: 5387 subql #1,%d7
57132: ca87 andl %d7,%d5
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
57134: b280 cmpl %d0,%d1
57136: 677a beqs 571b2 <fat_get_fat_cluster+0x126> <== NEVER TAKEN
57138: 123c 0004 moveb #4,%d1
5713c: b280 cmpl %d0,%d1
5713e: 6700 0090 beqw 571d0 <fat_get_fat_cluster+0x144>
57142: 123c 0001 moveb #1,%d1
57146: b280 cmpl %d0,%d1
57148: 6600 009c bnew 571e6 <fat_get_fat_cluster+0x15a>
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
5714c: 206e fffc moveal %fp@(-4),%a0
57150: 4281 clrl %d1
if ( ofs == (fs_info->vol.bps - 1) )
57152: 4280 clrl %d0
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
57154: 2068 001e moveal %a0@(30),%a0
57158: 1230 5800 moveb %a0@(00000000,%d5:l),%d1
if ( ofs == (fs_info->vol.bps - 1) )
5715c: 3013 movew %a3@,%d0
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
5715e: 2481 movel %d1,%a2@
if ( ofs == (fs_info->vol.bps - 1) )
57160: 5380 subql #1,%d0
57162: b085 cmpl %d5,%d0
57164: 662a bnes 57190 <fat_get_fat_cluster+0x104> <== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
57166: 2f06 movel %d6,%sp@- <== NOT EXECUTED
57168: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5716c: 2044 moveal %d4,%a0 <== NOT EXECUTED
5716e: 4868 0001 pea %a0@(1) <== NOT EXECUTED
57172: 2f0b movel %a3,%sp@- <== NOT EXECUTED
57174: 4e94 jsr %a4@ <== NOT EXECUTED
&block0);
if (rc != RC_OK)
57176: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5717a: 4a80 tstl %d0 <== NOT EXECUTED
5717c: 6678 bnes 571f6 <fat_get_fat_cluster+0x16a> <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
5717e: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
57182: 4280 clrl %d0 <== NOT EXECUTED
57184: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
57188: 1010 moveb %a0@,%d0 <== NOT EXECUTED
5718a: e188 lsll #8,%d0 <== NOT EXECUTED
5718c: 8192 orl %d0,%a2@ <== NOT EXECUTED
5718e: 600c bras 5719c <fat_get_fat_cluster+0x110> <== NOT EXECUTED
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
57190: 4280 clrl %d0
57192: 1030 5801 moveb %a0@(00000001,%d5:l),%d0
57196: e188 lsll #8,%d0
57198: 8081 orl %d1,%d0
5719a: 2480 movel %d0,%a2@
}
if ( FAT_CLUSTER_IS_ODD(cln) )
5719c: 0802 0000 btst #0,%d2
571a0: 6706 beqs 571a8 <fat_get_fat_cluster+0x11c>
*ret_val = (*ret_val) >> FAT12_SHIFT;
571a2: 2012 movel %a2@,%d0
571a4: e888 lsrl #4,%d0
571a6: 603a bras 571e2 <fat_get_fat_cluster+0x156>
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
571a8: 203c 0000 0fff movel #4095,%d0
571ae: c192 andl %d0,%a2@
571b0: 6046 bras 571f8 <fat_get_fat_cluster+0x16c>
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
571b2: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
571b6: 4281 clrl %d1 <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
571b8: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
571bc: 3230 5800 movew %a0@(00000000,%d5:l),%d1 <== NOT EXECUTED
static inline uint16_t m68k_swap_u16(
uint16_t value
)
{
return (((value & 0xff) << 8) | ((value >> 8) & 0xff));
571c0: 2001 movel %d1,%d0 <== NOT EXECUTED
571c2: e089 lsrl #8,%d1 <== NOT EXECUTED
571c4: e188 lsll #8,%d0 <== NOT EXECUTED
571c6: 0280 0000 ff00 andil #65280,%d0 <== NOT EXECUTED
571cc: 8081 orl %d1,%d0 <== NOT EXECUTED
571ce: 6012 bras 571e2 <fat_get_fat_cluster+0x156> <== NOT EXECUTED
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
571d0: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
571d4: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
*ret_val = CF_LE_L(*ret_val);
571d8: 2f30 5800 movel %a0@(00000000,%d5:l),%sp@- <== NOT EXECUTED
571dc: 4eba fe76 jsr %pc@(57054 <m68k_swap_u32>) <== NOT EXECUTED
571e0: 588f addql #4,%sp <== NOT EXECUTED
571e2: 2480 movel %d0,%a2@
break;
571e4: 6012 bras 571f8 <fat_get_fat_cluster+0x16c>
default:
rtems_set_errno_and_return_minus_one(EIO);
571e6: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
571ec: 76ff moveq #-1,%d3 <== NOT EXECUTED
571ee: 2040 moveal %d0,%a0 <== NOT EXECUTED
571f0: 7005 moveq #5,%d0 <== NOT EXECUTED
571f2: 2080 movel %d0,%a0@ <== NOT EXECUTED
571f4: 6002 bras 571f8 <fat_get_fat_cluster+0x16c> <== NOT EXECUTED
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
571f6: 2600 movel %d0,%d3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
571f8: 2003 movel %d3,%d0
571fa: 4cee 1cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a4
57200: 4e5e unlk %fp <== NOT EXECUTED
00050b30 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
50b30: 4e56 ffec linkw %fp,#-20 <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
50b34: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
50b38: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
50b3c: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
50b40: 47f9 0004 6750 lea 46750 <realloc>,%a3 <== NOT EXECUTED
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
50b46: 606c bras 50bb4 <fat_get_unique_ino+0x84> <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
50b48: 222a 0066 movel %a2@(102),%d1 <== NOT EXECUTED
50b4c: 2401 movel %d1,%d2 <== NOT EXECUTED
50b4e: e68a lsrl #3,%d2 <== NOT EXECUTED
50b50: 7607 moveq #7,%d3 <== NOT EXECUTED
50b52: 206a 0062 moveal %a2@(98),%a0 <== NOT EXECUTED
50b56: d1c2 addal %d2,%a0 <== NOT EXECUTED
50b58: 1410 moveb %a0@,%d2 <== NOT EXECUTED
50b5a: c681 andl %d1,%d3 <== NOT EXECUTED
50b5c: 1802 moveb %d2,%d4 <== NOT EXECUTED
50b5e: 49c4 extbl %d4 <== NOT EXECUTED
50b60: 0704 btst %d3,%d4 <== NOT EXECUTED
50b62: 6612 bnes 50b76 <fat_get_unique_ino+0x46> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
50b64: 7001 moveq #1,%d0 <== NOT EXECUTED
50b66: e7a8 lsll %d3,%d0 <== NOT EXECUTED
50b68: 8082 orl %d2,%d0 <== NOT EXECUTED
50b6a: 1080 moveb %d0,%a0@ <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
50b6c: 202a 0066 movel %a2@(102),%d0 <== NOT EXECUTED
50b70: d0aa 006e addl %a2@(110),%d0 <== NOT EXECUTED
50b74: 6048 bras 50bbe <fat_get_unique_ino+0x8e> <== NOT EXECUTED
}
fs_info->index++;
50b76: 5281 addql #1,%d1 <== NOT EXECUTED
50b78: 2541 0066 movel %d1,%a2@(102) <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
50b7c: b3c1 cmpal %d1,%a1 <== NOT EXECUTED
50b7e: 6204 bhis 50b84 <fat_get_unique_ino+0x54> <== NOT EXECUTED
fs_info->index = 0;
50b80: 42aa 0066 clrl %a2@(102) <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
50b84: 5280 addql #1,%d0 <== NOT EXECUTED
50b86: b3c0 cmpal %d0,%a1 <== NOT EXECUTED
50b88: 66be bnes 50b48 <fat_get_unique_ino+0x18> <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
50b8a: 223c 0fff ffff movel #268435455,%d1 <== NOT EXECUTED
50b90: 92aa 006e subl %a2@(110),%d1 <== NOT EXECUTED
50b94: d080 addl %d0,%d0 <== NOT EXECUTED
50b96: b280 cmpl %d0,%d1 <== NOT EXECUTED
50b98: 6322 blss 50bbc <fat_get_unique_ino+0x8c> <== NOT EXECUTED
{
fs_info->uino_pool_size <<= 1;
50b9a: 2540 006a movel %d0,%a2@(106) <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
50b9e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50ba0: 2f2a 0062 movel %a2@(98),%sp@- <== NOT EXECUTED
50ba4: 4e93 jsr %a3@ <== NOT EXECUTED
if (fs_info->uino != NULL)
50ba6: 508f addql #8,%sp <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
50ba8: 2540 0062 movel %d0,%a2@(98) <== NOT EXECUTED
if (fs_info->uino != NULL)
50bac: 670e beqs 50bbc <fat_get_unique_ino+0x8c> <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
50bae: 256a 006a 0066 movel %a2@(106),%a2@(102) <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
50bb4: 226a 006a moveal %a2@(106),%a1 <== NOT EXECUTED
50bb8: 4280 clrl %d0 <== NOT EXECUTED
50bba: 60ca bras 50b86 <fat_get_unique_ino+0x56> <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
50bbc: 4280 clrl %d0 <== NOT EXECUTED
}
50bbe: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3 <== NOT EXECUTED
50bc4: 4e5e unlk %fp <== NOT EXECUTED
00050a78 <fat_init_clusters_chain>:
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
50a78: 4280 clrl %d0
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
50a7a: 4e56 ffe0 linkw %fp,#-32
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
50a7e: 2d6e 000c fffc movel %fp@(12),%fp@(-4)
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
50a84: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
50a88: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
50a8c: 246b 0034 moveal %a3@(52),%a2
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
50a90: 4878 0001 pea 1 <ADD>
50a94: 302a 0006 movew %a2@(6),%d0
50a98: 2f00 movel %d0,%sp@-
50a9a: 4eb9 0004 4e3c jsr 44e3c <calloc>
if ( buf == NULL )
50aa0: 508f addql #8,%sp
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
50aa2: 2400 movel %d0,%d2
if ( buf == NULL )
50aa4: 6654 bnes 50afa <fat_init_clusters_chain+0x82> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
50aa6: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50aac: 2040 moveal %d0,%a0 <== NOT EXECUTED
50aae: 7005 moveq #5,%d0 <== NOT EXECUTED
50ab0: 2080 movel %d0,%a0@ <== NOT EXECUTED
50ab2: 601c bras 50ad0 <fat_init_clusters_chain+0x58> <== NOT EXECUTED
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
50ab4: 2f02 movel %d2,%sp@-
50ab6: 2f00 movel %d0,%sp@-
50ab8: 2f0b movel %a3,%sp@-
50aba: 4e95 jsr %a5@
if ( ret == -1 )
50abc: 4fef 000c lea %sp@(12),%sp
50ac0: 72ff moveq #-1,%d1
50ac2: b280 cmpl %d0,%d1
50ac4: 660e bnes 50ad4 <fat_init_clusters_chain+0x5c> <== ALWAYS TAKEN
{
free(buf);
50ac6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
50ac8: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return -1;
50ace: 588f addql #4,%sp <== NOT EXECUTED
50ad0: 70ff moveq #-1,%d0 <== NOT EXECUTED
50ad2: 6052 bras 50b26 <fat_init_clusters_chain+0xae> <== NOT EXECUTED
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50ad4: 2f03 movel %d3,%sp@-
50ad6: 2f2e fffc movel %fp@(-4),%sp@-
50ada: 2f0b movel %a3,%sp@-
50adc: 4e94 jsr %a4@
if ( rc != RC_OK )
50ade: 4fef 000c lea %sp@(12),%sp
50ae2: 4a80 tstl %d0
50ae4: 6724 beqs 50b0a <fat_init_clusters_chain+0x92> <== ALWAYS TAKEN
{
free(buf);
50ae6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
50ae8: 2d40 fff8 movel %d0,%fp@(-8) <== NOT EXECUTED
50aec: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rc;
50af2: 202e fff8 movel %fp@(-8),%d0 <== NOT EXECUTED
50af6: 588f addql #4,%sp <== NOT EXECUTED
50af8: 602c bras 50b26 <fat_init_clusters_chain+0xae> <== NOT EXECUTED
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50afa: 260e movel %fp,%d3
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
50afc: 4bf9 0005 0a32 lea 50a32 <fat_cluster_write>,%a5
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50b02: 5983 subql #4,%d3
50b04: 49f9 0005 708c lea 5708c <fat_get_fat_cluster>,%a4
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
50b0a: 202e fffc movel %fp@(-4),%d0
50b0e: 2200 movel %d0,%d1
50b10: c2aa 000c andl %a2@(12),%d1
50b14: b2aa 0010 cmpl %a2@(16),%d1
50b18: 659a bcss 50ab4 <fat_init_clusters_chain+0x3c>
free(buf);
return rc;
}
}
free(buf);
50b1a: 2f02 movel %d2,%sp@-
50b1c: 4eb9 0004 54d0 jsr 454d0 <free>
return rc;
50b22: 588f addql #4,%sp
50b24: 4280 clrl %d0
}
50b26: 4cee 3c0c ffe0 moveml %fp@(-32),%d2-%d3/%a2-%a5
50b2c: 4e5e unlk %fp <== NOT EXECUTED
00050d9c <fat_init_volume_info>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
50d9c: 4e56 ff64 linkw %fp,#-156
50da0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
50da4: 266e 0008 moveal %fp@(8),%a3
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
50da8: 246b 0034 moveal %a3@(52),%a2
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
50dac: 486e ffaa pea %fp@(-86)
50db0: 2f2b 0070 movel %a3@(112),%sp@-
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
50db4: 42ae fffc clrl %fp@(-4)
rc = stat(mt_entry->dev, &stat_buf);
50db8: 4eb9 0004 6960 jsr 46960 <stat>
if (rc == -1)
50dbe: 508f addql #8,%sp
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
50dc0: 2400 movel %d0,%d2
if (rc == -1)
50dc2: 70ff moveq #-1,%d0
50dc4: b082 cmpl %d2,%d0
50dc6: 6700 0756 beqw 5151e <fat_init_volume_info+0x782>
return rc;
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
50dca: 202e ffb6 movel %fp@(-74),%d0
50dce: 0280 0000 f000 andil #61440,%d0
50dd4: 0c80 0000 6000 cmpil #24576,%d0
50dda: 6710 beqs 50dec <fat_init_volume_info+0x50> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOTTY);
50ddc: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50de2: 7619 moveq #25,%d3 <== NOT EXECUTED
50de4: 2040 moveal %d0,%a0 <== NOT EXECUTED
50de6: 2083 movel %d3,%a0@ <== NOT EXECUTED
50de8: 6000 072e braw 51518 <fat_init_volume_info+0x77c> <== NOT EXECUTED
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
50dec: 2f2e ffc4 movel %fp@(-60),%sp@-
50df0: 2f2e ffc0 movel %fp@(-64),%sp@-
50df4: 4eb9 0004 44ba jsr 444ba <rtems_disk_obtain>
if (vol->dd == NULL)
50dfa: 508f addql #8,%sp
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
rtems_set_errno_and_return_minus_one(ENOTTY);
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
50dfc: 2540 0052 movel %d0,%a2@(82)
if (vol->dd == NULL)
50e00: 6610 bnes 50e12 <fat_init_volume_info+0x76> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
50e02: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50e08: 7405 moveq #5,%d2 <== NOT EXECUTED
50e0a: 2240 moveal %d0,%a1 <== NOT EXECUTED
50e0c: 2282 movel %d2,%a1@ <== NOT EXECUTED
50e0e: 6000 0708 braw 51518 <fat_init_volume_info+0x77c> <== NOT EXECUTED
vol->dev = stat_buf.st_rdev;
50e12: 202e ffc0 movel %fp@(-64),%d0
50e16: 222e ffc4 movel %fp@(-60),%d1
50e1a: 2540 004a movel %d0,%a2@(74)
50e1e: 2541 004e movel %d1,%a2@(78)
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
50e22: 486e fffc pea %fp@(-4)
50e26: 42a7 clrl %sp@-
50e28: 2f01 movel %d1,%sp@-
50e2a: 2f00 movel %d0,%sp@-
50e2c: 4eb9 0004 efec jsr 4efec <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
50e32: 4fef 0010 lea %sp@(16),%sp
50e36: 4a80 tstl %d0
50e38: 6600 00d4 bnew 50f0e <fat_init_volume_info+0x172>
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
50e3c: 206e fffc moveal %fp@(-4),%a0
50e40: 2268 001e moveal %a0@(30),%a1
50e44: 1229 000b moveb %a1@(11),%d1
50e48: 1829 000e moveb %a1@(14),%d4
50e4c: 1029 000f moveb %a1@(15),%d0
50e50: 1d41 ff95 moveb %d1,%fp@(-107)
50e54: 1229 0011 moveb %a1@(17),%d1
50e58: 3844 moveaw %d4,%a4
50e5a: 1d41 ff9c moveb %d1,%fp@(-100)
50e5e: 1229 0012 moveb %a1@(18),%d1
50e62: 1c29 000c moveb %a1@(12),%d6
50e66: 1d41 ff9b moveb %d1,%fp@(-101)
50e6a: 1229 0013 moveb %a1@(19),%d1
50e6e: 1429 000d moveb %a1@(13),%d2
50e72: 1d41 ff9a moveb %d1,%fp@(-102)
50e76: 1229 0014 moveb %a1@(20),%d1
50e7a: 1829 0010 moveb %a1@(16),%d4
50e7e: 1d41 ff99 moveb %d1,%fp@(-103)
50e82: 1229 0016 moveb %a1@(22),%d1
50e86: 3a40 moveaw %d0,%a5
50e88: 1d41 ff97 moveb %d1,%fp@(-105)
50e8c: 1229 0017 moveb %a1@(23),%d1
50e90: 1d41 ff96 moveb %d1,%fp@(-106)
50e94: 1229 0020 moveb %a1@(32),%d1
50e98: 1d41 ff9f moveb %d1,%fp@(-97)
50e9c: 1229 0021 moveb %a1@(33),%d1
50ea0: 1d41 ff9e moveb %d1,%fp@(-98)
50ea4: 1229 0022 moveb %a1@(34),%d1
50ea8: 1d41 ff9d moveb %d1,%fp@(-99)
50eac: 1229 0023 moveb %a1@(35),%d1
50eb0: 1d41 ff8f moveb %d1,%fp@(-113)
50eb4: 1229 0024 moveb %a1@(36),%d1
50eb8: 1d41 ffa1 moveb %d1,%fp@(-95)
50ebc: 1229 0025 moveb %a1@(37),%d1
50ec0: 1d41 ffa0 moveb %d1,%fp@(-96)
50ec4: 1229 0026 moveb %a1@(38),%d1
50ec8: 1d41 ffa5 moveb %d1,%fp@(-91)
50ecc: 1229 002c moveb %a1@(44),%d1
50ed0: 1e29 0027 moveb %a1@(39),%d7
50ed4: 1629 0028 moveb %a1@(40),%d3
50ed8: 1d41 ffa4 moveb %d1,%fp@(-92)
50edc: 1229 002d moveb %a1@(45),%d1
50ee0: 1a29 002f moveb %a1@(47),%d5
50ee4: 1d41 ffa3 moveb %d1,%fp@(-93)
50ee8: 1229 002e moveb %a1@(46),%d1
50eec: 1d41 ffa2 moveb %d1,%fp@(-94)
50ef0: 1229 0030 moveb %a1@(48),%d1
50ef4: 1d41 ffa7 moveb %d1,%fp@(-89)
50ef8: 1229 0031 moveb %a1@(49),%d1
sc = rtems_bdbuf_release( block);
50efc: 2f08 movel %a0,%sp@-
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
50efe: 1d41 ffa6 moveb %d1,%fp@(-90)
sc = rtems_bdbuf_release( block);
50f02: 4eb9 0004 f206 jsr 4f206 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
50f08: 588f addql #4,%sp
50f0a: 4a80 tstl %d0
50f0c: 671a beqs 50f28 <fat_init_volume_info+0x18c> <== ALWAYS TAKEN
{
rtems_disk_release(vol->dd);
50f0e: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
50f12: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
50f18: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50f1e: 7205 moveq #5,%d1 <== NOT EXECUTED
50f20: 2040 moveal %d0,%a0 <== NOT EXECUTED
50f22: 2081 movel %d1,%a0@ <== NOT EXECUTED
50f24: 6000 04fe braw 51424 <fat_init_volume_info+0x688> <== NOT EXECUTED
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
50f28: 4280 clrl %d0
50f2a: 1006 moveb %d6,%d0
50f2c: 4281 clrl %d1
50f2e: 122e ff95 moveb %fp@(-107),%d1
50f32: e188 lsll #8,%d0
50f34: 8081 orl %d1,%d0
if ( (vol->bps != 512) &&
50f36: 3200 movew %d0,%d1
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
50f38: 3480 movew %d0,%a2@
50f3a: 3040 moveaw %d0,%a0
if ( (vol->bps != 512) &&
50f3c: 0c81 0000 0200 cmpil #512,%d1
50f42: 6732 beqs 50f76 <fat_init_volume_info+0x1da> <== ALWAYS TAKEN
50f44: 0c81 0000 0400 cmpil #1024,%d1 <== NOT EXECUTED
50f4a: 672a beqs 50f76 <fat_init_volume_info+0x1da> <== NOT EXECUTED
(vol->bps != 1024) &&
50f4c: 0c81 0000 0800 cmpil #2048,%d1 <== NOT EXECUTED
50f52: 6722 beqs 50f76 <fat_init_volume_info+0x1da> <== NOT EXECUTED
(vol->bps != 2048) &&
50f54: 0c81 0000 1000 cmpil #4096,%d1 <== NOT EXECUTED
50f5a: 671a beqs 50f76 <fat_init_volume_info+0x1da> <== NOT EXECUTED
(vol->bps != 4096))
{
rtems_disk_release(vol->dd);
50f5c: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
50f60: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
50f66: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50f6c: 2240 moveal %d0,%a1 <== NOT EXECUTED
50f6e: 7016 moveq #22,%d0 <== NOT EXECUTED
50f70: 2280 movel %d0,%a1@ <== NOT EXECUTED
50f72: 6000 04b0 braw 51424 <fat_init_volume_info+0x688> <== NOT EXECUTED
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
50f76: 7c09 moveq #9,%d6
50f78: eca9 lsrl %d6,%d1
50f7a: 4200 clrb %d0
50f7c: 1c2e ff8f moveb %fp@(-113),%d6
50f80: 1540 0003 moveb %d0,%a2@(3)
50f84: 600c bras 50f92 <fat_init_volume_info+0x1f6>
i >>= 1, vol->sec_mul++);
50f86: e281 asrl #1,%d1 <== NOT EXECUTED
50f88: 102a 0003 moveb %a2@(3),%d0 <== NOT EXECUTED
50f8c: 5280 addql #1,%d0 <== NOT EXECUTED
50f8e: 1540 0003 moveb %d0,%a2@(3) <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
50f92: 0801 0000 btst #0,%d1
50f96: 67ee beqs 50f86 <fat_init_volume_info+0x1ea> <== NEVER TAKEN
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
50f98: 4281 clrl %d1
50f9a: 3208 movew %a0,%d1
50f9c: 4200 clrb %d0
50f9e: 1d46 ff8f moveb %d6,%fp@(-113)
50fa2: 2d41 ff90 movel %d1,%fp@(-112)
50fa6: 2241 moveal %d1,%a1
50fa8: 1540 0002 moveb %d0,%a2@(2)
50fac: 6010 bras 50fbe <fat_init_volume_info+0x222>
i >>= 1, vol->sec_log2++);
50fae: e281 asrl #1,%d1
50fb0: 102a 0002 moveb %a2@(2),%d0
50fb4: 3040 moveaw %d0,%a0
50fb6: 5288 addql #1,%a0
50fb8: 3008 movew %a0,%d0
50fba: 1540 0002 moveb %d0,%a2@(2)
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
50fbe: 0801 0000 btst #0,%d1
50fc2: 67ea beqs 50fae <fat_init_volume_info+0x212>
50fc4: 2d49 ff90 movel %a1,%fp@(-112)
50fc8: 1d46 ff8f moveb %d6,%fp@(-113)
i >>= 1, vol->sec_log2++);
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
50fcc: 1542 0004 moveb %d2,%a2@(4)
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
50fd0: 6700 0258 beqw 5122a <fat_init_volume_info+0x48e>
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
50fd4: 4281 clrl %d1
50fd6: 1202 moveb %d2,%d1
50fd8: 4200 clrb %d0
50fda: 226e ff90 moveal %fp@(-112),%a1
50fde: 1540 0005 moveb %d0,%a2@(5)
50fe2: 1c2e ff8f moveb %fp@(-113),%d6
50fe6: 6010 bras 50ff8 <fat_init_volume_info+0x25c>
i >>= 1, vol->spc_log2++);
50fe8: e281 asrl #1,%d1
50fea: 102a 0005 moveb %a2@(5),%d0
50fee: 3040 moveaw %d0,%a0
50ff0: 5288 addql #1,%a0
50ff2: 3008 movew %a0,%d0
50ff4: 1540 0005 moveb %d0,%a2@(5)
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
50ff8: 0801 0000 btst #0,%d1
50ffc: 67ea beqs 50fe8 <fat_init_volume_info+0x24c>
i >>= 1, vol->spc_log2++);
/*
* "bytes per cluster" value greater than 32K is invalid
*/
if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
50ffe: 4281 clrl %d1
51000: 122a 0005 moveb %a2@(5),%d1
51004: 4280 clrl %d0
51006: 1d46 ff8f moveb %d6,%fp@(-113)
5100a: 2c09 movel %a1,%d6
5100c: e3ae lsll %d1,%d6
5100e: 2d49 ff90 movel %a1,%fp@(-112)
51012: 3006 movew %d6,%d0
51014: 3546 0006 movew %d6,%a2@(6)
51018: 2040 moveal %d0,%a0
5101a: b1fc 0000 8000 cmpal #32768,%a0
51020: 6200 0208 bhiw 5122a <fat_init_volume_info+0x48e>
51024: 226e ff90 moveal %fp@(-112),%a1
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
51028: 2208 movel %a0,%d1
5102a: 4200 clrb %d0
5102c: 1c2e ff8f moveb %fp@(-113),%d6
51030: 1540 0008 moveb %d0,%a2@(8)
51034: 6010 bras 51046 <fat_init_volume_info+0x2aa>
i >>= 1, vol->bpc_log2++);
51036: e281 asrl #1,%d1
51038: 102a 0008 moveb %a2@(8),%d0
5103c: 3040 moveaw %d0,%a0
5103e: 5288 addql #1,%a0
51040: 3008 movew %a0,%d0
51042: 1540 0008 moveb %d0,%a2@(8)
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
51046: 0801 0000 btst #0,%d1
5104a: 67ea beqs 51036 <fat_init_volume_info+0x29a>
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
5104c: 4280 clrl %d0
5104e: 102e ff9b moveb %fp@(-101),%d0
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
51052: 320d movew %a5,%d1
51054: 1d46 ff8f moveb %d6,%fp@(-113)
51058: 3c0c movew %a4,%d6
5105a: 0281 0000 00ff andil #255,%d1
51060: 2d49 ff90 movel %a1,%fp@(-112)
51064: 0286 0000 00ff andil #255,%d6
5106a: e189 lsll #8,%d1
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
5106c: e188 lsll #8,%d0
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
5106e: 8286 orl %d6,%d1
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
51070: 1544 0009 moveb %d4,%a2@(9)
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
51074: 3041 moveaw %d1,%a0
51076: 3541 0014 movew %d1,%a2@(20)
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
5107a: 4281 clrl %d1
5107c: 122e ff9c moveb %fp@(-100),%d1
51080: 8081 orl %d1,%d0
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
51082: 2200 movel %d0,%d1
51084: eb89 lsll #5,%d1
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
51086: 3540 001e movew %d0,%a2@(30)
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
5108a: 49f1 18ff lea %a1@(ffffffff,%d1:l),%a4
5108e: 2209 movel %a1,%d1
51090: 200c movel %a4,%d0
51092: 4c41 0800 remsl %d1,%d0,%d0
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
51096: 4286 clrl %d6
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
51098: 2840 moveal %d0,%a4
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
5109a: 220c movel %a4,%d1
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
5109c: 1c2e ff97 moveb %fp@(-105),%d6
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
510a0: 2540 0020 movel %d0,%a2@(32)
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
510a4: 4280 clrl %d0
510a6: 102a 0002 moveb %a2@(2),%d0
510aa: e1a9 lsll %d0,%d1
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
510ac: 4280 clrl %d0
510ae: 102e ff96 moveb %fp@(-106),%d0
510b2: e188 lsll #8,%d0
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
510b4: 2541 0024 movel %d1,%a2@(36)
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
510b8: 8086 orl %d6,%d0
510ba: 4a40 tstw %d0
510bc: 6708 beqs 510c6 <fat_init_volume_info+0x32a> <== NEVER TAKEN
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
510be: 0280 0000 ffff andil #65535,%d0
510c4: 6022 bras 510e8 <fat_init_volume_info+0x34c>
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
510c6: 4280 clrl %d0 <== NOT EXECUTED
510c8: 4281 clrl %d1 <== NOT EXECUTED
510ca: 102e ffa0 moveb %fp@(-96),%d0 <== NOT EXECUTED
510ce: 122e ffa5 moveb %fp@(-91),%d1 <== NOT EXECUTED
510d2: 4286 clrl %d6 <== NOT EXECUTED
510d4: 1c2e ffa1 moveb %fp@(-95),%d6 <== NOT EXECUTED
510d8: 4841 swap %d1 <== NOT EXECUTED
510da: 4241 clrw %d1 <== NOT EXECUTED
510dc: e188 lsll #8,%d0 <== NOT EXECUTED
510de: 8081 orl %d1,%d0 <== NOT EXECUTED
510e0: 7218 moveq #24,%d1 <== NOT EXECUTED
510e2: 8086 orl %d6,%d0 <== NOT EXECUTED
510e4: e3af lsll %d1,%d7 <== NOT EXECUTED
510e6: 8087 orl %d7,%d0 <== NOT EXECUTED
510e8: 2540 0016 movel %d0,%a2@(22)
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
510ec: 4280 clrl %d0
510ee: 220c movel %a4,%d1
510f0: 0284 0000 00ff andil #255,%d4
510f6: 3008 movew %a0,%d0
510f8: 41ea 0016 lea %a2@(22),%a0
510fc: 4c10 4800 mulsl %a0@,%d4
51100: d880 addl %d0,%d4
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
51102: 4280 clrl %d0
51104: 102e ff99 moveb %fp@(-103),%d0
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
51108: d284 addl %d4,%d1
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
5110a: 2544 001a movel %d4,%a2@(26)
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
5110e: 4284 clrl %d4
51110: 182e ff9a moveb %fp@(-102),%d4
51114: e188 lsll #8,%d0
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
51116: 2541 002c movel %d1,%a2@(44)
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
5111a: 8084 orl %d4,%d0
5111c: 4a40 tstw %d0
5111e: 6708 beqs 51128 <fat_init_volume_info+0x38c> <== NEVER TAKEN
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
51120: 0280 0000 ffff andil #65535,%d0
51126: 6026 bras 5114e <fat_init_volume_info+0x3b2>
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
51128: 4280 clrl %d0 <== NOT EXECUTED
5112a: 4284 clrl %d4 <== NOT EXECUTED
5112c: 102e ff9e moveb %fp@(-98),%d0 <== NOT EXECUTED
51130: 182e ff9d moveb %fp@(-99),%d4 <== NOT EXECUTED
51134: e188 lsll #8,%d0 <== NOT EXECUTED
51136: 4844 swap %d4 <== NOT EXECUTED
51138: 4244 clrw %d4 <== NOT EXECUTED
5113a: 1c2e ff8f moveb %fp@(-113),%d6 <== NOT EXECUTED
5113e: 8084 orl %d4,%d0 <== NOT EXECUTED
51140: 4284 clrl %d4 <== NOT EXECUTED
51142: 182e ff9f moveb %fp@(-97),%d4 <== NOT EXECUTED
51146: 8084 orl %d4,%d0 <== NOT EXECUTED
51148: 7818 moveq #24,%d4 <== NOT EXECUTED
5114a: e9ae lsll %d4,%d6 <== NOT EXECUTED
5114c: 8086 orl %d6,%d0 <== NOT EXECUTED
5114e: 2540 0028 movel %d0,%a2@(40)
data_secs = vol->tot_secs - vol->data_fsec;
51152: 2c2a 0028 movel %a2@(40),%d6
51156: 9c81 subl %d1,%d6
51158: 2206 movel %d6,%d1
vol->data_cls = data_secs / vol->spc;
5115a: 0282 0000 00ff andil #255,%d2
51160: 4c42 1001 remul %d2,%d1,%d1
51164: 2541 0030 movel %d1,%a2@(48)
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
51168: 0c81 0000 0ff4 cmpil #4084,%d1
5116e: 6218 bhis 51188 <fat_init_volume_info+0x3ec> <== NEVER TAKEN
{
vol->type = FAT_FAT12;
vol->mask = FAT_FAT12_MASK;
51170: 223c 0000 0fff movel #4095,%d1
vol->eoc_val = FAT_FAT12_EOC;
51176: 243c 0000 0ff8 movel #4088,%d2
vol->data_cls = data_secs / vol->spc;
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
5117c: 7001 moveq #1,%d0
vol->mask = FAT_FAT12_MASK;
5117e: 2541 000c movel %d1,%a2@(12)
vol->data_cls = data_secs / vol->spc;
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
51182: 1540 000a moveb %d0,%a2@(10)
51186: 603a bras 511c2 <fat_init_volume_info+0x426>
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
51188: 0c81 0000 fff4 cmpil #65524,%d1 <== NOT EXECUTED
5118e: 621c bhis 511ac <fat_init_volume_info+0x410> <== NOT EXECUTED
{
vol->type = FAT_FAT16;
vol->mask = FAT_FAT16_MASK;
51190: 2c3c 0000 ffff movel #65535,%d6 <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
51196: 207c 0000 fff8 moveal #65528,%a0 <== NOT EXECUTED
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
5119c: 7802 moveq #2,%d4 <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
5119e: 2546 000c movel %d6,%a2@(12) <== NOT EXECUTED
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
511a2: 1544 000a moveb %d4,%a2@(10) <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
511a6: 2548 0010 movel %a0,%a2@(16) <== NOT EXECUTED
511aa: 601a bras 511c6 <fat_init_volume_info+0x42a> <== NOT EXECUTED
}
else
{
vol->type = FAT_FAT32;
511ac: 7004 moveq #4,%d0 <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
511ae: 223c 0fff ffff movel #268435455,%d1 <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
511b4: 1540 000a moveb %d0,%a2@(10) <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
511b8: 2541 000c movel %d1,%a2@(12) <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
511bc: 243c 0fff fff8 movel #268435448,%d2 <== NOT EXECUTED
511c2: 2542 0010 movel %d2,%a2@(16)
}
}
if (vol->type == FAT_FAT32)
511c6: 4280 clrl %d0
511c8: 102a 000a moveb %a2@(10),%d0
511cc: 7804 moveq #4,%d4
511ce: b880 cmpl %d0,%d4
511d0: 6600 01ac bnew 5137e <fat_init_volume_info+0x5e2>
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
511d4: 4280 clrl %d0 <== NOT EXECUTED
511d6: 4281 clrl %d1 <== NOT EXECUTED
511d8: 102e ffa3 moveb %fp@(-93),%d0 <== NOT EXECUTED
511dc: 122e ffa2 moveb %fp@(-94),%d1 <== NOT EXECUTED
511e0: 7c18 moveq #24,%d6 <== NOT EXECUTED
511e2: 4841 swap %d1 <== NOT EXECUTED
511e4: 4241 clrw %d1 <== NOT EXECUTED
511e6: e188 lsll #8,%d0 <== NOT EXECUTED
511e8: edad lsll %d6,%d5 <== NOT EXECUTED
511ea: 8081 orl %d1,%d0 <== NOT EXECUTED
511ec: 4281 clrl %d1 <== NOT EXECUTED
511ee: 122e ffa4 moveb %fp@(-92),%d1 <== NOT EXECUTED
511f2: 8081 orl %d1,%d0 <== NOT EXECUTED
511f4: 8085 orl %d5,%d0 <== NOT EXECUTED
511f6: 2540 0034 movel %d0,%a2@(52) <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
511fa: 7080 moveq #-128,%d0 <== NOT EXECUTED
511fc: c083 andl %d3,%d0 <== NOT EXECUTED
511fe: 1540 0042 moveb %d0,%a2@(66) <== NOT EXECUTED
if (vol->mirror)
51202: 670a beqs 5120e <fat_init_volume_info+0x472> <== NOT EXECUTED
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
51204: 700f moveq #15,%d0 <== NOT EXECUTED
51206: c680 andl %d0,%d3 <== NOT EXECUTED
51208: 1543 0048 moveb %d3,%a2@(72) <== NOT EXECUTED
5120c: 6006 bras 51214 <fat_init_volume_info+0x478> <== NOT EXECUTED
else
vol->afat = 0;
5120e: 4201 clrb %d1 <== NOT EXECUTED
51210: 1541 0048 moveb %d1,%a2@(72) <== NOT EXECUTED
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
51214: 4280 clrl %d0 <== NOT EXECUTED
51216: 102e ffa6 moveb %fp@(-90),%d0 <== NOT EXECUTED
5121a: 4281 clrl %d1 <== NOT EXECUTED
5121c: 122e ffa7 moveb %fp@(-89),%d1 <== NOT EXECUTED
51220: e188 lsll #8,%d0 <== NOT EXECUTED
51222: 8081 orl %d1,%d0 <== NOT EXECUTED
51224: 3540 0038 movew %d0,%a2@(56) <== NOT EXECUTED
if( vol->info_sec == 0 )
51228: 661a bnes 51244 <fat_init_volume_info+0x4a8> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
5122a: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
5122e: 7e16 moveq #22,%d7 <== NOT EXECUTED
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
if( vol->info_sec == 0 )
{
rtems_disk_release(vol->dd);
51230: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
51236: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5123c: 2040 moveal %d0,%a0 <== NOT EXECUTED
5123e: 2087 movel %d7,%a0@ <== NOT EXECUTED
51240: 6000 01e2 braw 51424 <fat_init_volume_info+0x688> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , 0,
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
51244: 49ee fff0 lea %fp@(-16),%a4 <== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , 0,
51248: 4bf9 0005 08b2 lea 508b2 <_fat_block_read>,%a5 <== NOT EXECUTED
5124e: 2f0c movel %a4,%sp@- <== NOT EXECUTED
51250: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
51254: 42a7 clrl %sp@- <== NOT EXECUTED
51256: 3f00 movew %d0,%sp@- <== NOT EXECUTED
51258: 4267 clrw %sp@- <== NOT EXECUTED
5125a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5125c: 4e95 jsr %a5@ <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
5125e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
51262: 4a80 tstl %d0 <== NOT EXECUTED
51264: 6c0e bges 51274 <fat_init_volume_info+0x4d8> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
51266: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
5126a: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
51270: 6000 01b2 braw 51424 <fat_init_volume_info+0x688> <== NOT EXECUTED
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
51274: 4280 clrl %d0 <== NOT EXECUTED
51276: 4281 clrl %d1 <== NOT EXECUTED
51278: 102c 0001 moveb %a4@(1),%d0 <== NOT EXECUTED
5127c: 122c 0002 moveb %a4@(2),%d1 <== NOT EXECUTED
51280: 7418 moveq #24,%d2 <== NOT EXECUTED
51282: 4841 swap %d1 <== NOT EXECUTED
51284: 4241 clrw %d1 <== NOT EXECUTED
51286: e188 lsll #8,%d0 <== NOT EXECUTED
51288: 8081 orl %d1,%d0 <== NOT EXECUTED
5128a: 4281 clrl %d1 <== NOT EXECUTED
5128c: 1214 moveb %a4@,%d1 <== NOT EXECUTED
5128e: 8081 orl %d1,%d0 <== NOT EXECUTED
51290: 122c 0003 moveb %a4@(3),%d1 <== NOT EXECUTED
51294: e5a9 lsll %d2,%d1 <== NOT EXECUTED
51296: 8081 orl %d1,%d0 <== NOT EXECUTED
51298: 0c80 4161 5252 cmpil #1096897106,%d0 <== NOT EXECUTED
5129e: 6724 beqs 512c4 <fat_init_volume_info+0x528> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
512a0: 2f2b 0034 movel %a3@(52),%sp@- <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
512a4: 7c16 moveq #22,%d6 <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
512a6: 4eb9 0005 0780 jsr 50780 <fat_buf_release> <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
512ac: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
512b0: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
512b6: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
512bc: 2040 moveal %d0,%a0 <== NOT EXECUTED
512be: 2086 movel %d6,%a0@ <== NOT EXECUTED
512c0: 6000 01de braw 514a0 <fat_init_volume_info+0x704> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
512c4: 2f0c movel %a4,%sp@- <== NOT EXECUTED
512c6: 4878 000c pea c <OPER1> <== NOT EXECUTED
512ca: 4280 clrl %d0 <== NOT EXECUTED
512cc: 4878 01e4 pea 1e4 <DBL_MANT_DIG+0x1af> <== NOT EXECUTED
512d0: 302a 0038 movew %a2@(56),%d0 <== NOT EXECUTED
512d4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
512d6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
512d8: 4e95 jsr %a5@ <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
512da: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
512de: 4a80 tstl %d0 <== NOT EXECUTED
512e0: 6c18 bges 512fa <fat_init_volume_info+0x55e> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
512e2: 2f2b 0034 movel %a3@(52),%sp@- <== NOT EXECUTED
512e6: 4eb9 0005 0780 jsr 50780 <fat_buf_release> <== NOT EXECUTED
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
512ec: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
512f0: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
512f6: 6000 01a8 braw 514a0 <fat_init_volume_info+0x704> <== NOT EXECUTED
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
512fa: 4280 clrl %d0 <== NOT EXECUTED
512fc: 4281 clrl %d1 <== NOT EXECUTED
512fe: 102c 0005 moveb %a4@(5),%d0 <== NOT EXECUTED
51302: 122c 0006 moveb %a4@(6),%d1 <== NOT EXECUTED
51306: 7418 moveq #24,%d2 <== NOT EXECUTED
51308: 4841 swap %d1 <== NOT EXECUTED
5130a: 4241 clrw %d1 <== NOT EXECUTED
5130c: e188 lsll #8,%d0 <== NOT EXECUTED
5130e: 8081 orl %d1,%d0 <== NOT EXECUTED
51310: 4281 clrl %d1 <== NOT EXECUTED
51312: 122c 0004 moveb %a4@(4),%d1 <== NOT EXECUTED
51316: 8081 orl %d1,%d0 <== NOT EXECUTED
51318: 122c 0007 moveb %a4@(7),%d1 <== NOT EXECUTED
5131c: e5a9 lsll %d2,%d1 <== NOT EXECUTED
5131e: 8081 orl %d1,%d0 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
51320: 4281 clrl %d1 <== NOT EXECUTED
51322: 122c 000a moveb %a4@(10),%d1 <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
51326: 2540 003a movel %d0,%a2@(58) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
5132a: 4280 clrl %d0 <== NOT EXECUTED
5132c: 102c 0009 moveb %a4@(9),%d0 <== NOT EXECUTED
51330: 4841 swap %d1 <== NOT EXECUTED
51332: 4241 clrw %d1 <== NOT EXECUTED
51334: e188 lsll #8,%d0 <== NOT EXECUTED
51336: 8081 orl %d1,%d0 <== NOT EXECUTED
51338: 4281 clrl %d1 <== NOT EXECUTED
5133a: 122c 0008 moveb %a4@(8),%d1 <== NOT EXECUTED
5133e: 8081 orl %d1,%d0 <== NOT EXECUTED
51340: 122c 000b moveb %a4@(11),%d1 <== NOT EXECUTED
51344: e5a9 lsll %d2,%d1 <== NOT EXECUTED
51346: 8081 orl %d1,%d0 <== NOT EXECUTED
51348: 2540 003e movel %d0,%a2@(62) <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
5134c: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
51350: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
51354: 2f0b movel %a3,%sp@- <== NOT EXECUTED
51356: 4eb9 0005 0c16 jsr 50c16 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
5135c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
51360: 2400 movel %d0,%d2 <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
51362: 6732 beqs 51396 <fat_init_volume_info+0x5fa> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
51364: 2f2b 0034 movel %a3@(52),%sp@- <== NOT EXECUTED
51368: 4eb9 0005 0780 jsr 50780 <fat_buf_release> <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
0xFFFFFFFF);
if ( rc != RC_OK )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
5136e: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
51372: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
return rc;
51378: 508f addql #8,%sp <== NOT EXECUTED
5137a: 6000 01a2 braw 5151e <fat_init_volume_info+0x782> <== NOT EXECUTED
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = 0xFFFFFFFF;
5137e: 7cff moveq #-1,%d6
}
}
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
51380: 4204 clrb %d4
}
}
}
else
{
vol->rdir_cl = 0;
51382: 42aa 0034 clrl %a2@(52)
vol->mirror = 0;
51386: 1544 0042 moveb %d4,%a2@(66)
vol->afat = 0;
5138a: 1544 0048 moveb %d4,%a2@(72)
vol->free_cls = 0xFFFFFFFF;
5138e: 2546 003a movel %d6,%a2@(58)
vol->next_cl = 0xFFFFFFFF;
51392: 2546 003e movel %d6,%a2@(62)
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
51396: 2f2b 0034 movel %a3@(52),%sp@-
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
5139a: 47f9 0004 4e3c lea 44e3c <calloc>,%a3
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
513a0: 4eb9 0005 0780 jsr 50780 <fat_buf_release>
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
513a6: 4280 clrl %d0
513a8: 102a 0048 moveb %a2@(72),%d0
513ac: 41ea 0016 lea %a2@(22),%a0
513b0: 4c10 0800 mulsl %a0@,%d0
513b4: 4281 clrl %d1
513b6: 322a 0014 movew %a2@(20),%d1
513ba: d081 addl %d1,%d0
513bc: 2540 0044 movel %d0,%a2@(68)
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
513c0: 4878 000c pea c <OPER1>
513c4: 4878 0002 pea 2 <DOUBLE_FLOAT>
513c8: 4e93 jsr %a3@
if ( fs_info->vhash == NULL )
513ca: 4fef 000c lea %sp@(12),%sp
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
513ce: 2040 moveal %d0,%a0
513d0: 2540 005a movel %d0,%a2@(90)
if ( fs_info->vhash == NULL )
513d4: 6738 beqs 5140e <fat_init_volume_info+0x672> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
513d6: 2240 moveal %d0,%a1
513d8: 5889 addql #4,%a1
513da: 2089 movel %a1,%a0@
513dc: 43e8 0010 lea %a0@(16),%a1
513e0: 2149 000c movel %a1,%a0@(12)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
513e4: 43e8 000c lea %a0@(12),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
513e8: 42a8 0004 clrl %a0@(4)
tail->previous = head;
513ec: 2140 0008 movel %d0,%a0@(8)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
513f0: 42a8 0010 clrl %a0@(16)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
513f4: 2149 0014 movel %a1,%a0@(20)
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
513f8: 4878 000c pea c <OPER1>
513fc: 4878 0002 pea 2 <DOUBLE_FLOAT>
51400: 4e93 jsr %a3@
if ( fs_info->rhash == NULL )
51402: 508f addql #8,%sp
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
51404: 2040 moveal %d0,%a0
51406: 2540 005e movel %d0,%a2@(94)
if ( fs_info->rhash == NULL )
5140a: 661e bnes 5142a <fat_init_volume_info+0x68e> <== ALWAYS TAKEN
5140c: 6072 bras 51480 <fat_init_volume_info+0x6e4> <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
rtems_disk_release(vol->dd);
5140e: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
51412: 7a0c moveq #12,%d5 <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
rtems_disk_release(vol->dd);
51414: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
5141a: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
51420: 2040 moveal %d0,%a0 <== NOT EXECUTED
51422: 2085 movel %d5,%a0@ <== NOT EXECUTED
51424: 588f addql #4,%sp <== NOT EXECUTED
51426: 6000 00f0 braw 51518 <fat_init_volume_info+0x77c> <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
5142a: 2240 moveal %d0,%a1
5142c: 5889 addql #4,%a1
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
5142e: 4281 clrl %d1
51430: 2089 movel %a1,%a0@
51432: 43e8 0010 lea %a0@(16),%a1
51436: 2149 000c movel %a1,%a0@(12)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
5143a: 43e8 000c lea %a0@(12),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
5143e: 2140 0008 movel %d0,%a0@(8)
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
51442: 203c 0000 0100 movel #256,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
51448: 42a8 0004 clrl %a0@(4)
5144c: 42a8 0010 clrl %a0@(16)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
51450: 2149 0014 movel %a1,%a0@(20)
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
51454: 122a 0003 moveb %a2@(3),%d1
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
51458: 2540 006a movel %d0,%a2@(106)
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
5145c: 202a 0028 movel %a2@(40),%d0
51460: e3a8 lsll %d1,%d0
fs_info->index = 0;
51462: 42aa 0066 clrl %a2@(102)
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
51466: e988 lsll #4,%d0
51468: 2540 006e movel %d0,%a2@(110)
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
5146c: 4878 0001 pea 1 <ADD>
51470: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
51474: 4e93 jsr %a3@
if ( fs_info->uino == NULL )
51476: 508f addql #8,%sp
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
51478: 2540 0062 movel %d0,%a2@(98)
if ( fs_info->uino == NULL )
5147c: 6654 bnes 514d2 <fat_init_volume_info+0x736> <== ALWAYS TAKEN
5147e: 6024 bras 514a4 <fat_init_volume_info+0x708> <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->rhash == NULL )
{
rtems_disk_release(vol->dd);
51480: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
free(fs_info->vhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
51484: 780c moveq #12,%d4 <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->rhash == NULL )
{
rtems_disk_release(vol->dd);
51486: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
5148c: 2f2a 005a movel %a2@(90),%sp@- <== NOT EXECUTED
51490: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
51496: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5149c: 2040 moveal %d0,%a0 <== NOT EXECUTED
5149e: 2084 movel %d4,%a0@ <== NOT EXECUTED
514a0: 508f addql #8,%sp <== NOT EXECUTED
514a2: 6074 bras 51518 <fat_init_volume_info+0x77c> <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
rtems_disk_release(vol->dd);
514a4: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
free(fs_info->vhash);
514a8: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
514ae: 760c moveq #12,%d3 <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
rtems_disk_release(vol->dd);
514b0: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
514b6: 2f2a 005a movel %a2@(90),%sp@- <== NOT EXECUTED
514ba: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->rhash);
514bc: 2f2a 005e movel %a2@(94),%sp@- <== NOT EXECUTED
514c0: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
514c2: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
514c8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
514cc: 2240 moveal %d0,%a1 <== NOT EXECUTED
514ce: 2283 movel %d3,%a1@ <== NOT EXECUTED
514d0: 6046 bras 51518 <fat_init_volume_info+0x77c> <== NOT EXECUTED
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
514d2: 4878 0001 pea 1 <ADD>
514d6: 4280 clrl %d0
514d8: 3012 movew %a2@,%d0
514da: 2f00 movel %d0,%sp@-
514dc: 4e93 jsr %a3@
if (fs_info->sec_buf == NULL)
514de: 508f addql #8,%sp
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
514e0: 2540 007c movel %d0,%a2@(124)
if (fs_info->sec_buf == NULL)
514e4: 6636 bnes 5151c <fat_init_volume_info+0x780> <== ALWAYS TAKEN
{
rtems_disk_release(vol->dd);
514e6: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
free(fs_info->vhash);
514ea: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
free(fs_info->rhash);
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
514f0: 740c moveq #12,%d2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
if (fs_info->sec_buf == NULL)
{
rtems_disk_release(vol->dd);
514f2: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
514f8: 2f2a 005a movel %a2@(90),%sp@- <== NOT EXECUTED
514fc: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->rhash);
514fe: 2f2a 005e movel %a2@(94),%sp@- <== NOT EXECUTED
51502: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->uino);
51504: 2f2a 0062 movel %a2@(98),%sp@- <== NOT EXECUTED
51508: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
5150a: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
51510: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
51514: 2040 moveal %d0,%a0 <== NOT EXECUTED
51516: 2082 movel %d2,%a0@ <== NOT EXECUTED
51518: 74ff moveq #-1,%d2 <== NOT EXECUTED
5151a: 6002 bras 5151e <fat_init_volume_info+0x782> <== NOT EXECUTED
}
return RC_OK;
5151c: 4282 clrl %d2
}
5151e: 2002 movel %d2,%d0
51520: 4cee 3cfc ff64 moveml %fp@(-156),%d2-%d7/%a2-%a5
51526: 4e5e unlk %fp
...
0005750c <fat_scan_fat_for_free_clusters>:
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
5750c: 4e56 ffd4 linkw %fp,#-44
57510: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
57514: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
57518: 246b 0034 moveal %a3@(52),%a2
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
5751c: 286e 0014 moveal %fp@(20),%a4
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
57520: 2e2a 0030 movel %a2@(48),%d7
57524: 5487 addql #2,%d7
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
57526: 2a6e 000c moveal %fp@(12),%a5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
5752a: 42ae fffc clrl %fp@(-4)
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
5752e: 4294 clrl %a4@
if (count == 0)
57530: 4aae 0010 tstl %fp@(16)
57534: 6700 0138 beqw 5766e <fat_scan_fat_for_free_clusters+0x162>
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
57538: 242a 003e movel %a2@(62),%d2
5753c: 70ff moveq #-1,%d0
5753e: b082 cmpl %d2,%d0
57540: 6602 bnes 57544 <fat_scan_fat_for_free_clusters+0x38>
uint32_t *last_cl
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
57542: 7402 moveq #2,%d2
}
}
i++;
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
57544: 7c02 moveq #2,%d6
57546: 4284 clrl %d4
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
57548: 2a3c 0005 7204 movel #356868,%d5
5754e: 6000 00f4 braw 57644 <fat_scan_fat_for_free_clusters+0x138>
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
57552: 486e fffc pea %fp@(-4)
57556: 2f02 movel %d2,%sp@-
57558: 2f0b movel %a3,%sp@-
5755a: 4eb9 0005 708c jsr 5708c <fat_get_fat_cluster>
if ( rc != RC_OK )
57560: 4fef 000c lea %sp@(12),%sp
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
57564: 2600 movel %d0,%d3
if ( rc != RC_OK )
57566: 6716 beqs 5757e <fat_scan_fat_for_free_clusters+0x72><== ALWAYS TAKEN
{
if (*cls_added != 0)
57568: 4a94 tstl %a4@ <== NOT EXECUTED
5756a: 6700 0108 beqw 57674 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, (*chain));
5756e: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
57570: 2f0b movel %a3,%sp@- <== NOT EXECUTED
57572: 4eb9 0005 7462 jsr 57462 <fat_free_fat_clusters_chain> <== NOT EXECUTED
57578: 508f addql #8,%sp <== NOT EXECUTED
5757a: 6000 00f8 braw 57674 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
5757e: 4aae fffc tstl %fp@(-4)
57582: 6600 00b6 bnew 5763a <fat_scan_fat_for_free_clusters+0x12e>
/*
* We are enforced to process allocation of the first free cluster
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
57586: 4a94 tstl %a4@
57588: 661a bnes 575a4 <fat_scan_fat_for_free_clusters+0x98><== NEVER TAKEN
{
*chain = cl4find;
5758a: 2a82 movel %d2,%a5@
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
5758c: 4878 ffff pea ffffffff <LESS>
57590: 2045 moveal %d5,%a0
57592: 2f02 movel %d2,%sp@-
57594: 2f0b movel %a3,%sp@-
57596: 4e90 jsr %a0@
if ( rc != RC_OK )
57598: 4fef 000c lea %sp@(12),%sp
5759c: 4a80 tstl %d0
5759e: 6766 beqs 57606 <fat_scan_fat_for_free_clusters+0xfa><== ALWAYS TAKEN
575a0: 6000 00d0 braw 57672 <fat_scan_fat_for_free_clusters+0x166><== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
575a4: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
575a8: 2045 moveal %d5,%a0 <== NOT EXECUTED
575aa: 2f02 movel %d2,%sp@- <== NOT EXECUTED
575ac: 2f0b movel %a3,%sp@- <== NOT EXECUTED
575ae: 4e90 jsr %a0@ <== NOT EXECUTED
if ( rc != RC_OK )
575b0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
575b4: 4a80 tstl %d0 <== NOT EXECUTED
575b6: 6714 beqs 575cc <fat_scan_fat_for_free_clusters+0xc0><== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
575b8: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
575ba: 2e00 movel %d0,%d7 <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
575bc: 2607 movel %d7,%d3 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
575be: 2f0b movel %a3,%sp@- <== NOT EXECUTED
575c0: 4eb9 0005 7462 jsr 57462 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
575c6: 508f addql #8,%sp <== NOT EXECUTED
575c8: 6000 00aa braw 57674 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
575cc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
575ce: 2045 moveal %d5,%a0 <== NOT EXECUTED
575d0: 2f04 movel %d4,%sp@- <== NOT EXECUTED
575d2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
575d4: 4e90 jsr %a0@ <== NOT EXECUTED
if ( rc != RC_OK )
575d6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
575da: 4a80 tstl %d0 <== NOT EXECUTED
575dc: 6728 beqs 57606 <fat_scan_fat_for_free_clusters+0xfa><== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
575de: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
575e0: 2800 movel %d0,%d4 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
575e2: 2604 movel %d4,%d3 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
575e4: 2f0b movel %a3,%sp@- <== NOT EXECUTED
575e6: 4eb9 0005 7462 jsr 57462 <fat_free_fat_clusters_chain> <== NOT EXECUTED
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_FREE);
575ec: 42a7 clrl %sp@- <== NOT EXECUTED
575ee: 2f02 movel %d2,%sp@- <== NOT EXECUTED
575f0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
575f2: 4eb9 0005 7204 jsr 57204 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
575f8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
575fa: 4eb9 0005 0780 jsr 50780 <fat_buf_release> <== NOT EXECUTED
return rc;
57600: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
57604: 606e bras 57674 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
}
}
save_cln = cl4find;
(*cls_added)++;
57606: 2014 movel %a4@,%d0
57608: 5280 addql #1,%d0
5760a: 2880 movel %d0,%a4@
/* have we satisfied request ? */
if (*cls_added == count)
5760c: b0ae 0010 cmpl %fp@(16),%d0
57610: 6626 bnes 57638 <fat_scan_fat_for_free_clusters+0x12c><== NEVER TAKEN
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
57612: 202a 003a movel %a2@(58),%d0
57616: 72ff moveq #-1,%d1
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
57618: 2542 003e movel %d2,%a2@(62)
if (fs_info->vol.free_cls != 0xFFFFFFFF)
5761c: b280 cmpl %d0,%d1
5761e: 6706 beqs 57626 <fat_scan_fat_for_free_clusters+0x11a><== ALWAYS TAKEN
fs_info->vol.free_cls -= (*cls_added);
57620: 9094 subl %a4@,%d0 <== NOT EXECUTED
57622: 2540 003a movel %d0,%a2@(58) <== NOT EXECUTED
*last_cl = save_cln;
57626: 206e 0018 moveal %fp@(24),%a0
5762a: 2082 movel %d2,%a0@
fat_buf_release(fs_info);
5762c: 2f0a movel %a2,%sp@-
5762e: 4eb9 0005 0780 jsr 50780 <fat_buf_release>
return rc;
57634: 588f addql #4,%sp
57636: 603c bras 57674 <fat_scan_fat_for_free_clusters+0x168>
save_cln = cl4find;
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
57638: 2802 movel %d2,%d4 <== NOT EXECUTED
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
}
}
i++;
5763a: 5286 addql #1,%d6
cl4find++;
5763c: 5282 addql #1,%d2
if (cl4find >= data_cls_val)
5763e: be82 cmpl %d2,%d7
57640: 6202 bhis 57644 <fat_scan_fat_for_free_clusters+0x138><== ALWAYS TAKEN
cl4find = 2;
57642: 7402 moveq #2,%d2 <== NOT EXECUTED
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
57644: be86 cmpl %d6,%d7
57646: 6200 ff0a bhiw 57552 <fat_scan_fat_for_free_clusters+0x46>
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
5764a: 202a 003a movel %a2@(58),%d0 <== NOT EXECUTED
5764e: 72ff moveq #-1,%d1 <== NOT EXECUTED
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
57650: 2544 003e movel %d4,%a2@(62) <== NOT EXECUTED
if (fs_info->vol.free_cls != 0xFFFFFFFF)
57654: b280 cmpl %d0,%d1 <== NOT EXECUTED
57656: 6706 beqs 5765e <fat_scan_fat_for_free_clusters+0x152><== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
57658: 9094 subl %a4@,%d0 <== NOT EXECUTED
5765a: 2540 003a movel %d0,%a2@(58) <== NOT EXECUTED
*last_cl = save_cln;
5765e: 206e 0018 moveal %fp@(24),%a0 <== NOT EXECUTED
57662: 2084 movel %d4,%a0@ <== NOT EXECUTED
fat_buf_release(fs_info);
57664: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57666: 4eb9 0005 0780 jsr 50780 <fat_buf_release> <== NOT EXECUTED
return RC_OK;
5766c: 588f addql #4,%sp <== NOT EXECUTED
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
return rc;
5766e: 4283 clrl %d3 <== NOT EXECUTED
57670: 6002 bras 57674 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
57672: 2600 movel %d0,%d3 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
fat_buf_release(fs_info);
return RC_OK;
}
57674: 2003 movel %d3,%d0
57676: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
5767c: 4e5e unlk %fp <== NOT EXECUTED
00057204 <fat_set_fat_cluster>:
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
57204: 7001 moveq #1,%d0
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
57206: 4e56 ffd8 linkw %fp,#-40
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
5720a: 206e 0008 moveal %fp@(8),%a0
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
5720e: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
57212: 242e 000c movel %fp@(12),%d2
57216: 2a2e 0010 movel %fp@(16),%d5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
5721a: 2468 0034 moveal %a0@(52),%a2
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
5721e: 42ae fffc clrl %fp@(-4)
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
57222: b082 cmpl %d2,%d0
57224: 6400 0222 bccw 57448 <fat_set_fat_cluster+0x244>
57228: 202a 0030 movel %a2@(48),%d0
5722c: 5280 addql #1,%d0
5722e: b082 cmpl %d2,%d0
57230: 6500 0216 bcsw 57448 <fat_set_fat_cluster+0x244>
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
57234: 4280 clrl %d0
57236: 102a 000a moveb %a2@(10),%d0
5723a: 7601 moveq #1,%d3
5723c: 2202 movel %d2,%d1
5723e: c680 andl %d0,%d3
57240: 6706 beqs 57248 <fat_set_fat_cluster+0x44> <== NEVER TAKEN
57242: e289 lsrl #1,%d1
57244: d282 addl %d2,%d1
57246: 600c bras 57254 <fat_set_fat_cluster+0x50>
57248: 0800 0001 btst #1,%d0 <== NOT EXECUTED
5724c: 6704 beqs 57252 <fat_set_fat_cluster+0x4e> <== NOT EXECUTED
5724e: d281 addl %d1,%d1 <== NOT EXECUTED
57250: 6002 bras 57254 <fat_set_fat_cluster+0x50> <== NOT EXECUTED
57252: e589 lsll #2,%d1 <== NOT EXECUTED
57254: 4284 clrl %d4
57256: 182a 0002 moveb %a2@(2),%d4
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
5725a: 2e02 movel %d2,%d7
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
5725c: e8a9 lsrl %d4,%d1
5725e: 2641 moveal %d1,%a3
57260: d7ea 0044 addal %a2@(68),%a3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
57264: 4a83 tstl %d3
57266: 6706 beqs 5726e <fat_set_fat_cluster+0x6a> <== NEVER TAKEN
57268: e28f lsrl #1,%d7
5726a: de82 addl %d2,%d7
5726c: 600c bras 5727a <fat_set_fat_cluster+0x76>
5726e: 0800 0001 btst #1,%d0 <== NOT EXECUTED
57272: 6704 beqs 57278 <fat_set_fat_cluster+0x74> <== NOT EXECUTED
57274: de87 addl %d7,%d7 <== NOT EXECUTED
57276: 6002 bras 5727a <fat_set_fat_cluster+0x76> <== NOT EXECUTED
57278: e58f lsll #2,%d7 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
5727a: 2c0e movel %fp,%d6
5727c: 5986 subql #4,%d6
5727e: 49f9 0005 05a0 lea 505a0 <fat_buf_access>,%a4
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
57284: 3612 movew %a2@,%d3
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
57286: 2f06 movel %d6,%sp@-
57288: 4878 0001 pea 1 <ADD>
5728c: 2f0b movel %a3,%sp@-
5728e: 2f0a movel %a2,%sp@-
57290: 4e94 jsr %a4@
if (rc != RC_OK)
57292: 4fef 0010 lea %sp@(16),%sp
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
57296: 2800 movel %d0,%d4
if (rc != RC_OK)
57298: 6600 01bc bnew 57456 <fat_set_fat_cluster+0x252>
return rc;
switch ( fs_info->vol.type )
5729c: 4280 clrl %d0
5729e: 102a 000a moveb %a2@(10),%d0
572a2: 7202 moveq #2,%d1
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
572a4: 0283 0000 ffff andil #65535,%d3
572aa: 5383 subql #1,%d3
572ac: c687 andl %d7,%d3
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
572ae: b280 cmpl %d0,%d1
572b0: 6700 0142 beqw 573f4 <fat_set_fat_cluster+0x1f0>
572b4: 123c 0004 moveb #4,%d1
572b8: b280 cmpl %d0,%d1
572ba: 6700 015a beqw 57416 <fat_set_fat_cluster+0x212>
572be: 123c 0001 moveb #1,%d1
572c2: b280 cmpl %d0,%d1
572c4: 6600 0182 bnew 57448 <fat_set_fat_cluster+0x244>
572c8: 206e fffc moveal %fp@(-4),%a0
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
572cc: 0802 0000 btst #0,%d2
572d0: 6700 0084 beqw 57356 <fat_set_fat_cluster+0x152>
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
572d4: 2068 001e moveal %a0@(30),%a0
572d8: d1c3 addal %d3,%a0
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
572da: 123c 000f moveb #15,%d1
572de: 1010 moveb %a0@,%d0
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
572e0: e98d lsll #4,%d5
*((uint8_t *)(block0->buffer + ofs)) =
572e2: c081 andl %d1,%d0
572e4: 1080 moveb %d0,%a0@
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
572e6: 206e fffc moveal %fp@(-4),%a0
572ea: 2068 001e moveal %a0@(30),%a0
572ee: d1c3 addal %d3,%a0
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
572f0: 1010 moveb %a0@,%d0
572f2: 8085 orl %d5,%d0
572f4: 1080 moveb %d0,%a0@
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
572f6: 7001 moveq #1,%d0
572f8: 1540 0076 moveb %d0,%a2@(118)
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
572fc: 4280 clrl %d0
572fe: 3012 movew %a2@,%d0
57300: 5380 subql #1,%d0
57302: b083 cmpl %d3,%d0
57304: 663c bnes 57342 <fat_set_fat_cluster+0x13e> <== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
57306: 2f06 movel %d6,%sp@- <== NOT EXECUTED
57308: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5730c: 486b 0001 pea %a3@(1) <== NOT EXECUTED
57310: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57312: 4e94 jsr %a4@ <== NOT EXECUTED
&block0);
if (rc != RC_OK)
57314: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
57318: 2800 movel %d0,%d4 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
5731a: 6600 013a bnew 57456 <fat_set_fat_cluster+0x252> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
5731e: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
57322: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
57326: 4210 clrb %a0@ <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
57328: 0285 0000 ffff andil #65535,%d5 <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
5732e: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
(uint8_t )((fat16_clv & 0xFF00)>>8);
57332: e08d lsrl #8,%d5 <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
57334: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
57338: 1010 moveb %a0@,%d0 <== NOT EXECUTED
5733a: 8a80 orl %d0,%d5 <== NOT EXECUTED
5733c: 1085 moveb %d5,%a0@ <== NOT EXECUTED
5733e: 6000 0100 braw 57440 <fat_set_fat_cluster+0x23c> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
57342: 206e fffc moveal %fp@(-4),%a0
57346: 5283 addql #1,%d3
57348: 2068 001e moveal %a0@(30),%a0
5734c: 4200 clrb %d0
5734e: 1180 3800 moveb %d0,%a0@(00000000,%d3:l)
57352: 6000 0086 braw 573da <fat_set_fat_cluster+0x1d6>
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
57356: 2068 001e moveal %a0@(30),%a0
5735a: 4201 clrb %d1
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
5735c: 0285 0000 0fff andil #4095,%d5
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
57362: 1181 3800 moveb %d1,%a0@(00000000,%d3:l)
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
57366: 206e fffc moveal %fp@(-4),%a0
5736a: 2068 001e moveal %a0@(30),%a0
5736e: d1c3 addal %d3,%a0
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs)) =
57370: 1010 moveb %a0@,%d0
57372: 8085 orl %d5,%d0
57374: 1080 moveb %d0,%a0@
57376: 7001 moveq #1,%d0
57378: 1540 0076 moveb %d0,%a2@(118)
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
5737c: 4280 clrl %d0
5737e: 3012 movew %a2@,%d0
57380: 5380 subql #1,%d0
57382: b083 cmpl %d3,%d0
57384: 6640 bnes 573c6 <fat_set_fat_cluster+0x1c2> <== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
57386: 2f06 movel %d6,%sp@- <== NOT EXECUTED
57388: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5738c: 486b 0001 pea %a3@(1) <== NOT EXECUTED
57390: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57392: 4e94 jsr %a4@ <== NOT EXECUTED
&block0);
if (rc != RC_OK)
57394: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
57398: 2800 movel %d0,%d4 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
5739a: 6600 00ba bnew 57456 <fat_set_fat_cluster+0x252> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
5739e: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
573a2: 72f0 moveq #-16,%d1 <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
573a4: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
573a8: 1010 moveb %a0@,%d0 <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
573aa: 0285 0000 ffff andil #65535,%d5 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
573b0: c081 andl %d1,%d0 <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
573b2: e08d lsrl #8,%d5 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
573b4: 1080 moveb %d0,%a0@ <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
573b6: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
573ba: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
573be: 1010 moveb %a0@,%d0 <== NOT EXECUTED
573c0: 8a80 orl %d0,%d5 <== NOT EXECUTED
573c2: 1085 moveb %d5,%a0@ <== NOT EXECUTED
573c4: 6048 bras 5740e <fat_set_fat_cluster+0x20a> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
573c6: 206e fffc moveal %fp@(-4),%a0
573ca: 5283 addql #1,%d3
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
573cc: 72f0 moveq #-16,%d1
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
573ce: 2068 001e moveal %a0@(30),%a0
573d2: d1c3 addal %d3,%a0
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
573d4: 1010 moveb %a0@,%d0
573d6: c081 andl %d1,%d0
573d8: 1080 moveb %d0,%a0@
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
573da: 206e fffc moveal %fp@(-4),%a0
573de: 2068 001e moveal %a0@(30),%a0
573e2: d1c3 addal %d3,%a0
(uint8_t )((fat16_clv & 0xFF00)>>8);
573e4: 0285 0000 ffff andil #65535,%d5
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
573ea: 1010 moveb %a0@,%d0
(*((uint8_t *)(block0->buffer + ofs+1))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
573ec: e08d lsrl #8,%d5
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
573ee: 8a80 orl %d0,%d5
573f0: 1085 moveb %d5,%a0@
573f2: 6062 bras 57456 <fat_set_fat_cluster+0x252>
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
573f4: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
573f8: 0285 0000 ffff andil #65535,%d5 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
573fe: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
57402: 2005 movel %d5,%d0 <== NOT EXECUTED
57404: e08d lsrl #8,%d5 <== NOT EXECUTED
57406: e188 lsll #8,%d0 <== NOT EXECUTED
57408: 8085 orl %d5,%d0 <== NOT EXECUTED
5740a: 3180 3800 movew %d0,%a0@(00000000,%d3:l) <== NOT EXECUTED
5740e: 7001 moveq #1,%d0 <== NOT EXECUTED
57410: 1540 0076 moveb %d0,%a2@(118) <== NOT EXECUTED
57414: 6040 bras 57456 <fat_set_fat_cluster+0x252> <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
57416: 49fa fc3c lea %pc@(57054 <m68k_swap_u32>),%a4 <== NOT EXECUTED
5741a: 0285 0fff ffff andil #268435455,%d5 <== NOT EXECUTED
57420: 2f05 movel %d5,%sp@- <== NOT EXECUTED
57422: 4e94 jsr %a4@ <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
57424: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
57428: 2400 movel %d0,%d2 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
5742a: 2668 001e moveal %a0@(30),%a3 <== NOT EXECUTED
5742e: d7c3 addal %d3,%a3 <== NOT EXECUTED
57430: 2ebc f000 0000 movel #-268435456,%sp@ <== NOT EXECUTED
57436: 4e94 jsr %a4@ <== NOT EXECUTED
57438: 588f addql #4,%sp <== NOT EXECUTED
5743a: c093 andl %a3@,%d0 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
fat32_clv | (*((uint32_t *)(block0->buffer + ofs)));
5743c: 8082 orl %d2,%d0 <== NOT EXECUTED
5743e: 2680 movel %d0,%a3@ <== NOT EXECUTED
57440: 7201 moveq #1,%d1 <== NOT EXECUTED
57442: 1541 0076 moveb %d1,%a2@(118) <== NOT EXECUTED
57446: 600e bras 57456 <fat_set_fat_cluster+0x252> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
57448: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5744e: 78ff moveq #-1,%d4 <== NOT EXECUTED
57450: 7205 moveq #5,%d1 <== NOT EXECUTED
57452: 2040 moveal %d0,%a0 <== NOT EXECUTED
57454: 2081 movel %d1,%a0@ <== NOT EXECUTED
break;
}
return RC_OK;
}
57456: 2004 movel %d4,%d0
57458: 4cee 1cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a4
5745e: 4e5e unlk %fp <== NOT EXECUTED
00050c94 <fat_shutdown_drive>:
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
50c94: 4280 clrl %d0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
50c96: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED
50c9a: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
50c9e: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@ <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
50ca2: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
50ca6: 102a 000a moveb %a2@(10),%d0 <== NOT EXECUTED
50caa: 44c0 movew %d0,%ccr <== NOT EXECUTED
50cac: 661c bnes 50cca <fat_shutdown_drive+0x36> <== NOT EXECUTED
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
50cae: 2f2a 003e movel %a2@(62),%sp@- <== NOT EXECUTED
50cb2: 2f2a 003a movel %a2@(58),%sp@- <== NOT EXECUTED
50cb6: 2f08 movel %a0,%sp@- <== NOT EXECUTED
50cb8: 4eb9 0005 0c16 jsr 50c16 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
50cbe: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
50cc2: 2400 movel %d0,%d2 <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
50cc4: 6706 beqs 50ccc <fat_shutdown_drive+0x38> <== NOT EXECUTED
rc = -1;
50cc6: 74ff moveq #-1,%d2 <== NOT EXECUTED
50cc8: 6002 bras 50ccc <fat_shutdown_drive+0x38> <== NOT EXECUTED
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
int rc = RC_OK;
50cca: 4282 clrl %d2 <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
rc = -1;
}
fat_buf_release(fs_info);
50ccc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50cce: 4eb9 0005 0780 jsr 50780 <fat_buf_release> <== NOT EXECUTED
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
50cd4: 2f2a 004e movel %a2@(78),%sp@- <== NOT EXECUTED
50cd8: 2f2a 004a movel %a2@(74),%sp@- <== NOT EXECUTED
50cdc: 4eb9 0004 f446 jsr 4f446 <rtems_bdbuf_syncdev> <== NOT EXECUTED
50ce2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
50ce6: 4a80 tstl %d0 <== NOT EXECUTED
50ce8: 6702 beqs 50cec <fat_shutdown_drive+0x58> <== NOT EXECUTED
rc = -1;
50cea: 74ff moveq #-1,%d2 <== NOT EXECUTED
50cec: 4283 clrl %d3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
50cee: 49f9 0004 9a64 lea 49a64 <_Chain_Get>,%a4 <== NOT EXECUTED
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
50cf4: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
50cfa: 282a 005a movel %a2@(90),%d4 <== NOT EXECUTED
50cfe: d883 addl %d3,%d4 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
50d00: 6006 bras 50d08 <fat_shutdown_drive+0x74> <== NOT EXECUTED
free(node);
50d02: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50d04: 4e93 jsr %a3@ <== NOT EXECUTED
50d06: 588f addql #4,%sp <== NOT EXECUTED
50d08: 2f04 movel %d4,%sp@- <== NOT EXECUTED
50d0a: 4e94 jsr %a4@ <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
50d0c: 588f addql #4,%sp <== NOT EXECUTED
50d0e: 4a80 tstl %d0 <== NOT EXECUTED
50d10: 66f0 bnes 50d02 <fat_shutdown_drive+0x6e> <== NOT EXECUTED
50d12: 0683 0000 000c addil #12,%d3 <== NOT EXECUTED
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
50d18: 103c 0018 moveb #24,%d0 <== NOT EXECUTED
50d1c: b083 cmpl %d3,%d0 <== NOT EXECUTED
50d1e: 66da bnes 50cfa <fat_shutdown_drive+0x66> <== NOT EXECUTED
50d20: 4283 clrl %d3 <== NOT EXECUTED
50d22: 49f9 0004 9a64 lea 49a64 <_Chain_Get>,%a4 <== NOT EXECUTED
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
50d28: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
50d2e: 282a 005e movel %a2@(94),%d4 <== NOT EXECUTED
50d32: d883 addl %d3,%d4 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
50d34: 6006 bras 50d3c <fat_shutdown_drive+0xa8> <== NOT EXECUTED
free(node);
50d36: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50d38: 4e93 jsr %a3@ <== NOT EXECUTED
50d3a: 588f addql #4,%sp <== NOT EXECUTED
50d3c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
50d3e: 4e94 jsr %a4@ <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
50d40: 588f addql #4,%sp <== NOT EXECUTED
50d42: 4a80 tstl %d0 <== NOT EXECUTED
50d44: 66f0 bnes 50d36 <fat_shutdown_drive+0xa2> <== NOT EXECUTED
50d46: 0683 0000 000c addil #12,%d3 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
50d4c: 103c 0018 moveb #24,%d0 <== NOT EXECUTED
50d50: b083 cmpl %d3,%d0 <== NOT EXECUTED
50d52: 66da bnes 50d2e <fat_shutdown_drive+0x9a> <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
50d54: 2f2a 005a movel %a2@(90),%sp@- <== NOT EXECUTED
50d58: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
50d5e: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->rhash);
50d60: 2f2a 005e movel %a2@(94),%sp@- <== NOT EXECUTED
50d64: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->uino);
50d66: 2f2a 0062 movel %a2@(98),%sp@- <== NOT EXECUTED
50d6a: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->sec_buf);
50d6c: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
50d70: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_disk_release(fs_info->vol.dd);
50d72: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
50d76: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
if (rc)
50d7c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
50d80: 4a82 tstl %d2 <== NOT EXECUTED
50d82: 670c beqs 50d90 <fat_shutdown_drive+0xfc> <== NOT EXECUTED
errno = EIO;
50d84: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
50d8a: 7205 moveq #5,%d1 <== NOT EXECUTED
50d8c: 2040 moveal %d0,%a0 <== NOT EXECUTED
50d8e: 2081 movel %d1,%a0@ <== NOT EXECUTED
return rc;
}
50d90: 2002 movel %d2,%d0 <== NOT EXECUTED
50d92: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 <== NOT EXECUTED
50d98: 4e5e unlk %fp <== NOT EXECUTED
0005bc88 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
5bc88: 4e56 fff0 linkw %fp,#-16
5bc8c: 202e 0008 movel %fp@(8),%d0
5bc90: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
5bc94: 262e 000c movel %fp@(12),%d3
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
5bc98: 2239 0005 eca2 movel 5eca2 <rtems_libio_number_iops>,%d1
5bc9e: b280 cmpl %d0,%d1
5bca0: 631c blss 5bcbe <fcntl+0x36>
iop = rtems_libio_iop( fd );
5bca2: 2400 movel %d0,%d2
5bca4: ed88 lsll #6,%d0
5bca6: e78a lsll #3,%d2
5bca8: 2679 0006 0494 moveal 60494 <rtems_libio_iops>,%a3
5bcae: 9082 subl %d2,%d0
5bcb0: 45f3 0800 lea %a3@(00000000,%d0:l),%a2
rtems_libio_check_is_open(iop);
5bcb4: 202a 0014 movel %a2@(20),%d0
5bcb8: 0800 0008 btst #8,%d0
5bcbc: 6610 bnes 5bcce <fcntl+0x46>
5bcbe: 4eb9 0004 d9cc jsr 4d9cc <__errno>
5bcc4: 7209 moveq #9,%d1
5bcc6: 2040 moveal %d0,%a0
5bcc8: 2081 movel %d1,%a0@
5bcca: 6000 0116 braw 5bde2 <fcntl+0x15a>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
5bcce: 7409 moveq #9,%d2
5bcd0: b483 cmpl %d3,%d2
5bcd2: 6500 00de bcsw 5bdb2 <fcntl+0x12a>
5bcd6: 307b 3a06 moveaw %pc@(5bcde <fcntl+0x56>,%d3:l:2),%a0
5bcda: 4efb 8802 jmp %pc@(5bcde <fcntl+0x56>,%a0:l)
5bcde: 0014 .short 0x0014 <== NOT EXECUTED
5bce0: 006e .short 0x006e <== NOT EXECUTED
5bce2: 007a .short 0x007a <== NOT EXECUTED
5bce4: 0090 009e 00c4 oril #10354884,%d0 <== NOT EXECUTED
5bcea: 00c4 bitrev %d4 <== NOT EXECUTED
5bcec: 00c4 bitrev %d4 <== NOT EXECUTED
5bcee: 00c4 bitrev %d4 <== NOT EXECUTED
5bcf0: 00c4 bitrev %d4 <== NOT EXECUTED
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
5bcf2: 242e 0010 movel %fp@(16),%d2
if ( fd2 )
5bcf6: 6710 beqs 5bd08 <fcntl+0x80>
diop = rtems_libio_iop( fd2 );
5bcf8: b282 cmpl %d2,%d1
5bcfa: 631c blss 5bd18 <fcntl+0x90> <== NEVER TAKEN
5bcfc: 2002 movel %d2,%d0
5bcfe: ed8a lsll #6,%d2
5bd00: e788 lsll #3,%d0
5bd02: 9480 subl %d0,%d2
5bd04: d7c2 addal %d2,%a3
5bd06: 6012 bras 5bd1a <fcntl+0x92>
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
5bd08: 4eb9 0004 358c jsr 4358c <rtems_libio_allocate>
5bd0e: 2640 moveal %d0,%a3
if ( diop == 0 ) {
5bd10: 4a80 tstl %d0
5bd12: 6606 bnes 5bd1a <fcntl+0x92> <== ALWAYS TAKEN
5bd14: 6000 00cc braw 5bde2 <fcntl+0x15a> <== NOT EXECUTED
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
5bd18: 97cb subal %a3,%a3 <== NOT EXECUTED
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
5bd1a: 240b movel %a3,%d2
ret = -1;
break;
}
}
diop->flags = iop->flags;
5bd1c: 276a 0014 0014 movel %a2@(20),%a3@(20)
diop->pathinfo = iop->pathinfo;
5bd22: 4878 0014 pea 14 <OPER2>
5bd26: 486a 0018 pea %a2@(24)
5bd2a: 486b 0018 pea %a3@(24)
5bd2e: 4eb9 0004 e6bc jsr 4e6bc <memcpy>
ret = (int) (diop - rtems_libio_iops);
5bd34: 4fef 000c lea %sp@(12),%sp
5bd38: 94b9 0006 0494 subl 60494 <rtems_libio_iops>,%d2
5bd3e: 203c b6db 6db7 movel #-1227133513,%d0
5bd44: e682 asrl #3,%d2
5bd46: 4c00 2800 mulsl %d0,%d2
5bd4a: 6074 bras 5bdc0 <fcntl+0x138>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
5bd4c: 0800 000b btst #11,%d0
5bd50: 56c2 sne %d2
5bd52: 49c2 extbl %d2
5bd54: 4482 negl %d2
5bd56: 606c bras 5bdc4 <fcntl+0x13c>
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
5bd58: 4aae 0010 tstl %fp@(16)
5bd5c: 6706 beqs 5bd64 <fcntl+0xdc>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
5bd5e: 08c0 000b bset #11,%d0
5bd62: 6004 bras 5bd68 <fcntl+0xe0>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
5bd64: 0880 000b bclr #11,%d0
5bd68: 2540 0014 movel %d0,%a2@(20)
5bd6c: 6030 bras 5bd9e <fcntl+0x116>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
5bd6e: 2f00 movel %d0,%sp@-
5bd70: 4eb9 0004 353e jsr 4353e <rtems_libio_to_fcntl_flags>
5bd76: 588f addql #4,%sp
5bd78: 2400 movel %d0,%d2
5bd7a: 6044 bras 5bdc0 <fcntl+0x138>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
5bd7c: 2f2e 0010 movel %fp@(16),%sp@-
5bd80: 4eb9 0004 34fe jsr 434fe <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
5bd86: 222a 0014 movel %a2@(20),%d1
5bd8a: 588f addql #4,%sp
5bd8c: 0280 0000 0201 andil #513,%d0
5bd92: 0281 ffff fdfe andil #-514,%d1
5bd98: 8081 orl %d1,%d0
5bd9a: 2540 0014 movel %d0,%a2@(20)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
5bd9e: 4282 clrl %d2
5bda0: 6022 bras 5bdc4 <fcntl+0x13c>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
5bda2: 4eb9 0004 d9cc jsr 4d9cc <__errno>
5bda8: 2040 moveal %d0,%a0
5bdaa: 20bc 0000 0086 movel #134,%a0@
5bdb0: 6030 bras 5bde2 <fcntl+0x15a>
ret = -1;
break;
default:
errno = EINVAL;
5bdb2: 4eb9 0004 d9cc jsr 4d9cc <__errno>
5bdb8: 2040 moveal %d0,%a0
5bdba: 7016 moveq #22,%d0
5bdbc: 2080 movel %d0,%a0@
5bdbe: 6022 bras 5bde2 <fcntl+0x15a>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
5bdc0: 4a82 tstl %d2
5bdc2: 6d20 blts 5bde4 <fcntl+0x15c> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
5bdc4: 206a 0020 moveal %a2@(32),%a0
5bdc8: 2f0a movel %a2,%sp@-
5bdca: 2f03 movel %d3,%sp@-
5bdcc: 2068 0030 moveal %a0@(48),%a0
5bdd0: 4e90 jsr %a0@
if (err) {
5bdd2: 508f addql #8,%sp
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
5bdd4: 2600 movel %d0,%d3
if (err) {
5bdd6: 670c beqs 5bde4 <fcntl+0x15c> <== ALWAYS TAKEN
errno = err;
5bdd8: 4eb9 0004 d9cc jsr 4d9cc <__errno> <== NOT EXECUTED
5bdde: 2040 moveal %d0,%a0 <== NOT EXECUTED
5bde0: 2083 movel %d3,%a0@ <== NOT EXECUTED
ret = -1;
5bde2: 74ff moveq #-1,%d2
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
5bde4: 2002 movel %d2,%d0
5bde6: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
5bdec: 4e5e unlk %fp <== NOT EXECUTED
0004b726 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b726: 4e56 ffd8 linkw %fp,#-40
4b72a: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
4b72e: 266e 0008 moveal %fp@(8),%a3
4b732: 286e 000c moveal %fp@(12),%a4
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
4b736: 4ab9 0006 04a8 tstl 604a8 <pipe_semaphore>
4b73c: 6656 bnes 4b794 <fifo_open+0x6e>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4b73e: 42a7 clrl %sp@-
4b740: 42a7 clrl %sp@-
4b742: 2f39 0006 0ba0 movel 60ba0 <rtems_libio_semaphore>,%sp@-
4b748: 4eb9 0004 766c jsr 4766c <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
4b74e: 4fef 000c lea %sp@(12),%sp
4b752: 4ab9 0006 04a8 tstl 604a8 <pipe_semaphore>
4b758: 6624 bnes 4b77e <fifo_open+0x58> <== NEVER TAKEN
sc = rtems_semaphore_create(
4b75a: 4879 0006 04a8 pea 604a8 <pipe_semaphore>
4b760: 42a7 clrl %sp@-
4b762: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
4b766: 4878 0001 pea 1 <ADD>
4b76a: 2f3c 5049 5045 movel #1346981957,%sp@-
4b770: 4eb9 0004 7430 jsr 47430 <rtems_semaphore_create>
4b776: 4fef 0014 lea %sp@(20),%sp
4b77a: 2400 movel %d0,%d2
4b77c: 6002 bras 4b780 <fifo_open+0x5a>
free(pipe);
}
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
4b77e: 4282 clrl %d2 <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4b780: 2f39 0006 0ba0 movel 60ba0 <rtems_libio_semaphore>,%sp@-
4b786: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
4b78c: 588f addql #4,%sp
4b78e: 4a82 tstl %d2
4b790: 6600 0362 bnew 4baf4 <fifo_open+0x3ce>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4b794: 42a7 clrl %sp@-
4b796: 42a7 clrl %sp@-
4b798: 2f39 0006 04a8 movel 604a8 <pipe_semaphore>,%sp@-
4b79e: 4eb9 0004 766c jsr 4766c <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
4b7a4: 4fef 000c lea %sp@(12),%sp
4b7a8: 4a80 tstl %d0
4b7aa: 6600 0348 bnew 4baf4 <fifo_open+0x3ce>
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
4b7ae: 2453 moveal %a3@,%a2
if (pipe == NULL) {
4b7b0: 4a8a tstl %a2
4b7b2: 6600 015c bnew 4b910 <fifo_open+0x1ea>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4b7b6: 4878 0034 pea 34 <OPER2+0x20>
4b7ba: 4bf9 0004 49e0 lea 449e0 <malloc>,%a5
4b7c0: 4e95 jsr %a5@
if (pipe == NULL)
4b7c2: 588f addql #4,%sp
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4b7c4: 2440 moveal %d0,%a2
if (pipe == NULL)
4b7c6: 4a80 tstl %d0
4b7c8: 6700 0142 beqw 4b90c <fifo_open+0x1e6>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
4b7cc: 4878 0034 pea 34 <OPER2+0x20>
4b7d0: 42a7 clrl %sp@-
4b7d2: 2f00 movel %d0,%sp@-
4b7d4: 4eb9 0004 fa70 jsr 4fa70 <memset>
pipe->Size = PIPE_BUF;
4b7da: 203c 0000 0200 movel #512,%d0
4b7e0: 2540 0004 movel %d0,%a2@(4)
pipe->Buffer = malloc(pipe->Size);
4b7e4: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
4b7e8: 4e95 jsr %a5@
if (! pipe->Buffer)
4b7ea: 4fef 0010 lea %sp@(16),%sp
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
4b7ee: 2480 movel %d0,%a2@
if (! pipe->Buffer)
4b7f0: 6700 0110 beqw 4b902 <fifo_open+0x1dc>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b7f4: 486a 002c pea %a2@(44)
4b7f8: 4bf9 0004 cee8 lea 4cee8 <rtems_barrier_create>,%a5
rtems_build_name ('P', 'I', 'r', c),
4b7fe: 1039 0005 f558 moveb 5f558 <c.6530>,%d0
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b804: 42a7 clrl %sp@-
rtems_build_name ('P', 'I', 'r', c),
4b806: 49c0 extbl %d0
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b808: 42a7 clrl %sp@-
4b80a: 0080 5049 7200 oril #1346990592,%d0
4b810: 2f00 movel %d0,%sp@-
4b812: 4e95 jsr %a5@
4b814: 4fef 0010 lea %sp@(16),%sp
4b818: 4a80 tstl %d0
4b81a: 6600 00dc bnew 4b8f8 <fifo_open+0x1d2>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4b81e: 486a 0030 pea %a2@(48)
rtems_build_name ('P', 'I', 'w', c),
4b822: 1039 0005 f558 moveb 5f558 <c.6530>,%d0
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4b828: 42a7 clrl %sp@-
rtems_build_name ('P', 'I', 'w', c),
4b82a: 49c0 extbl %d0
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4b82c: 42a7 clrl %sp@-
4b82e: 0080 5049 7700 oril #1346991872,%d0
4b834: 2f00 movel %d0,%sp@-
4b836: 4e95 jsr %a5@
4b838: 4fef 0010 lea %sp@(16),%sp
4b83c: 4a80 tstl %d0
4b83e: 6600 00ac bnew 4b8ec <fifo_open+0x1c6>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4b842: 486a 0028 pea %a2@(40)
rtems_build_name ('P', 'I', 's', c), 1,
4b846: 1039 0005 f558 moveb 5f558 <c.6530>,%d0
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4b84c: 42a7 clrl %sp@-
4b84e: 4878 0010 pea 10 <INVALID_OPERATION>
rtems_build_name ('P', 'I', 's', c), 1,
4b852: 49c0 extbl %d0
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4b854: 4878 0001 pea 1 <ADD>
4b858: 0080 5049 7300 oril #1346990848,%d0
4b85e: 2f00 movel %d0,%sp@-
4b860: 4eb9 0004 7430 jsr 47430 <rtems_semaphore_create>
4b866: 4fef 0014 lea %sp@(20),%sp
4b86a: 4a80 tstl %d0
4b86c: 6672 bnes 4b8e0 <fifo_open+0x1ba>
/* Set barriers to be interruptible by signals. */
static void pipe_interruptible(pipe_control_t *pipe)
{
Objects_Locations location;
_Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
4b86e: 260e movel %fp,%d3
4b870: 5983 subql #4,%d3
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
4b872: 243c 0004 8d38 movel #298296,%d2
4b878: 2042 moveal %d2,%a0
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
_Thread_Enable_dispatch();
4b87a: 4bf9 0004 997c lea 4997c <_Thread_Enable_dispatch>,%a5
4b880: 2f03 movel %d3,%sp@-
4b882: 2f2a 002c movel %a2@(44),%sp@-
4b886: 4879 0006 1528 pea 61528 <_Barrier_Information>
4b88c: 4e90 jsr %a0@
static void pipe_interruptible(pipe_control_t *pipe)
{
Objects_Locations location;
_Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
4b88e: 223c 1000 0000 movel #268435456,%d1
4b894: 2040 moveal %d0,%a0
4b896: 83a8 004c orl %d1,%a0@(76)
_Thread_Enable_dispatch();
4b89a: 4e95 jsr %a5@
4b89c: 2042 moveal %d2,%a0
4b89e: 2f03 movel %d3,%sp@-
4b8a0: 2f2a 0030 movel %a2@(48),%sp@-
4b8a4: 4879 0006 1528 pea 61528 <_Barrier_Information>
4b8aa: 4e90 jsr %a0@
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
4b8ac: 223c 1000 0000 movel #268435456,%d1
4b8b2: 2040 moveal %d0,%a0
4b8b4: 83a8 004c orl %d1,%a0@(76)
_Thread_Enable_dispatch();
4b8b8: 4e95 jsr %a5@
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4b8ba: 4fef 0018 lea %sp@(24),%sp
4b8be: 1039 0005 f558 moveb 5f558 <c.6530>,%d0
4b8c4: 49c0 extbl %d0
4b8c6: 2200 movel %d0,%d1
4b8c8: 5281 addql #1,%d1
4b8ca: 13c1 0005 f558 moveb %d1,5f558 <c.6530>
4b8d0: 727a moveq #122,%d1
4b8d2: b280 cmpl %d0,%d1
4b8d4: 663a bnes 4b910 <fifo_open+0x1ea>
c = 'a';
4b8d6: 7061 moveq #97,%d0
4b8d8: 13c0 0005 f558 moveb %d0,5f558 <c.6530>
4b8de: 6030 bras 4b910 <fifo_open+0x1ea>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
4b8e0: 2f2a 0030 movel %a2@(48),%sp@-
4b8e4: 4eb9 0004 cfa4 jsr 4cfa4 <rtems_barrier_delete>
4b8ea: 588f addql #4,%sp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
4b8ec: 2f2a 002c movel %a2@(44),%sp@-
4b8f0: 4eb9 0004 cfa4 jsr 4cfa4 <rtems_barrier_delete>
4b8f6: 588f addql #4,%sp
err_rbar:
free(pipe->Buffer);
4b8f8: 2f12 movel %a2@,%sp@-
4b8fa: 4eb9 0004 42dc jsr 442dc <free>
4b900: 588f addql #4,%sp
err_buf:
free(pipe);
4b902: 2f0a movel %a2,%sp@-
4b904: 4eb9 0004 42dc jsr 442dc <free>
4b90a: 588f addql #4,%sp
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4b90c: 74f4 moveq #-12,%d2
4b90e: 6030 bras 4b940 <fifo_open+0x21a>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4b910: 42a7 clrl %sp@-
4b912: 42a7 clrl %sp@-
4b914: 2f2a 0028 movel %a2@(40),%sp@-
4b918: 4eb9 0004 766c jsr 4766c <rtems_semaphore_obtain>
4b91e: 4fef 000c lea %sp@(12),%sp
4b922: 4a80 tstl %d0
4b924: 6604 bnes 4b92a <fifo_open+0x204> <== NEVER TAKEN
4b926: 4282 clrl %d2
4b928: 6002 bras 4b92c <fifo_open+0x206>
err = -EINTR;
4b92a: 74fc moveq #-4,%d2 <== NOT EXECUTED
if (*pipep == NULL) {
4b92c: 4a93 tstl %a3@
4b92e: 6610 bnes 4b940 <fifo_open+0x21a>
if (err)
4b930: 4a82 tstl %d2
4b932: 670a beqs 4b93e <fifo_open+0x218> <== ALWAYS TAKEN
pipe_free(pipe);
4b934: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4b936: 4eba fd14 jsr %pc@(4b64c <pipe_free>) <== NOT EXECUTED
4b93a: 588f addql #4,%sp <== NOT EXECUTED
4b93c: 6002 bras 4b940 <fifo_open+0x21a> <== NOT EXECUTED
else
*pipep = pipe;
4b93e: 268a movel %a2,%a3@
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
4b940: 2f39 0006 04a8 movel 604a8 <pipe_semaphore>,%sp@-
4b946: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
4b94c: 588f addql #4,%sp
4b94e: 4a82 tstl %d2
4b950: 6600 01a4 bnew 4baf6 <fifo_open+0x3d0>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
4b954: 7006 moveq #6,%d0
4b956: 7204 moveq #4,%d1
4b958: c0ac 0014 andl %a4@(20),%d0
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
4b95c: 2453 moveal %a3@,%a2
switch (LIBIO_ACCMODE(iop)) {
4b95e: b280 cmpl %d0,%d1
4b960: 6700 009c beqw 4b9fe <fifo_open+0x2d8>
4b964: 123c 0006 moveb #6,%d1
4b968: b280 cmpl %d0,%d1
4b96a: 6700 0122 beqw 4ba8e <fifo_open+0x368>
4b96e: 123c 0002 moveb #2,%d1
4b972: b280 cmpl %d0,%d1
4b974: 6600 0160 bnew 4bad6 <fifo_open+0x3b0>
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
4b978: 202a 0010 movel %a2@(16),%d0
4b97c: 2040 moveal %d0,%a0
4b97e: 5288 addql #1,%a0
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4b980: 52aa 0020 addql #1,%a2@(32)
if (pipe->Readers ++ == 0)
4b984: 2548 0010 movel %a0,%a2@(16)
4b988: 4a80 tstl %d0
4b98a: 6610 bnes 4b99c <fifo_open+0x276> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
4b98c: 486e fff8 pea %fp@(-8)
4b990: 2f2a 0030 movel %a2@(48),%sp@-
4b994: 4eb9 0004 d040 jsr 4d040 <rtems_barrier_release>
4b99a: 508f addql #8,%sp
if (pipe->Writers == 0) {
4b99c: 4aaa 0014 tstl %a2@(20)
4b9a0: 6600 0134 bnew 4bad6 <fifo_open+0x3b0>
/* Not an error */
if (LIBIO_NODELAY(iop))
4b9a4: 7001 moveq #1,%d0
4b9a6: c0ac 0014 andl %a4@(20),%d0
4b9aa: 6600 012a bnew 4bad6 <fifo_open+0x3b0>
break;
prevCounter = pipe->writerCounter;
4b9ae: 2a2a 0024 movel %a2@(36),%d5
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
4b9b2: 4bf9 0004 766c lea 4766c <rtems_semaphore_obtain>,%a5
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4b9b8: 283c 0004 7778 movel #292728,%d4
if (! PIPE_READWAIT(pipe))
4b9be: 263c 0004 d0a4 movel #315556,%d3
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4b9c4: 2f2a 0028 movel %a2@(40),%sp@-
4b9c8: 2044 moveal %d4,%a0
4b9ca: 4e90 jsr %a0@
if (! PIPE_READWAIT(pipe))
4b9cc: 2043 moveal %d3,%a0
4b9ce: 42a7 clrl %sp@-
4b9d0: 2f2a 002c movel %a2@(44),%sp@-
4b9d4: 4e90 jsr %a0@
4b9d6: 4fef 000c lea %sp@(12),%sp
4b9da: 4a80 tstl %d0
4b9dc: 6600 0106 bnew 4bae4 <fifo_open+0x3be>
goto out_error;
if (! PIPE_LOCK(pipe))
4b9e0: 42a7 clrl %sp@-
4b9e2: 42a7 clrl %sp@-
4b9e4: 2f2a 0028 movel %a2@(40),%sp@-
4b9e8: 4e95 jsr %a5@
4b9ea: 4fef 000c lea %sp@(12),%sp
4b9ee: 4a80 tstl %d0
4b9f0: 6600 00f2 bnew 4bae4 <fifo_open+0x3be>
goto out_error;
} while (prevCounter == pipe->writerCounter);
4b9f4: baaa 0024 cmpl %a2@(36),%d5
4b9f8: 67ca beqs 4b9c4 <fifo_open+0x29e> <== NEVER TAKEN
4b9fa: 6000 00da braw 4bad6 <fifo_open+0x3b0>
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4b9fe: 202a 0014 movel %a2@(20),%d0
4ba02: 2200 movel %d0,%d1
4ba04: 5281 addql #1,%d1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4ba06: 52aa 0024 addql #1,%a2@(36)
if (pipe->Writers ++ == 0)
4ba0a: 2541 0014 movel %d1,%a2@(20)
4ba0e: 4a80 tstl %d0
4ba10: 6610 bnes 4ba22 <fifo_open+0x2fc> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4ba12: 486e fff8 pea %fp@(-8)
4ba16: 2f2a 002c movel %a2@(44),%sp@-
4ba1a: 4eb9 0004 d040 jsr 4d040 <rtems_barrier_release>
4ba20: 508f addql #8,%sp
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4ba22: 4aaa 0010 tstl %a2@(16)
4ba26: 6600 00ae bnew 4bad6 <fifo_open+0x3b0>
4ba2a: 7001 moveq #1,%d0
4ba2c: c0ac 0014 andl %a4@(20),%d0
4ba30: 6712 beqs 4ba44 <fifo_open+0x31e>
PIPE_UNLOCK(pipe);
4ba32: 2f2a 0028 movel %a2@(40),%sp@-
err = -ENXIO;
4ba36: 74fa moveq #-6,%d2
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
4ba38: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
4ba3e: 588f addql #4,%sp
4ba40: 6000 00a4 braw 4bae6 <fifo_open+0x3c0>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
4ba44: 2a2a 0020 movel %a2@(32),%d5
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
4ba48: 4bf9 0004 766c lea 4766c <rtems_semaphore_obtain>,%a5
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4ba4e: 283c 0004 7778 movel #292728,%d4
if (! PIPE_WRITEWAIT(pipe))
4ba54: 263c 0004 d0a4 movel #315556,%d3
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4ba5a: 2f2a 0028 movel %a2@(40),%sp@-
4ba5e: 2044 moveal %d4,%a0
4ba60: 4e90 jsr %a0@
if (! PIPE_WRITEWAIT(pipe))
4ba62: 2043 moveal %d3,%a0
4ba64: 42a7 clrl %sp@-
4ba66: 2f2a 0030 movel %a2@(48),%sp@-
4ba6a: 4e90 jsr %a0@
4ba6c: 4fef 000c lea %sp@(12),%sp
4ba70: 4a80 tstl %d0
4ba72: 6670 bnes 4bae4 <fifo_open+0x3be> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
4ba74: 42a7 clrl %sp@-
4ba76: 42a7 clrl %sp@-
4ba78: 2f2a 0028 movel %a2@(40),%sp@-
4ba7c: 4e95 jsr %a5@
4ba7e: 4fef 000c lea %sp@(12),%sp
4ba82: 4a80 tstl %d0
4ba84: 665e bnes 4bae4 <fifo_open+0x3be> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
4ba86: baaa 0020 cmpl %a2@(32),%d5
4ba8a: 67ce beqs 4ba5a <fifo_open+0x334> <== NEVER TAKEN
4ba8c: 6048 bras 4bad6 <fifo_open+0x3b0>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
4ba8e: 202a 0010 movel %a2@(16),%d0
4ba92: 2200 movel %d0,%d1
4ba94: 5281 addql #1,%d1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4ba96: 52aa 0020 addql #1,%a2@(32)
if (pipe->Readers ++ == 0)
4ba9a: 2541 0010 movel %d1,%a2@(16)
4ba9e: 4a80 tstl %d0
4baa0: 6610 bnes 4bab2 <fifo_open+0x38c> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
4baa2: 486e fff8 pea %fp@(-8)
4baa6: 2f2a 0030 movel %a2@(48),%sp@-
4baaa: 4eb9 0004 d040 jsr 4d040 <rtems_barrier_release>
4bab0: 508f addql #8,%sp
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4bab2: 202a 0014 movel %a2@(20),%d0
4bab6: 2040 moveal %d0,%a0
4bab8: 5288 addql #1,%a0
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
4baba: 52aa 0024 addql #1,%a2@(36)
if (pipe->Writers ++ == 0)
4babe: 2548 0014 movel %a0,%a2@(20)
4bac2: 4a80 tstl %d0
4bac4: 6610 bnes 4bad6 <fifo_open+0x3b0> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4bac6: 486e fff8 pea %fp@(-8)
4baca: 2f2a 002c movel %a2@(44),%sp@-
4bace: 4eb9 0004 d040 jsr 4d040 <rtems_barrier_release>
4bad4: 508f addql #8,%sp
break;
}
PIPE_UNLOCK(pipe);
4bad6: 2f2a 0028 movel %a2@(40),%sp@-
4bada: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
return 0;
4bae0: 588f addql #4,%sp
4bae2: 6012 bras 4baf6 <fifo_open+0x3d0>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
4bae4: 74fc moveq #-4,%d2 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
4bae6: 2f0c movel %a4,%sp@-
4bae8: 2f0b movel %a3,%sp@-
4baea: 4eb9 0004 b694 jsr 4b694 <pipe_release>
return err;
4baf0: 508f addql #8,%sp
4baf2: 6002 bras 4baf6 <fifo_open+0x3d0>
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
if (sc == RTEMS_SUCCESSFUL) {
4baf4: 74f4 moveq #-12,%d2
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
4baf6: 2002 movel %d2,%d0
4baf8: 4cee 3c3c ffd8 moveml %fp@(-40),%d2-%d5/%a2-%a5
4bafe: 4e5e unlk %fp <== NOT EXECUTED
000434a4 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
434a4: 4e56 0000 linkw %fp,#0
434a8: 202e 0008 movel %fp@(8),%d0
434ac: 222e 000c movel %fp@(12),%d1
434b0: 2f02 movel %d2,%sp@-
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
434b2: b0b9 0005 eb12 cmpl 5eb12 <rtems_libio_number_iops>,%d0
434b8: 641c bccs 434d6 <fpathconf+0x32>
iop = rtems_libio_iop(fd);
434ba: 2400 movel %d0,%d2
434bc: ed88 lsll #6,%d0
434be: e78a lsll #3,%d2
434c0: 2079 0006 0274 moveal 60274 <rtems_libio_iops>,%a0
434c6: 9082 subl %d2,%d0
434c8: d1c0 addal %d0,%a0
rtems_libio_check_is_open(iop);
434ca: 2028 0014 movel %a0@(20),%d0
434ce: 0280 0000 0100 andil #256,%d0
434d4: 6610 bnes 434e6 <fpathconf+0x42> <== ALWAYS TAKEN
434d6: 4eb9 0004 dadc jsr 4dadc <__errno>
434dc: 7209 moveq #9,%d1
434de: 2040 moveal %d0,%a0
434e0: 2081 movel %d1,%a0@
434e2: 6000 0082 braw 43566 <fpathconf+0xc2>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
434e6: 2068 0028 moveal %a0@(40),%a0
switch ( name ) {
434ea: 700b moveq #11,%d0
434ec: b081 cmpl %d1,%d0
434ee: 656a bcss 4355a <fpathconf+0xb6>
434f0: 303b 1a08 movew %pc@(434fa <fpathconf+0x56>,%d1:l:2),%d0
434f4: 48c0 extl %d0
434f6: 4efb 0802 jmp %pc@(434fa <fpathconf+0x56>,%d0:l)
434fa: 0018 .short 0x0018 <== NOT EXECUTED
434fc: 001e .short 0x001e <== NOT EXECUTED
434fe: 0024 .short 0x0024 <== NOT EXECUTED
43500: 002a .short 0x002a <== NOT EXECUTED
43502: 0030 .short 0x0030 <== NOT EXECUTED
43504: 0036 .short 0x0036 <== NOT EXECUTED
43506: 003c .short 0x003c <== NOT EXECUTED
43508: 0042 .short 0x0042 <== NOT EXECUTED
4350a: 0048 .short 0x0048 <== NOT EXECUTED
4350c: 004e .short 0x004e <== NOT EXECUTED
4350e: 0054 .short 0x0054 <== NOT EXECUTED
43510: 005a .short 0x005a <== NOT EXECUTED
case _PC_LINK_MAX:
return_value = the_limits->link_max;
43512: 2028 0038 movel %a0@(56),%d0
break;
43516: 6050 bras 43568 <fpathconf+0xc4>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
43518: 2028 003c movel %a0@(60),%d0
break;
4351c: 604a bras 43568 <fpathconf+0xc4>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
4351e: 2028 0040 movel %a0@(64),%d0
break;
43522: 6044 bras 43568 <fpathconf+0xc4>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
43524: 2028 0044 movel %a0@(68),%d0
break;
43528: 603e bras 43568 <fpathconf+0xc4>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
4352a: 2028 0048 movel %a0@(72),%d0
break;
4352e: 6038 bras 43568 <fpathconf+0xc4>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
43530: 2028 004c movel %a0@(76),%d0
break;
43534: 6032 bras 43568 <fpathconf+0xc4>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
43536: 2028 0054 movel %a0@(84),%d0
break;
4353a: 602c bras 43568 <fpathconf+0xc4>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
4353c: 2028 0058 movel %a0@(88),%d0
break;
43540: 6026 bras 43568 <fpathconf+0xc4>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
43542: 2028 0064 movel %a0@(100),%d0
break;
43546: 6020 bras 43568 <fpathconf+0xc4>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
43548: 2028 0050 movel %a0@(80),%d0
break;
4354c: 601a bras 43568 <fpathconf+0xc4>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
4354e: 2028 005c movel %a0@(92),%d0
break;
43552: 6014 bras 43568 <fpathconf+0xc4>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
43554: 2028 0060 movel %a0@(96),%d0
break;
43558: 600e bras 43568 <fpathconf+0xc4>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
4355a: 4eb9 0004 dadc jsr 4dadc <__errno>
43560: 2040 moveal %d0,%a0
43562: 7016 moveq #22,%d0
43564: 2080 movel %d0,%a0@
43566: 70ff moveq #-1,%d0
break;
}
return return_value;
}
43568: 242e fffc movel %fp@(-4),%d2
4356c: 4e5e unlk %fp <== NOT EXECUTED
00042b68 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
42b68: 4e56 0000 linkw %fp,#0
MSBUMP(free_calls, 1);
42b6c: 52b9 0005 ea68 addql #1,5ea68 <rtems_malloc_statistics+0xc>
#include <stdlib.h>
void free(
void *ptr
)
{
42b72: 2f02 movel %d2,%sp@-
42b74: 242e 0008 movel %fp@(8),%d2
MSBUMP(free_calls, 1);
if ( !ptr )
42b78: 676c beqs 42be6 <free+0x7e>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
42b7a: 7003 moveq #3,%d0
42b7c: b0b9 0005 ecdc cmpl 5ecdc <_System_state_Current>,%d0
42b82: 661a bnes 42b9e <free+0x36> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
42b84: 4eb9 0004 2d0c jsr 42d0c <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
42b8a: 4a00 tstb %d0
42b8c: 6610 bnes 42b9e <free+0x36>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
42b8e: 2d42 0008 movel %d2,%fp@(8)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
42b92: 242e fffc movel %fp@(-4),%d2
42b96: 4e5e unlk %fp
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
42b98: 4ef9 0004 2d80 jmp 42d80 <malloc_deferred_free>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
42b9e: 2079 0005 da14 moveal 5da14 <rtems_malloc_statistics_helpers>,%a0
42ba4: 4a88 tstl %a0
42ba6: 670a beqs 42bb2 <free+0x4a>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
42ba8: 2f02 movel %d2,%sp@-
42baa: 2068 0008 moveal %a0@(8),%a0
42bae: 4e90 jsr %a0@
42bb0: 588f addql #4,%sp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
42bb2: 2f02 movel %d2,%sp@-
42bb4: 2f39 0005 d29a movel 5d29a <RTEMS_Malloc_Heap>,%sp@-
42bba: 4eb9 0004 73ec jsr 473ec <_Protected_heap_Free>
42bc0: 508f addql #8,%sp
42bc2: 4a00 tstb %d0
42bc4: 6620 bnes 42be6 <free+0x7e>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
42bc6: 2079 0005 d29a moveal 5d29a <RTEMS_Malloc_Heap>,%a0
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
42bcc: 2f28 001c movel %a0@(28),%sp@-
42bd0: 2f28 0018 movel %a0@(24),%sp@-
42bd4: 2f02 movel %d2,%sp@-
42bd6: 4879 0005 c244 pea 5c244 <rtems_status_assoc+0x168>
42bdc: 4eb9 0004 3828 jsr 43828 <printk>
42be2: 4fef 0010 lea %sp@(16),%sp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
42be6: 242e fffc movel %fp@(-4),%d2
42bea: 4e5e unlk %fp
...
00045be0 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
45be0: 4e56 0000 linkw %fp,#0
45be4: 2f0b movel %a3,%sp@-
45be6: 2f0a movel %a2,%sp@-
45be8: 246e 0008 moveal %fp@(8),%a2
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
45bec: b5fc 0006 16a4 cmpal #399012,%a2
45bf2: 6728 beqs 45c1c <free_user_env+0x3c> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
45bf4: 486a 0004 pea %a2@(4)
45bf8: 47f9 0004 4bc0 lea 44bc0 <rtems_filesystem_freenode>,%a3
45bfe: 4e93 jsr %a3@
rtems_filesystem_freenode( &env->root_directory);
45c00: 486a 0018 pea %a2@(24)
45c04: 4e93 jsr %a3@
free(env);
}
}
45c06: 266e fffc moveal %fp@(-4),%a3
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
45c0a: 508f addql #8,%sp
45c0c: 2d4a 0008 movel %a2,%fp@(8)
}
}
45c10: 246e fff8 moveal %fp@(-8),%a2
45c14: 4e5e unlk %fp
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
45c16: 4ef9 0004 4bd4 jmp 44bd4 <free>
}
}
45c1c: 246e fff8 moveal %fp@(-8),%a2 <== NOT EXECUTED
45c20: 266e fffc moveal %fp@(-4),%a3 <== NOT EXECUTED
45c24: 4e5e unlk %fp <== NOT EXECUTED
000436b8 <fsync>:
#include <rtems/seterr.h>
int fsync(
int fd
)
{
436b8: 4e56 0000 linkw %fp,#0
436bc: 202e 0008 movel %fp@(8),%d0
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
436c0: b0b9 0005 eb12 cmpl 5eb12 <rtems_libio_number_iops>,%d0
436c6: 641c bccs 436e4 <fsync+0x2c>
iop = rtems_libio_iop( fd );
436c8: 2200 movel %d0,%d1
436ca: ed88 lsll #6,%d0
436cc: e789 lsll #3,%d1
436ce: 2079 0006 0274 moveal 60274 <rtems_libio_iops>,%a0
436d4: 9081 subl %d1,%d0
436d6: d1c0 addal %d0,%a0
rtems_libio_check_is_open(iop);
436d8: 2028 0014 movel %a0@(20),%d0
436dc: 0280 0000 0100 andil #256,%d0
436e2: 6612 bnes 436f6 <fsync+0x3e>
436e4: 4eb9 0004 dadc jsr 4dadc <__errno>
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
}
436ea: 4e5e unlk %fp
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
436ec: 2040 moveal %d0,%a0
436ee: 7009 moveq #9,%d0
436f0: 2080 movel %d0,%a0@
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
}
436f2: 70ff moveq #-1,%d0
436f4: 4e75 rts
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
436f6: 2268 0020 moveal %a0@(32),%a1
436fa: 2d48 0008 movel %a0,%fp@(8)
}
436fe: 4e5e unlk %fp
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
43700: 2269 0028 moveal %a1@(40),%a1
43704: 4ed1 jmp %a1@
...
00049d5c <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
49d5c: 4e56 ffec linkw %fp,#-20
49d60: 202e 0008 movel %fp@(8),%d0
49d64: 2f0a movel %a2,%sp@-
49d66: 2f02 movel %d2,%sp@-
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
49d68: b0b9 0005 d2e2 cmpl 5d2e2 <rtems_libio_number_iops>,%d0
49d6e: 641a bccs 49d8a <ftruncate+0x2e> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
49d70: 2200 movel %d0,%d1
49d72: ed88 lsll #6,%d0
49d74: e789 lsll #3,%d1
49d76: 2479 0005 ea44 moveal 5ea44 <rtems_libio_iops>,%a2
49d7c: 9081 subl %d1,%d0
49d7e: d5c0 addal %d0,%a2
rtems_libio_check_is_open(iop);
49d80: 202a 0014 movel %a2@(20),%d0
49d84: 0800 0008 btst #8,%d0
49d88: 660e bnes 49d98 <ftruncate+0x3c>
49d8a: 4eb9 0004 cd68 jsr 4cd68 <__errno>
49d90: 7409 moveq #9,%d2
49d92: 2040 moveal %d0,%a0
49d94: 2082 movel %d2,%a0@
49d96: 604c bras 49de4 <ftruncate+0x88>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
49d98: 44c0 movew %d0,%ccr
49d9a: 670e beqs 49daa <ftruncate+0x4e>
49d9c: 4eb9 0004 cd68 jsr 4cd68 <__errno>
49da2: 7216 moveq #22,%d1
49da4: 2040 moveal %d0,%a0
49da6: 2081 movel %d1,%a0@
49da8: 603a bras 49de4 <ftruncate+0x88>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
49daa: 4878 0014 pea 14 <OPER2>
49dae: 240e movel %fp,%d2
49db0: 486a 0018 pea %a2@(24)
49db4: 0682 ffff ffec addil #-20,%d2
49dba: 2f02 movel %d2,%sp@-
49dbc: 4eb9 0004 d588 jsr 4d588 <memcpy>
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
49dc2: 206e fff8 moveal %fp@(-8),%a0
49dc6: 2f02 movel %d2,%sp@-
49dc8: 2068 0010 moveal %a0@(16),%a0
49dcc: 4e90 jsr %a0@
49dce: 4fef 0010 lea %sp@(16),%sp
49dd2: 7201 moveq #1,%d1
49dd4: b280 cmpl %d0,%d1
49dd6: 6610 bnes 49de8 <ftruncate+0x8c>
rtems_set_errno_and_return_minus_one( EISDIR );
49dd8: 4eb9 0004 cd68 jsr 4cd68 <__errno>
49dde: 2040 moveal %d0,%a0
49de0: 7015 moveq #21,%d0
49de2: 2080 movel %d0,%a0@
49de4: 70ff moveq #-1,%d0
49de6: 6018 bras 49e00 <ftruncate+0xa4>
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
49de8: 206a 0020 moveal %a2@(32),%a0
49dec: 2f2e 0010 movel %fp@(16),%sp@-
49df0: 2f2e 000c movel %fp@(12),%sp@-
49df4: 2f0a movel %a2,%sp@-
49df6: 2068 0020 moveal %a0@(32),%a0
49dfa: 4e90 jsr %a0@
49dfc: 4fef 000c lea %sp@(12),%sp
}
49e00: 242e ffe4 movel %fp@(-28),%d2
49e04: 246e ffe8 moveal %fp@(-24),%a2
49e08: 4e5e unlk %fp <== NOT EXECUTED
00042430 <get_disk_entry>:
}
}
static rtems_disk_device *
get_disk_entry(dev_t dev, bool lookup_only)
{
42430: 4e56 0000 linkw %fp,#0
42434: 202e 000c movel %fp@(12),%d0
42438: 2f03 movel %d3,%sp@-
4243a: 162e 0013 moveb %fp@(19),%d3
4243e: 2f02 movel %d2,%sp@-
42440: 242e 0008 movel %fp@(8),%d2
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major < disktab_size && disktab != NULL) {
42444: b4b9 0006 15ca cmpl 615ca <disktab_size>,%d2
4244a: 6432 bccs 4247e <get_disk_entry+0x4e> <== NEVER TAKEN
4244c: 2239 0006 15ce movel 615ce <disktab>,%d1
42452: 672a beqs 4247e <get_disk_entry+0x4e> <== NEVER TAKEN
rtems_disk_device_table *dtab = disktab + major;
42454: 2041 moveal %d1,%a0
42456: e78a lsll #3,%d2
42458: d1c2 addal %d2,%a0
if (minor < dtab->size && dtab->minor != NULL) {
4245a: b0a8 0004 cmpl %a0@(4),%d0
4245e: 641e bccs 4247e <get_disk_entry+0x4e> <== NEVER TAKEN
42460: 2050 moveal %a0@,%a0
42462: 4a88 tstl %a0
42464: 6718 beqs 4247e <get_disk_entry+0x4e> <== NEVER TAKEN
rtems_disk_device *dd = dtab->minor [minor];
42466: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
if (dd != NULL && !lookup_only) {
4246a: 4a88 tstl %a0
4246c: 6712 beqs 42480 <get_disk_entry+0x50>
4246e: 4a03 tstb %d3
42470: 660e bnes 42480 <get_disk_entry+0x50>
if (!dd->deleted) {
42472: 4a28 0030 tstb %a0@(48)
42476: 6606 bnes 4247e <get_disk_entry+0x4e>
++dd->uses;
42478: 52a8 0014 addql #1,%a0@(20)
4247c: 6002 bras 42480 <get_disk_entry+0x50>
} else {
dd = NULL;
4247e: 91c8 subal %a0,%a0
return dd;
}
}
return NULL;
}
42480: 241f movel %sp@+,%d2
42482: 2008 movel %a0,%d0
42484: 261f movel %sp@+,%d3
42486: 4e5e unlk %fp <== NOT EXECUTED
0005bed4 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
5bed4: 4e56 ffec linkw %fp,#-20
5bed8: 202e 0008 movel %fp@(8),%d0
5bedc: 2f0a movel %a2,%sp@-
5bede: 2f02 movel %d2,%sp@-
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
5bee0: b0b9 0005 eca2 cmpl 5eca2 <rtems_libio_number_iops>,%d0
5bee6: 6412 bccs 5befa <getdents+0x26> <== NEVER TAKEN
5bee8: 2200 movel %d0,%d1
5beea: ed88 lsll #6,%d0
5beec: e789 lsll #3,%d1
5beee: 2479 0006 0494 moveal 60494 <rtems_libio_iops>,%a2
5bef4: 9081 subl %d1,%d0
5bef6: d5c0 addal %d0,%a2
5bef8: 6002 bras 5befc <getdents+0x28>
5befa: 95ca subal %a2,%a2 <== NOT EXECUTED
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
5befc: 4878 0014 pea 14 <OPER2>
5bf00: 240e movel %fp,%d2
5bf02: 486a 0018 pea %a2@(24)
5bf06: 0682 ffff ffec addil #-20,%d2
5bf0c: 2f02 movel %d2,%sp@-
5bf0e: 4eb9 0004 e6bc jsr 4e6bc <memcpy>
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
5bf14: 206e fff8 moveal %fp@(-8),%a0
5bf18: 2f02 movel %d2,%sp@-
5bf1a: 2068 0010 moveal %a0@(16),%a0
5bf1e: 4e90 jsr %a0@
5bf20: 4fef 0010 lea %sp@(16),%sp
5bf24: 7201 moveq #1,%d1
5bf26: b280 cmpl %d0,%d1
5bf28: 6710 beqs 5bf3a <getdents+0x66>
rtems_set_errno_and_return_minus_one( ENOTDIR );
5bf2a: 4eb9 0004 d9cc jsr 4d9cc <__errno>
5bf30: 2040 moveal %d0,%a0
5bf32: 7014 moveq #20,%d0
5bf34: 2080 movel %d0,%a0@
5bf36: 70ff moveq #-1,%d0
5bf38: 6018 bras 5bf52 <getdents+0x7e>
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
5bf3a: 206a 0020 moveal %a2@(32),%a0
5bf3e: 2f2e 0010 movel %fp@(16),%sp@-
5bf42: 2f2e 000c movel %fp@(12),%sp@-
5bf46: 2f0a movel %a2,%sp@-
5bf48: 2068 0008 moveal %a0@(8),%a0
5bf4c: 4e90 jsr %a0@
5bf4e: 4fef 000c lea %sp@(12),%sp
}
5bf52: 242e ffe4 movel %fp@(-28),%d2
5bf56: 246e ffe8 moveal %fp@(-24),%a2
5bf5a: 4e5e unlk %fp
...
000433e8 <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
433e8: 4e56 ffe0 linkw %fp,#-32
433ec: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@
433f0: 262e 0008 movel %fp@(8),%d3
433f4: 282e 000c movel %fp@(12),%d4
433f8: 246e 0010 moveal %fp@(16),%a2
433fc: 2a2e 0014 movel %fp@(20),%d5
43400: 2c2e 0018 movel %fp@(24),%d6
FILE *fp;
int match;
init_etc_passwd_group();
43404: 4eb9 0004 3308 jsr 43308 <init_etc_passwd_group>
if ((fp = fopen("/etc/group", "r")) == NULL)
4340a: 4879 0005 e19f pea 5e19f <_global_impure_ptr+0xc7>
43410: 4879 0005 d930 pea 5d930 <rtems_status_assoc+0x21a>
43416: 4eb9 0004 e0f2 jsr 4e0f2 <fopen>
4341c: 508f addql #8,%sp
4341e: 2400 movel %d0,%d2
43420: 660e bnes 43430 <getgr_r+0x48>
rtems_set_errno_and_return_minus_one( EINVAL );
43422: 4eb9 0004 d8fc jsr 4d8fc <__errno>
43428: 7216 moveq #22,%d1
4342a: 2040 moveal %d0,%a0
4342c: 2081 movel %d1,%a0@
4342e: 6068 bras 43498 <getgr_r+0xb0>
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
43430: 49fa fcf4 lea %pc@(43126 <scangr>),%a4
goto error_einval;
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
43434: 47f9 0004 f7e0 lea 4f7e0 <strcmp>,%a3
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
4343a: 2f06 movel %d6,%sp@-
4343c: 2f05 movel %d5,%sp@-
4343e: 2f0a movel %a2,%sp@-
43440: 2f02 movel %d2,%sp@-
43442: 4e94 jsr %a4@
43444: 4fef 0010 lea %sp@(16),%sp
43448: 4a80 tstl %d0
4344a: 6736 beqs 43482 <getgr_r+0x9a>
goto error_einval;
if (name) {
4344c: 4a83 tstl %d3
4344e: 670e beqs 4345e <getgr_r+0x76>
match = (strcmp(grp->gr_name, name) == 0);
43450: 2f03 movel %d3,%sp@-
43452: 2f12 movel %a2@,%sp@-
43454: 4e93 jsr %a3@
43456: 508f addql #8,%sp
43458: 4a80 tstl %d0
4345a: 57c0 seq %d0
4345c: 600a bras 43468 <getgr_r+0x80>
} else {
match = (grp->gr_gid == gid);
4345e: 4280 clrl %d0
43460: 302a 0008 movew %a2@(8),%d0
43464: b880 cmpl %d0,%d4
43466: 57c0 seq %d0
43468: 49c0 extbl %d0
4346a: 4480 negl %d0
}
if (match) {
4346c: 67cc beqs 4343a <getgr_r+0x52> <== NEVER TAKEN
fclose(fp);
4346e: 2f02 movel %d2,%sp@-
43470: 4eb9 0004 da30 jsr 4da30 <fclose>
*result = grp;
43476: 206e 001c moveal %fp@(28),%a0
return 0;
4347a: 588f addql #4,%sp
4347c: 4280 clrl %d0
match = (grp->gr_gid == gid);
}
if (match) {
fclose(fp);
*result = grp;
4347e: 208a movel %a2,%a0@
return 0;
43480: 6018 bras 4349a <getgr_r+0xb2>
}
}
error_einval:
fclose(fp);
43482: 2f02 movel %d2,%sp@-
43484: 4eb9 0004 da30 jsr 4da30 <fclose>
rtems_set_errno_and_return_minus_one( EINVAL );
4348a: 4eb9 0004 d8fc jsr 4d8fc <__errno>
43490: 588f addql #4,%sp
43492: 2040 moveal %d0,%a0
43494: 7016 moveq #22,%d0
43496: 2080 movel %d0,%a0@
43498: 70ff moveq #-1,%d0
}
4349a: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
434a0: 4e5e unlk %fp <== NOT EXECUTED
0004c1c4 <imfs_dir_open>:
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
4c1c4: 7001 moveq #1,%d0
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
4c1c6: 4e56 0000 linkw %fp,#0
4c1ca: 206e 0008 moveal %fp@(8),%a0
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
4c1ce: 2268 0018 moveal %a0@(24),%a1
4c1d2: b0a9 0048 cmpl %a1@(72),%d0
4c1d6: 6610 bnes 4c1e8 <imfs_dir_open+0x24> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
4c1d8: 4280 clrl %d0
4c1da: 4281 clrl %d1
4c1dc: 2140 000c movel %d0,%a0@(12)
4c1e0: 2141 0010 movel %d1,%a0@(16)
return 0;
4c1e4: 4280 clrl %d0
4c1e6: 6002 bras 4c1ea <imfs_dir_open+0x26>
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
return -1; /* It wasn't a directory --> return error */
4c1e8: 70ff moveq #-1,%d0 <== NOT EXECUTED
iop->offset = 0;
return 0;
}
4c1ea: 4e5e unlk %fp <== NOT EXECUTED
0004c1ee <imfs_dir_read>:
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4c1ee: 4e56 fec0 linkw %fp,#-320
4c1f2: 222e 0010 movel %fp@(16),%d1
4c1f6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4c1fa: 266e 0008 moveal %fp@(8),%a3
int current_entry;
int first_entry;
int last_entry;
struct dirent tmp_dirent;
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
4c1fe: 206b 0018 moveal %a3@(24),%a0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4c202: 2008 movel %a0,%d0
4c204: 0680 0000 0050 addil #80,%d0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4c20a: 2468 004c moveal %a0@(76),%a2
the_chain = &the_jnode->info.directory.Entries;
if ( rtems_chain_is_empty( the_chain ) )
4c20e: b08a cmpl %a2,%d0
4c210: 6700 00c2 beqw 4c2d4 <imfs_dir_read+0xe6>
bytes_transferred = 0;
first_entry = iop->offset;
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
4c214: 263c 0000 0110 movel #272,%d3
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
strcpy( tmp_dirent.d_name, the_jnode->name );
4c21a: 280e movel %fp,%d4
4c21c: 0684 ffff fef0 addil #-272,%d4
4c222: 2e04 movel %d4,%d7
4c224: 0687 0000 0010 addil #16,%d7
4c22a: 4bf9 0004 dbcc lea 4dbcc <strcpy>,%a5
memcpy(
4c230: 49f9 0004 d588 lea 4d588 <memcpy>,%a4
bytes_transferred = 0;
first_entry = iop->offset;
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
4c236: 4c43 1001 remul %d3,%d1,%d1
/* Move to the first of the desired directory entries */
the_node = rtems_chain_first( the_chain );
bytes_transferred = 0;
first_entry = iop->offset;
4c23a: 2a2b 0010 movel %a3@(16),%d5
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
4c23e: 2401 movel %d1,%d2
4c240: e189 lsll #8,%d1
4c242: e98a lsll #4,%d2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
4c244: 2d40 fee8 movel %d0,%fp@(-280)
4c248: d282 addl %d2,%d1
4c24a: d285 addl %d5,%d1
return 0;
/* Move to the first of the desired directory entries */
the_node = rtems_chain_first( the_chain );
bytes_transferred = 0;
4c24c: 4282 clrl %d2
first_entry = iop->offset;
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
4c24e: 2d41 feec movel %d1,%fp@(-276)
/* The directory was not empty so try to move to the desired entry in chain*/
for (
current_entry = 0;
4c252: 4243 clrw %d3
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
/* The directory was not empty so try to move to the desired entry in chain*/
for (
4c254: 6076 bras 4c2cc <imfs_dir_read+0xde>
current_entry = 0;
current_entry < last_entry;
current_entry = current_entry + sizeof(struct dirent) ){
if ( rtems_chain_is_tail( the_chain, the_node ) ){
4c256: b5ee fee8 cmpal %fp@(-280),%a2
4c25a: 677a beqs 4c2d6 <imfs_dir_read+0xe8> <== NEVER TAKEN
/* entry in the read */
return bytes_transferred; /* Indicate that there are no more */
/* entries to return */
}
if( current_entry >= first_entry ) {
4c25c: ba83 cmpl %d3,%d5
4c25e: 6e64 bgts 4c2c4 <imfs_dir_read+0xd6> <== NEVER TAKEN
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
4c260: 2d6a 0034 fef0 movel %a2@(52),%fp@(-272)
/* entries to return */
}
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
4c266: 2d43 fef8 movel %d3,%fp@(-264)
4c26a: 5bc6 smi %d6
4c26c: 49c6 extbl %d6
4c26e: 2d46 fef4 movel %d6,%fp@(-268)
tmp_dirent.d_reclen = sizeof( struct dirent );
4c272: 307c 0110 moveaw #272,%a0
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
4c276: 2c0a movel %a2,%d6
4c278: 0686 0000 000c addil #12,%d6
4c27e: 2f06 movel %d6,%sp@-
}
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
4c280: 3d48 fefc movew %a0,%fp@(-260)
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
4c284: 4eb9 0004 e0d4 jsr 4e0d4 <strlen>
strcpy( tmp_dirent.d_name, the_jnode->name );
4c28a: 2e86 movel %d6,%sp@
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
4c28c: 3d40 fefe movew %d0,%fp@(-258)
strcpy( tmp_dirent.d_name, the_jnode->name );
4c290: 2f07 movel %d7,%sp@-
4c292: 4e95 jsr %a5@
memcpy(
4c294: 4878 0110 pea 110 <DBL_MANT_DIG+0xdb>
4c298: 206e 000c moveal %fp@(12),%a0
4c29c: 2f04 movel %d4,%sp@-
4c29e: 4870 2800 pea %a0@(00000000,%d2:l)
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
bytes_transferred = bytes_transferred + sizeof( struct dirent );
4c2a2: 0682 0000 0110 addil #272,%d2
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
strcpy( tmp_dirent.d_name, the_jnode->name );
memcpy(
4c2a8: 4e94 jsr %a4@
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
bytes_transferred = bytes_transferred + sizeof( struct dirent );
4c2aa: 4fef 0014 lea %sp@(20),%sp
memcpy(
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
4c2ae: 4280 clrl %d0
4c2b0: 223c 0000 0110 movel #272,%d1
4c2b6: d3ab 0010 addl %d1,%a3@(16)
4c2ba: 2c2b 000c movel %a3@(12),%d6
4c2be: dd80 addxl %d0,%d6
4c2c0: 2746 000c movel %d6,%a3@(12)
bytes_transferred = bytes_transferred + sizeof( struct dirent );
}
the_node = the_node->next;
4c2c4: 2452 moveal %a2@,%a2
* to the end of the exisiting file, the remaining entries will be placed in
* the buffer and the returned value will be equal to -m actual- times the
* size of a directory entry.
*/
ssize_t imfs_dir_read(
4c2c6: 0683 0000 0110 addil #272,%d3
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
/* The directory was not empty so try to move to the desired entry in chain*/
for (
4c2cc: b6ae feec cmpl %fp@(-276),%d3
4c2d0: 6d84 blts 4c256 <imfs_dir_read+0x68> <== NEVER TAKEN
4c2d2: 6002 bras 4c2d6 <imfs_dir_read+0xe8>
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
the_chain = &the_jnode->info.directory.Entries;
if ( rtems_chain_is_empty( the_chain ) )
return 0;
4c2d4: 4282 clrl %d2
the_node = the_node->next;
}
/* Success */
return bytes_transferred;
}
4c2d6: 2002 movel %d2,%d0
4c2d8: 4cee 3cfc fec0 moveml %fp@(-320),%d2-%d7/%a2-%a5
4c2de: 4e5e unlk %fp <== NOT EXECUTED
0004c402 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
4c402: 4e56 0000 linkw %fp,#0
4c406: 206e 000c moveal %fp@(12),%a0
4c40a: 2f0a movel %a2,%sp@-
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
4c40c: 2450 moveal %a0@,%a2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4c40e: 200a movel %a2,%d0
4c410: 0680 0000 0050 addil #80,%d0
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
4c416: b0aa 004c cmpl %a2@(76),%d0
4c41a: 670e beqs 4c42a <imfs_dir_rmnod+0x28>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
4c41c: 4eb9 0004 cd68 jsr 4cd68 <__errno>
4c422: 2040 moveal %d0,%a0
4c424: 705a moveq #90,%d0
4c426: 2080 movel %d0,%a0@
4c428: 6016 bras 4c440 <imfs_dir_rmnod+0x3e>
4c42a: 2068 0010 moveal %a0@(16),%a0
/*
* You cannot remove the file system root node.
*/
if ( rtems_filesystem_is_root_location(pathloc) )
4c42e: b5e8 001c cmpal %a0@(28),%a2
4c432: 6610 bnes 4c444 <imfs_dir_rmnod+0x42>
rtems_set_errno_and_return_minus_one( EBUSY );
4c434: 4eb9 0004 cd68 jsr 4cd68 <__errno>
4c43a: 7210 moveq #16,%d1
4c43c: 2040 moveal %d0,%a0
4c43e: 2081 movel %d1,%a0@
4c440: 70ff moveq #-1,%d0
4c442: 601a bras 4c45e <imfs_dir_rmnod+0x5c>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
4c444: 4aaa 0058 tstl %a2@(88)
4c448: 66ea bnes 4c434 <imfs_dir_rmnod+0x32> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
4c44a: 2f0a movel %a2,%sp@-
4c44c: 4eb9 0004 9a3c jsr 49a3c <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
4c452: 2f0a movel %a2,%sp@-
4c454: 4eb9 0004 9a80 jsr 49a80 <IMFS_check_node_remove>
return 0;
4c45a: 508f addql #8,%sp
4c45c: 4280 clrl %d0
}
4c45e: 246e fffc moveal %fp@(-4),%a2
4c462: 4e5e unlk %fp
...
00043308 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
43308: 4e56 0000 linkw %fp,#0
4330c: 2f0a movel %a2,%sp@-
4330e: 2f02 movel %d2,%sp@-
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
43310: 4a39 0005 f940 tstb 5f940 <etc_passwd_initted.6430>
43316: 6600 00c4 bnew 433dc <init_etc_passwd_group+0xd4>
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
4331a: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
4331e: 45f9 0004 e0f2 lea 4e0f2 <fopen>,%a2
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
43324: 4879 0005 d8b6 pea 5d8b6 <rtems_status_assoc+0x1a0>
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
4332a: 7001 moveq #1,%d0
4332c: 13c0 0005 f940 moveb %d0,5f940 <etc_passwd_initted.6430>
mkdir("/etc", 0777);
43332: 4eb9 0004 3b1c jsr 43b1c <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
43338: 4879 0005 e19f pea 5e19f <_global_impure_ptr+0xc7>
4333e: 4879 0005 d8bb pea 5d8bb <rtems_status_assoc+0x1a5>
43344: 4e92 jsr %a2@
43346: 4fef 0010 lea %sp@(16),%sp
4334a: 4a80 tstl %d0
4334c: 670c beqs 4335a <init_etc_passwd_group+0x52>
fclose(fp);
4334e: 2f00 movel %d0,%sp@-
43350: 4eb9 0004 da30 jsr 4da30 <fclose>
43356: 588f addql #4,%sp
43358: 602e bras 43388 <init_etc_passwd_group+0x80>
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
4335a: 4879 0005 d8c7 pea 5d8c7 <rtems_status_assoc+0x1b1>
43360: 4879 0005 d8bb pea 5d8bb <rtems_status_assoc+0x1a5>
43366: 4e92 jsr %a2@
43368: 508f addql #8,%sp
4336a: 2400 movel %d0,%d2
4336c: 671a beqs 43388 <init_etc_passwd_group+0x80> <== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
4336e: 2f00 movel %d0,%sp@-
43370: 4879 0005 d8c9 pea 5d8c9 <rtems_status_assoc+0x1b3>
43376: 4eb9 0004 e1d4 jsr 4e1d4 <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
4337c: 2f02 movel %d2,%sp@-
4337e: 4eb9 0004 da30 jsr 4da30 <fclose>
43384: 4fef 000c lea %sp@(12),%sp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
43388: 4879 0005 e19f pea 5e19f <_global_impure_ptr+0xc7>
4338e: 45f9 0004 e0f2 lea 4e0f2 <fopen>,%a2
43394: 4879 0005 d930 pea 5d930 <rtems_status_assoc+0x21a>
4339a: 4e92 jsr %a2@
4339c: 508f addql #8,%sp
4339e: 4a80 tstl %d0
433a0: 670c beqs 433ae <init_etc_passwd_group+0xa6>
fclose(fp);
433a2: 2f00 movel %d0,%sp@-
433a4: 4eb9 0004 da30 jsr 4da30 <fclose>
433aa: 588f addql #4,%sp
433ac: 602e bras 433dc <init_etc_passwd_group+0xd4>
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
433ae: 4879 0005 d8c7 pea 5d8c7 <rtems_status_assoc+0x1b1>
433b4: 4879 0005 d930 pea 5d930 <rtems_status_assoc+0x21a>
433ba: 4e92 jsr %a2@
433bc: 508f addql #8,%sp
433be: 2400 movel %d0,%d2
433c0: 671a beqs 433dc <init_etc_passwd_group+0xd4> <== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
433c2: 2f00 movel %d0,%sp@-
433c4: 4879 0005 d93b pea 5d93b <rtems_status_assoc+0x225>
433ca: 4eb9 0004 e1d4 jsr 4e1d4 <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
433d0: 2f02 movel %d2,%sp@-
433d2: 4eb9 0004 da30 jsr 4da30 <fclose>
433d8: 4fef 000c lea %sp@(12),%sp
}
}
433dc: 242e fff8 movel %fp@(-8),%d2
433e0: 246e fffc moveal %fp@(-4),%a2
433e4: 4e5e unlk %fp <== NOT EXECUTED
0004467a <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
4467a: 4e56 fff4 linkw %fp,#-12
4467e: 222e 0008 movel %fp@(8),%d1
44682: 48d7 040c moveml %d2-%d3/%a2,%sp@
44686: 246e 000c moveal %fp@(12),%a2
if (tty->termios.c_iflag & ISTRIP)
4468a: 202a 0030 movel %a2@(48),%d0
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
4468e: 1401 moveb %d1,%d2
if (tty->termios.c_iflag & ISTRIP)
44690: 0800 0005 btst #5,%d0
44694: 6704 beqs 4469a <iproc+0x20> <== ALWAYS TAKEN
c &= 0x7f;
44696: 747f moveq #127,%d2 <== NOT EXECUTED
44698: c481 andl %d1,%d2 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
4469a: 0800 0009 btst #9,%d0
4469e: 6724 beqs 446c4 <iproc+0x4a>
c = tolower (c);
446a0: 2079 0005 d4e4 moveal 5d4e4 <__ctype_ptr__>,%a0
446a6: 7603 moveq #3,%d3
446a8: 0282 0000 00ff andil #255,%d2
446ae: 1230 2801 moveb %a0@(00000001,%d2:l),%d1
446b2: 49c1 extbl %d1
446b4: c283 andl %d3,%d1
446b6: 163c 0001 moveb #1,%d3
446ba: b681 cmpl %d1,%d3
446bc: 6606 bnes 446c4 <iproc+0x4a>
446be: 0682 0000 0020 addil #32,%d2
if (c == '\r') {
446c4: 4281 clrl %d1
446c6: 1202 moveb %d2,%d1
446c8: 760d moveq #13,%d3
446ca: b681 cmpl %d1,%d3
446cc: 6610 bnes 446de <iproc+0x64>
if (tty->termios.c_iflag & IGNCR)
446ce: 4a00 tstb %d0
446d0: 6d00 0104 bltw 447d6 <iproc+0x15c>
return 0;
if (tty->termios.c_iflag & ICRNL)
446d4: 0800 0008 btst #8,%d0
446d8: 671a beqs 446f4 <iproc+0x7a> <== NEVER TAKEN
c = '\n';
446da: 740a moveq #10,%d2
446dc: 6016 bras 446f4 <iproc+0x7a>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
446de: 760a moveq #10,%d3
446e0: b681 cmpl %d1,%d3
446e2: 660a bnes 446ee <iproc+0x74>
446e4: 0800 0006 btst #6,%d0
446e8: 670a beqs 446f4 <iproc+0x7a> <== ALWAYS TAKEN
c = '\r';
446ea: 740d moveq #13,%d2 <== NOT EXECUTED
446ec: 6006 bras 446f4 <iproc+0x7a> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
446ee: 4a02 tstb %d2
446f0: 6700 00a8 beqw 4479a <iproc+0x120>
446f4: 222a 003c movel %a2@(60),%d1
446f8: 0801 0001 btst #1,%d1
446fc: 6700 009c beqw 4479a <iproc+0x120>
if (c == tty->termios.c_cc[VERASE]) {
44700: 4283 clrl %d3
44702: 162a 0043 moveb %a2@(67),%d3
44706: 4280 clrl %d0
44708: 1002 moveb %d2,%d0
4470a: b680 cmpl %d0,%d3
4470c: 6604 bnes 44712 <iproc+0x98>
erase (tty, 0);
4470e: 42a7 clrl %sp@-
44710: 600e bras 44720 <iproc+0xa6>
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
44712: 4283 clrl %d3
44714: 162a 0044 moveb %a2@(68),%d3
44718: b680 cmpl %d0,%d3
4471a: 6610 bnes 4472c <iproc+0xb2>
erase (tty, 1);
4471c: 4878 0001 pea 1 <ADD>
44720: 2f0a movel %a2,%sp@-
44722: 4eba fdc4 jsr %pc@(444e8 <erase>)
return 0;
44726: 508f addql #8,%sp
44728: 6000 00ac braw 447d6 <iproc+0x15c>
}
else if (c == tty->termios.c_cc[VEOF]) {
4472c: 4283 clrl %d3
4472e: 162a 0045 moveb %a2@(69),%d3
44732: b680 cmpl %d0,%d3
44734: 6700 009c beqw 447d2 <iproc+0x158>
return 1;
} else if (c == '\n') {
44738: 760a moveq #10,%d3
4473a: b680 cmpl %d0,%d3
4473c: 6622 bnes 44760 <iproc+0xe6>
if (tty->termios.c_lflag & (ECHO | ECHONL))
4473e: 7048 moveq #72,%d0
44740: c280 andl %d0,%d1
44742: 670c beqs 44750 <iproc+0xd6> <== NEVER TAKEN
echo (c, tty);
44744: 2f0a movel %a2,%sp@-
44746: 4878 000a pea a <LASTO>
4474a: 4eba fd14 jsr %pc@(44460 <echo>)
4474e: 508f addql #8,%sp
tty->cbuf[tty->ccount++] = c;
44750: 202a 0020 movel %a2@(32),%d0
44754: 206a 001c moveal %a2@(28),%a0
44758: 720a moveq #10,%d1
4475a: 1181 0800 moveb %d1,%a0@(00000000,%d0:l)
4475e: 6032 bras 44792 <iproc+0x118>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
44760: 4283 clrl %d3
44762: 162a 004c moveb %a2@(76),%d3
44766: b680 cmpl %d0,%d3
44768: 670a beqs 44774 <iproc+0xfa> <== NEVER TAKEN
4476a: 4283 clrl %d3
4476c: 162a 0051 moveb %a2@(81),%d3
44770: b680 cmpl %d0,%d3
44772: 6626 bnes 4479a <iproc+0x120> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
44774: 44c1 movew %d1,%ccr <== NOT EXECUTED
44776: 6a0e bpls 44786 <iproc+0x10c> <== NOT EXECUTED
echo (c, tty);
44778: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4477a: 4280 clrl %d0 <== NOT EXECUTED
4477c: 1002 moveb %d2,%d0 <== NOT EXECUTED
4477e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
44780: 4eba fcde jsr %pc@(44460 <echo>) <== NOT EXECUTED
44784: 508f addql #8,%sp <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
44786: 202a 0020 movel %a2@(32),%d0 <== NOT EXECUTED
4478a: 206a 001c moveal %a2@(28),%a0 <== NOT EXECUTED
4478e: 1182 0800 moveb %d2,%a0@(00000000,%d0:l) <== NOT EXECUTED
44792: 5280 addql #1,%d0
44794: 2540 0020 movel %d0,%a2@(32)
44798: 6038 bras 447d2 <iproc+0x158>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
4479a: 2039 0005 d418 movel 5d418 <rtems_termios_cbufsize>,%d0
447a0: 5380 subql #1,%d0
447a2: b0aa 0020 cmpl %a2@(32),%d0
447a6: 6f2e bles 447d6 <iproc+0x15c> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
447a8: 7008 moveq #8,%d0
447aa: c0aa 003c andl %a2@(60),%d0
447ae: 670e beqs 447be <iproc+0x144> <== NEVER TAKEN
echo (c, tty);
447b0: 2f0a movel %a2,%sp@-
447b2: 4280 clrl %d0
447b4: 1002 moveb %d2,%d0
447b6: 2f00 movel %d0,%sp@-
447b8: 4eba fca6 jsr %pc@(44460 <echo>)
447bc: 508f addql #8,%sp
tty->cbuf[tty->ccount++] = c;
447be: 202a 0020 movel %a2@(32),%d0
447c2: 206a 001c moveal %a2@(28),%a0
447c6: 1182 0800 moveb %d2,%a0@(00000000,%d0:l)
447ca: 5280 addql #1,%d0
447cc: 2540 0020 movel %d0,%a2@(32)
447d0: 6004 bras 447d6 <iproc+0x15c>
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
447d2: 7001 moveq #1,%d0
447d4: 6002 bras 447d8 <iproc+0x15e>
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
447d6: 4280 clrl %d0
}
447d8: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
447de: 4e5e unlk %fp <== NOT EXECUTED
0005ac44 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
5ac44: 4e56 ffcc linkw %fp,#-52
5ac48: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
5ac4c: 242e 000c movel %fp@(12),%d2
5ac50: 246e 0010 moveal %fp@(16),%a2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
5ac54: 4eb9 0005 a870 jsr 5a870 <getpid>
5ac5a: b0ae 0008 cmpl %fp@(8),%d0
5ac5e: 6710 beqs 5ac70 <killinfo+0x2c>
rtems_set_errno_and_return_minus_one( ESRCH );
5ac60: 4eb9 0004 cd68 jsr 4cd68 <__errno>
5ac66: 7403 moveq #3,%d2
5ac68: 2040 moveal %d0,%a0
5ac6a: 2082 movel %d2,%a0@
5ac6c: 6000 01ae braw 5ae1c <killinfo+0x1d8>
/*
* Validate the signal passed.
*/
if ( !sig )
5ac70: 4a82 tstl %d2
5ac72: 670a beqs 5ac7e <killinfo+0x3a>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
5ac74: 2002 movel %d2,%d0
5ac76: 5380 subql #1,%d0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
5ac78: 721f moveq #31,%d1
5ac7a: b280 cmpl %d0,%d1
5ac7c: 6410 bccs 5ac8e <killinfo+0x4a>
rtems_set_errno_and_return_minus_one( EINVAL );
5ac7e: 4eb9 0004 cd68 jsr 4cd68 <__errno>
5ac84: 7216 moveq #22,%d1
5ac86: 2040 moveal %d0,%a0
5ac88: 2081 movel %d1,%a0@
5ac8a: 6000 0190 braw 5ae1c <killinfo+0x1d8>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
5ac8e: 2202 movel %d2,%d1
5ac90: 2802 movel %d2,%d4
5ac92: e589 lsll #2,%d1
5ac94: e98c lsll #4,%d4
5ac96: 9881 subl %d1,%d4
5ac98: 2044 moveal %d4,%a0
5ac9a: d1fc 0005 f03c addal #389180,%a0
5aca0: 7201 moveq #1,%d1
5aca2: b290 cmpl %a0@,%d1
5aca4: 6700 01ae beqw 5ae54 <killinfo+0x210>
/*
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
5aca8: 123c 0008 moveb #8,%d1
5acac: b282 cmpl %d2,%d1
5acae: 6710 beqs 5acc0 <killinfo+0x7c>
5acb0: 123c 0004 moveb #4,%d1
5acb4: b282 cmpl %d2,%d1
5acb6: 6708 beqs 5acc0 <killinfo+0x7c>
5acb8: 123c 000b moveb #11,%d1
5acbc: b282 cmpl %d2,%d1
5acbe: 6616 bnes 5acd6 <killinfo+0x92>
return pthread_kill( pthread_self(), sig );
5acc0: 4eb9 0005 b028 jsr 5b028 <pthread_self>
5acc6: 2f02 movel %d2,%sp@-
5acc8: 2f00 movel %d0,%sp@-
5acca: 4eb9 0005 af7c jsr 5af7c <pthread_kill>
5acd0: 508f addql #8,%sp
5acd2: 6000 0182 braw 5ae56 <killinfo+0x212>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
5acd6: 7601 moveq #1,%d3
5acd8: e1ab lsll %d0,%d3
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
5acda: 7001 moveq #1,%d0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
5acdc: 2d42 fff4 movel %d2,%fp@(-12)
siginfo->si_code = SI_USER;
5ace0: 2d40 fff8 movel %d0,%fp@(-8)
if ( !value ) {
5ace4: 4a8a tstl %a2
5ace6: 6606 bnes 5acee <killinfo+0xaa>
siginfo->si_value.sival_int = 0;
5ace8: 42ae fffc clrl %fp@(-4)
5acec: 6004 bras 5acf2 <killinfo+0xae>
} else {
siginfo->si_value = *value;
5acee: 2d52 fffc movel %a2@,%fp@(-4)
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
5acf2: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
5acf8: 5280 addql #1,%d0
5acfa: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
5ad00: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
/*
* Is the currently executing thread interested? If so then it will
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
5ad06: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
5ad0c: 2268 0102 moveal %a0@(258),%a1
5ad10: 2029 00d0 movel %a1@(208),%d0
5ad14: 4680 notl %d0
5ad16: c083 andl %d3,%d0
5ad18: 6600 00ae bnew 5adc8 <killinfo+0x184>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
5ad1c: 2079 0005 f1c0 moveal 5f1c0 <_POSIX_signals_Wait_queue>,%a0
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
5ad22: 601c bras 5ad40 <killinfo+0xfc>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
5ad24: 2003 movel %d3,%d0
5ad26: c0a8 0030 andl %a0@(48),%d0
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
5ad2a: 2268 0102 moveal %a0@(258),%a1
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
5ad2e: 6600 0098 bnew 5adc8 <killinfo+0x184>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
5ad32: 2029 00d0 movel %a1@(208),%d0
5ad36: 4680 notl %d0
5ad38: c083 andl %d3,%d0
5ad3a: 6600 008c bnew 5adc8 <killinfo+0x184>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
5ad3e: 2050 moveal %a0@,%a0
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
5ad40: b1fc 0005 f1c4 cmpal #389572,%a0
5ad46: 66dc bnes 5ad24 <killinfo+0xe0>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
5ad48: 4280 clrl %d0
5ad4a: 1039 0005 d1fa moveb 5d1fa <rtems_maximum_priority>,%d0
5ad50: 45f9 0005 eb5c lea 5eb5c <_Objects_Information_table+0x8>,%a2
5ad56: 5280 addql #1,%d0
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
5ad58: 91c8 subal %a0,%a0
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
5ad5a: 225a moveal %a2@+,%a1
5ad5c: 4a89 tstl %a1
5ad5e: 675c beqs 5adbc <killinfo+0x178> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
5ad60: 2269 0004 moveal %a1@(4),%a1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
5ad64: 4281 clrl %d1
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5ad66: 7a01 moveq #1,%d5
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
5ad68: 3229 000e movew %a1@(14),%d1
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
5ad6c: 2669 0018 moveal %a1@(24),%a3
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
5ad70: 2841 moveal %d1,%a4
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
5ad72: 588b addql #4,%a3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5ad74: 6042 bras 5adb8 <killinfo+0x174>
the_thread = (Thread_Control *) object_table[ index ];
5ad76: 225b moveal %a3@+,%a1
if ( !the_thread )
5ad78: 4a89 tstl %a1
5ad7a: 673a beqs 5adb6 <killinfo+0x172>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
5ad7c: 2229 0014 movel %a1@(20),%d1
5ad80: b081 cmpl %d1,%d0
5ad82: 6532 bcss 5adb6 <killinfo+0x172>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
5ad84: 2a69 0102 moveal %a1@(258),%a5
5ad88: 2c2d 00d0 movel %a5@(208),%d6
5ad8c: 4686 notl %d6
5ad8e: cc83 andl %d3,%d6
5ad90: 6724 beqs 5adb6 <killinfo+0x172>
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
5ad92: b081 cmpl %d1,%d0
5ad94: 621c bhis 5adb2 <killinfo+0x16e>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
5ad96: 4a88 tstl %a0
5ad98: 671c beqs 5adb6 <killinfo+0x172> <== NEVER TAKEN
5ad9a: 2e28 0010 movel %a0@(16),%d7
5ad9e: 6716 beqs 5adb6 <killinfo+0x172> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
5ada0: 2c29 0010 movel %a1@(16),%d6
5ada4: 670c beqs 5adb2 <killinfo+0x16e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
5ada6: 0807 001c btst #28,%d7
5adaa: 660a bnes 5adb6 <killinfo+0x172>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
5adac: 0806 001c btst #28,%d6
5adb0: 6704 beqs 5adb6 <killinfo+0x172>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
5adb2: 2001 movel %d1,%d0
5adb4: 2049 moveal %a1,%a0
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5adb6: 5285 addql #1,%d5
5adb8: b9c5 cmpal %d5,%a4
5adba: 64ba bccs 5ad76 <killinfo+0x132>
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
5adbc: b5fc 0005 eb64 cmpal #387940,%a2
5adc2: 6696 bnes 5ad5a <killinfo+0x116>
}
}
}
}
if ( interested ) {
5adc4: 4a88 tstl %a0
5adc6: 6716 beqs 5adde <killinfo+0x19a>
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
5adc8: 486e fff4 pea %fp@(-12)
5adcc: 2f02 movel %d2,%sp@-
5adce: 2f08 movel %a0,%sp@-
5add0: 4eb9 0005 ae80 jsr 5ae80 <_POSIX_signals_Unblock_thread>
5add6: 4fef 000c lea %sp@(12),%sp
5adda: 4a00 tstb %d0
5addc: 6670 bnes 5ae4e <killinfo+0x20a>
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
5adde: 2f03 movel %d3,%sp@-
5ade0: 4eb9 0005 ae60 jsr 5ae60 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
5ade6: 588f addql #4,%sp
5ade8: 41f9 0005 f034 lea 5f034 <_POSIX_signals_Vectors>,%a0
5adee: 7002 moveq #2,%d0
5adf0: b0b0 4800 cmpl %a0@(00000000,%d4:l),%d0
5adf4: 6658 bnes 5ae4e <killinfo+0x20a>
psiginfo = (POSIX_signals_Siginfo_node *)
5adf6: 4879 0005 f1b4 pea 5f1b4 <_POSIX_signals_Inactive_siginfo>
5adfc: 4eb9 0004 6414 jsr 46414 <_Chain_Get>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
5ae02: 588f addql #4,%sp
*/
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
5ae04: 2440 moveal %d0,%a2
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
5ae06: 4a80 tstl %d0
5ae08: 6616 bnes 5ae20 <killinfo+0x1dc>
_Thread_Enable_dispatch();
5ae0a: 4eb9 0004 7d80 jsr 47d80 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
5ae10: 4eb9 0004 cd68 jsr 4cd68 <__errno>
5ae16: 2040 moveal %d0,%a0
5ae18: 700b moveq #11,%d0
5ae1a: 2080 movel %d0,%a0@
5ae1c: 70ff moveq #-1,%d0
5ae1e: 6036 bras 5ae56 <killinfo+0x212>
}
psiginfo->Info = *siginfo;
5ae20: 4878 000c pea c <OPER1>
5ae24: 486e fff4 pea %fp@(-12)
5ae28: 486a 0008 pea %a2@(8)
5ae2c: 4eb9 0004 d588 jsr 4d588 <memcpy>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
5ae32: 2002 movel %d2,%d0
5ae34: e98a lsll #4,%d2
5ae36: e588 lsll #2,%d0
5ae38: 2f0a movel %a2,%sp@-
5ae3a: 9480 subl %d0,%d2
5ae3c: 0682 0005 f22c addil #389676,%d2
5ae42: 2f02 movel %d2,%sp@-
5ae44: 4eb9 0004 63b4 jsr 463b4 <_Chain_Append>
5ae4a: 4fef 0014 lea %sp@(20),%sp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
5ae4e: 4eb9 0004 7d80 jsr 47d80 <_Thread_Enable_dispatch>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
return 0;
5ae54: 4280 clrl %d0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
5ae56: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5
5ae5c: 4e5e unlk %fp <== NOT EXECUTED
000432d0 <libc_wrapup>:
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
432d0: 7003 moveq #3,%d0
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
432d2: 4e56 0000 linkw %fp,#0
432d6: 2f0a movel %a2,%sp@-
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
432d8: b0b9 0005 ecdc cmpl 5ecdc <_System_state_Current>,%d0
432de: 664c bnes 4332c <libc_wrapup+0x5c> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
432e0: 2479 0005 c9ee moveal 5c9ee <_global_impure_ptr>,%a2
432e6: b5f9 0005 d4e8 cmpal 5d4e8 <_impure_ptr>,%a2
432ec: 6710 beqs 432fe <libc_wrapup+0x2e>
_wrapup_reent(_global_impure_ptr);
432ee: 2f0a movel %a2,%sp@-
432f0: 4eb9 0004 d7d2 jsr 4d7d2 <_wrapup_reent>
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
432f6: 588f addql #4,%sp
432f8: 23ca 0005 d4e8 movel %a2,5d4e8 <_impure_ptr>
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
432fe: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
43304: 45f9 0004 ce9c lea 4ce9c <fclose>,%a2
4330a: 2f28 0004 movel %a0@(4),%sp@-
4330e: 4e92 jsr %a2@
fclose (stdout);
43310: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
43316: 2f28 0008 movel %a0@(8),%sp@-
4331a: 4e92 jsr %a2@
fclose (stderr);
4331c: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
43322: 2f28 000c movel %a0@(12),%sp@-
43326: 4e92 jsr %a2@
43328: 4fef 000c lea %sp@(12),%sp
}
4332c: 246e fffc moveal %fp@(-4),%a2
43330: 4e5e unlk %fp <== NOT EXECUTED
00044b78 <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
44b78: 4e56 ffdc linkw %fp,#-36
44b7c: 48d7 001c moveml %d2-%d4,%sp@
44b80: 282e 0008 movel %fp@(8),%d4
44b84: 262e 000c movel %fp@(12),%d3
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
44b88: 660e bnes 44b98 <lstat+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
44b8a: 4eb9 0004 f130 jsr 4f130 <__errno>
44b90: 2040 moveal %d0,%a0
44b92: 700e moveq #14,%d0
44b94: 2080 movel %d0,%a0@
44b96: 605a bras 44bf2 <lstat+0x7a>
status = rtems_filesystem_evaluate_path( path, strlen( path ),
44b98: 2f04 movel %d4,%sp@-
44b9a: 240e movel %fp,%d2
44b9c: 0682 ffff ffec addil #-20,%d2
44ba2: 4eb9 0005 0618 jsr 50618 <strlen>
44ba8: 4297 clrl %sp@
44baa: 2f02 movel %d2,%sp@-
44bac: 42a7 clrl %sp@-
44bae: 2f00 movel %d0,%sp@-
44bb0: 2f04 movel %d4,%sp@-
44bb2: 4eb9 0004 44c0 jsr 444c0 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
44bb8: 4fef 0014 lea %sp@(20),%sp
44bbc: 4a80 tstl %d0
44bbe: 6632 bnes 44bf2 <lstat+0x7a> <== NEVER TAKEN
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
44bc0: 4878 0046 pea 46 <DBL_MANT_DIG+0x11>
44bc4: 42a7 clrl %sp@-
44bc6: 2f03 movel %d3,%sp@-
44bc8: 4eb9 0004 f9c0 jsr 4f9c0 <memset>
status = (*loc.handlers->fstat_h)( &loc, buf );
44bce: 206e fff4 moveal %fp@(-12),%a0
44bd2: 2f03 movel %d3,%sp@-
44bd4: 2f02 movel %d2,%sp@-
44bd6: 2068 0018 moveal %a0@(24),%a0
44bda: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
44bdc: 2f02 movel %d2,%sp@-
44bde: 2d40 ffe8 movel %d0,%fp@(-24)
44be2: 4eb9 0004 468c jsr 4468c <rtems_filesystem_freenode>
return status;
44be8: 202e ffe8 movel %fp@(-24),%d0
44bec: 4fef 0018 lea %sp@(24),%sp
44bf0: 6002 bras 44bf4 <lstat+0x7c>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
return -1;
44bf2: 70ff moveq #-1,%d0
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
44bf4: 4cee 001c ffdc moveml %fp@(-36),%d2-%d4
44bfa: 4e5e unlk %fp <== NOT EXECUTED
00042e54 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
42e54: 4e56 0000 linkw %fp,#0
void *return_this;
MSBUMP(malloc_calls, 1);
42e58: 52b9 0005 ea60 addql #1,5ea60 <rtems_malloc_statistics+0x4>
#include "malloc_p.h"
void *malloc(
size_t size
)
{
42e5e: 2f03 movel %d3,%sp@-
42e60: 2f02 movel %d2,%sp@-
42e62: 242e 0008 movel %fp@(8),%d2
MSBUMP(malloc_calls, 1);
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
42e66: 4eb9 0004 2d4a jsr 42d4a <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
42e6c: 4a82 tstl %d2
42e6e: 677e beqs 42eee <malloc+0x9a>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
42e70: 7003 moveq #3,%d0
42e72: b0b9 0005 ecdc cmpl 5ecdc <_System_state_Current>,%d0
42e78: 660a bnes 42e84 <malloc+0x30>
!malloc_is_system_state_OK() )
42e7a: 4eb9 0004 2d0c jsr 42d0c <malloc_is_system_state_OK>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
42e80: 4a00 tstb %d0
42e82: 676a beqs 42eee <malloc+0x9a> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
42e84: 42a7 clrl %sp@-
42e86: 42a7 clrl %sp@-
42e88: 2f02 movel %d2,%sp@-
42e8a: 2f39 0005 d29a movel 5d29a <RTEMS_Malloc_Heap>,%sp@-
42e90: 4eb9 0004 73ac jsr 473ac <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
42e96: 4fef 0010 lea %sp@(16),%sp
42e9a: 4a80 tstl %d0
42e9c: 6626 bnes 42ec4 <malloc+0x70>
if (rtems_malloc_sbrk_helpers)
42e9e: 2079 0005 da10 moveal 5da10 <rtems_malloc_sbrk_helpers>,%a0
42ea4: 4a88 tstl %a0
42ea6: 670e beqs 42eb6 <malloc+0x62>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
42ea8: 2f02 movel %d2,%sp@-
42eaa: 2068 0004 moveal %a0@(4),%a0
42eae: 4e90 jsr %a0@
if ( !return_this ) {
42eb0: 588f addql #4,%sp
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
42eb2: 2600 movel %d0,%d3
if ( !return_this ) {
42eb4: 6610 bnes 42ec6 <malloc+0x72>
errno = ENOMEM;
42eb6: 4eb9 0004 cd68 jsr 4cd68 <__errno>
42ebc: 2040 moveal %d0,%a0
42ebe: 700c moveq #12,%d0
42ec0: 2080 movel %d0,%a0@
42ec2: 602a bras 42eee <malloc+0x9a>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
42ec4: 2600 movel %d0,%d3
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
42ec6: 2079 0005 da0c moveal 5da0c <rtems_malloc_dirty_helper>,%a0
42ecc: 4a88 tstl %a0
42ece: 6708 beqs 42ed8 <malloc+0x84>
(*rtems_malloc_dirty_helper)( return_this, size );
42ed0: 2f02 movel %d2,%sp@-
42ed2: 2f03 movel %d3,%sp@-
42ed4: 4e90 jsr %a0@
42ed6: 508f addql #8,%sp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
42ed8: 2079 0005 da14 moveal 5da14 <rtems_malloc_statistics_helpers>,%a0
42ede: 4a88 tstl %a0
42ee0: 670e beqs 42ef0 <malloc+0x9c>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
42ee2: 2f03 movel %d3,%sp@-
42ee4: 2068 0004 moveal %a0@(4),%a0
42ee8: 4e90 jsr %a0@
42eea: 588f addql #4,%sp
42eec: 6002 bras 42ef0 <malloc+0x9c>
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
return NULL;
42eee: 4283 clrl %d3
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
return return_this;
}
42ef0: 2003 movel %d3,%d0
42ef2: 242e fff8 movel %fp@(-8),%d2
42ef6: 262e fffc movel %fp@(-4),%d3
42efa: 4e5e unlk %fp
...
00042be0 <malloc_get_statistics>:
#include "malloc_p.h"
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
42be0: 4e56 0000 linkw %fp,#0
42be4: 2f02 movel %d2,%sp@-
42be6: 242e 0008 movel %fp@(8),%d2
if ( !stats )
42bea: 6732 beqs 42c1e <malloc_get_statistics+0x3e> <== NEVER TAKEN
return -1;
_RTEMS_Lock_allocator();
42bec: 2f39 0005 e918 movel 5e918 <_RTEMS_Allocator_Mutex>,%sp@-
42bf2: 4eb9 0004 615c jsr 4615c <_API_Mutex_Lock>
*stats = rtems_malloc_statistics;
42bf8: 4878 002c pea 2c <OPER2+0x18>
42bfc: 4879 0005 e73c pea 5e73c <rtems_malloc_statistics>
42c02: 2f02 movel %d2,%sp@-
42c04: 4eb9 0004 d354 jsr 4d354 <memcpy>
_RTEMS_Unlock_allocator();
42c0a: 2f39 0005 e918 movel 5e918 <_RTEMS_Allocator_Mutex>,%sp@-
42c10: 4eb9 0004 61bc jsr 461bc <_API_Mutex_Unlock>
return 0;
42c16: 4fef 0014 lea %sp@(20),%sp
42c1a: 4280 clrl %d0
42c1c: 6002 bras 42c20 <malloc_get_statistics+0x40>
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
if ( !stats )
return -1;
42c1e: 70ff moveq #-1,%d0
_RTEMS_Lock_allocator();
*stats = rtems_malloc_statistics;
_RTEMS_Unlock_allocator();
return 0;
}
42c20: 242e fffc movel %fp@(-4),%d2
42c24: 4e5e unlk %fp <== NOT EXECUTED
00042ed4 <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
42ed4: 4e56 fff4 linkw %fp,#-12
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
42ed8: 2039 0005 ed70 movel 5ed70 <RTEMS_Malloc_Sbrk_amount>,%d0
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
42ede: 48d7 040c moveml %d2-%d3/%a2,%sp@
42ee2: 262e 0008 movel %fp@(8),%d3
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
42ee6: 4a80 tstl %d0
42ee8: 676a beqs 42f54 <malloc_sbrk_extend_and_allocate+0x80><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
42eea: 2403 movel %d3,%d2
42eec: d480 addl %d0,%d2
starting_address = (void *) sbrk(the_size);
42eee: 45f9 0004 072e lea 4072e <sbrk>,%a2
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
42ef4: 4c40 2002 remul %d0,%d2,%d2
42ef8: 4c00 2800 mulsl %d0,%d2
starting_address = (void *) sbrk(the_size);
42efc: 2f02 movel %d2,%sp@-
42efe: 4e92 jsr %a2@
if ( starting_address == (void*) -1 )
42f00: 588f addql #4,%sp
42f02: 72ff moveq #-1,%d1
42f04: b280 cmpl %d0,%d1
42f06: 674c beqs 42f54 <malloc_sbrk_extend_and_allocate+0x80>
return (void *) 0;
if ( !_Protected_heap_Extend(
42f08: 2f02 movel %d2,%sp@-
42f0a: 2f00 movel %d0,%sp@-
42f0c: 2f39 0005 d43a movel 5d43a <RTEMS_Malloc_Heap>,%sp@-
42f12: 4eb9 0004 73e0 jsr 473e0 <_Protected_heap_Extend>
42f18: 4fef 000c lea %sp@(12),%sp
42f1c: 4a00 tstb %d0
42f1e: 6616 bnes 42f36 <malloc_sbrk_extend_and_allocate+0x62>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
42f20: 4482 negl %d2
42f22: 2f02 movel %d2,%sp@-
42f24: 4e92 jsr %a2@
errno = ENOMEM;
42f26: 4eb9 0004 cfa8 jsr 4cfa8 <__errno>
return (void *) 0;
42f2c: 588f addql #4,%sp
return (void *) 0;
if ( !_Protected_heap_Extend(
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
errno = ENOMEM;
42f2e: 2040 moveal %d0,%a0
42f30: 700c moveq #12,%d0
42f32: 2080 movel %d0,%a0@
42f34: 601e bras 42f54 <malloc_sbrk_extend_and_allocate+0x80>
42f36: 42a7 clrl %sp@-
return (void *) 0;
}
MSBUMP(space_available, the_size);
42f38: d5b9 0005 ed44 addl %d2,5ed44 <rtems_malloc_statistics>
42f3e: 42a7 clrl %sp@-
42f40: 2f03 movel %d3,%sp@-
42f42: 2f39 0005 d43a movel 5d43a <RTEMS_Malloc_Heap>,%sp@-
42f48: 4eb9 0004 73a0 jsr 473a0 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
42f4e: 4fef 0010 lea %sp@(16),%sp
42f52: 6002 bras 42f56 <malloc_sbrk_extend_and_allocate+0x82>
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
starting_address = (void *) sbrk(the_size);
if ( starting_address == (void*) -1 )
return (void *) 0;
42f54: 4280 clrl %d0
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
42f56: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
42f5c: 4e5e unlk %fp <== NOT EXECUTED
00042f60 <malloc_sbrk_initialize>:
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
42f60: 4e56 0000 linkw %fp,#0
42f64: 222e 000c movel %fp@(12),%d1
42f68: 202e 0008 movel %fp@(8),%d0
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
42f6c: 23c1 0005 ed70 movel %d1,5ed70 <RTEMS_Malloc_Sbrk_amount>
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
42f72: 4a80 tstl %d0
42f74: 6626 bnes 42f9c <malloc_sbrk_initialize+0x3c>
uaddress = (uintptr_t)sbrk(length);
42f76: 2f01 movel %d1,%sp@-
42f78: 4eb9 0004 072e jsr 4072e <sbrk>
if (uaddress == (uintptr_t) -1) {
42f7e: 588f addql #4,%sp
42f80: 72ff moveq #-1,%d1
42f82: b280 cmpl %d0,%d1
42f84: 660a bnes 42f90 <malloc_sbrk_initialize+0x30> <== NEVER TAKEN
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
42f86: 4878 001a pea 1a <OPER2+0x6>
42f8a: 4eb9 0004 610c jsr 4610c <rtems_fatal_error_occurred>
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
42f90: 7203 moveq #3,%d1 <== NOT EXECUTED
42f92: c280 andl %d0,%d1 <== NOT EXECUTED
42f94: 6706 beqs 42f9c <malloc_sbrk_initialize+0x3c> <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
42f96: 5880 addql #4,%d0 <== NOT EXECUTED
42f98: 72fc moveq #-4,%d1 <== NOT EXECUTED
42f9a: c081 andl %d1,%d0 <== NOT EXECUTED
}
starting_address = (void *)uaddress;
}
return starting_address;
}
42f9c: 4e5e unlk %fp <== NOT EXECUTED
0004bee2 <memfile_lseek>:
{
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
4bee2: 7006 moveq #6,%d0
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
4bee4: 4e56 fff0 linkw %fp,#-16
4bee8: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4beec: 246e 0008 moveal %fp@(8),%a2
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4bef0: 266a 0018 moveal %a2@(24),%a3
if (the_jnode->type == IMFS_LINEAR_FILE) {
4bef4: b0ab 0048 cmpl %a3@(72),%d0
4bef8: 6620 bnes 4bf1a <memfile_lseek+0x38>
if (iop->offset > the_jnode->info.linearfile.size)
4befa: 202b 004c movel %a3@(76),%d0
4befe: 222b 0050 movel %a3@(80),%d1
4bf02: 242a 000c movel %a2@(12),%d2
4bf06: 262a 0010 movel %a2@(16),%d3
4bf0a: 9681 subl %d1,%d3
4bf0c: 9580 subxl %d0,%d2
4bf0e: 6f44 bles 4bf54 <memfile_lseek+0x72>
iop->offset = the_jnode->info.linearfile.size;
4bf10: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
4bf14: 2541 0010 movel %d1,%a2@(16) <== NOT EXECUTED
4bf18: 603a bras 4bf54 <memfile_lseek+0x72> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
4bf1a: 2f2a 0010 movel %a2@(16),%sp@-
4bf1e: 2f2a 000c movel %a2@(12),%sp@-
4bf22: 2f0b movel %a3,%sp@-
4bf24: 4eb9 0004 bb20 jsr 4bb20 <IMFS_memfile_extend>
4bf2a: 4fef 000c lea %sp@(12),%sp
4bf2e: 4a80 tstl %d0
4bf30: 6712 beqs 4bf44 <memfile_lseek+0x62>
rtems_set_errno_and_return_minus_one( ENOSPC );
4bf32: 4eb9 0004 cd68 jsr 4cd68 <__errno>
4bf38: 761c moveq #28,%d3
4bf3a: 2040 moveal %d0,%a0
4bf3c: 2083 movel %d3,%a0@
4bf3e: 70ff moveq #-1,%d0
4bf40: 72ff moveq #-1,%d1
4bf42: 6018 bras 4bf5c <memfile_lseek+0x7a>
iop->size = the_jnode->info.file.size;
4bf44: 202b 004c movel %a3@(76),%d0
4bf48: 222b 0050 movel %a3@(80),%d1
4bf4c: 2540 0004 movel %d0,%a2@(4)
4bf50: 2541 0008 movel %d1,%a2@(8)
}
return iop->offset;
4bf54: 202a 000c movel %a2@(12),%d0
4bf58: 222a 0010 movel %a2@(16),%d1
}
4bf5c: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4bf62: 4e5e unlk %fp
...
0004bdd6 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
4bdd6: 4e56 fff0 linkw %fp,#-16
4bdda: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bdde: 266e 0008 moveal %fp@(8),%a3
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
4bde2: 202b 0014 movel %a3@(20),%d0
4bde6: 0280 0000 0204 andil #516,%d0
uint32_t mode
)
{
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4bdec: 246b 0018 moveal %a3@(24),%a2
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
4bdf0: 674c beqs 4be3e <memfile_open+0x68>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
4bdf2: 7006 moveq #6,%d0
4bdf4: b0aa 0048 cmpl %a2@(72),%d0
4bdf8: 6644 bnes 4be3e <memfile_open+0x68> <== ALWAYS TAKEN
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
4bdfa: 7405 moveq #5,%d2 <== NOT EXECUTED
4bdfc: 2542 0048 movel %d2,%a2@(72) <== NOT EXECUTED
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
4be00: 202a 0050 movel %a2@(80),%d0 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
4be04: 4282 clrl %d2 <== NOT EXECUTED
4be06: 4283 clrl %d3 <== NOT EXECUTED
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
4be08: 222a 0054 movel %a2@(84),%d1 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
4be0c: 2542 004c movel %d2,%a2@(76) <== NOT EXECUTED
4be10: 2543 0050 movel %d3,%a2@(80) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
4be14: 42aa 0054 clrl %a2@(84) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
4be18: 42aa 0058 clrl %a2@(88) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
4be1c: 42aa 005c clrl %a2@(92) <== NOT EXECUTED
if ((count != 0)
4be20: 4a80 tstl %d0 <== NOT EXECUTED
4be22: 671a beqs 4be3e <memfile_open+0x68> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
4be24: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4be26: 76ff moveq #-1,%d3 <== NOT EXECUTED
4be28: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4be2a: 42a7 clrl %sp@- <== NOT EXECUTED
4be2c: 42a7 clrl %sp@- <== NOT EXECUTED
4be2e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4be30: 4eb9 0004 bc30 jsr 4bc30 <IMFS_memfile_write> <== NOT EXECUTED
4be36: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4be3a: b680 cmpl %d0,%d3 <== NOT EXECUTED
4be3c: 6730 beqs 4be6e <memfile_open+0x98> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
4be3e: 202b 0014 movel %a3@(20),%d0
4be42: 0280 0000 0200 andil #512,%d0
4be48: 6710 beqs 4be5a <memfile_open+0x84>
iop->offset = the_jnode->info.file.size;
4be4a: 202a 004c movel %a2@(76),%d0
4be4e: 222a 0050 movel %a2@(80),%d1
4be52: 2740 000c movel %d0,%a3@(12)
4be56: 2741 0010 movel %d1,%a3@(16)
iop->size = the_jnode->info.file.size;
return 0;
4be5a: 4280 clrl %d0
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
4be5c: 222a 004c movel %a2@(76),%d1
4be60: 242a 0050 movel %a2@(80),%d2
4be64: 2741 0004 movel %d1,%a3@(4)
4be68: 2742 0008 movel %d2,%a3@(8)
return 0;
4be6c: 6002 bras 4be70 <memfile_open+0x9a>
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
4be6e: 70ff moveq #-1,%d0 <== NOT EXECUTED
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
return 0;
}
4be70: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4be76: 4e5e unlk %fp <== NOT EXECUTED
00042f20 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
42f20: 4e56 ffd4 linkw %fp,#-44
42f24: 48d7 001c moveml %d2-%d4,%sp@
42f28: 262e 000c movel %fp@(12),%d3
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
42f2c: 2003 movel %d3,%d0
42f2e: 0280 0000 f000 andil #61440,%d0
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
42f34: 282e 0008 movel %fp@(8),%d4
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
42f38: 0c80 0000 4000 cmpil #16384,%d0
42f3e: 6732 beqs 42f72 <mknod+0x52>
42f40: 6212 bhis 42f54 <mknod+0x34>
42f42: 0c80 0000 1000 cmpil #4096,%d0
42f48: 6728 beqs 42f72 <mknod+0x52>
42f4a: 0c80 0000 2000 cmpil #8192,%d0
42f50: 6612 bnes 42f64 <mknod+0x44>
42f52: 601e bras 42f72 <mknod+0x52>
42f54: 0c80 0000 6000 cmpil #24576,%d0
42f5a: 6716 beqs 42f72 <mknod+0x52>
42f5c: 0c80 0000 8000 cmpil #32768,%d0
42f62: 670e beqs 42f72 <mknod+0x52> <== ALWAYS TAKEN
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
42f64: 4eb9 0004 cd68 jsr 4cd68 <__errno>
42f6a: 2040 moveal %d0,%a0
42f6c: 7016 moveq #22,%d0
42f6e: 2080 movel %d0,%a0@
42f70: 6064 bras 42fd6 <mknod+0xb6>
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
42f72: 240e movel %fp,%d2
42f74: 0682 ffff ffe4 addil #-28,%d2
42f7a: 2f02 movel %d2,%sp@-
42f7c: 486e fff8 pea %fp@(-8)
42f80: 2f04 movel %d4,%sp@-
42f82: 4eb9 0004 3840 jsr 43840 <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
42f88: 486e fffc pea %fp@(-4)
42f8c: d8ae fff8 addl %fp@(-8),%d4
42f90: 2f02 movel %d2,%sp@-
42f92: 206e fff0 moveal %fp@(-16),%a0
42f96: 2f04 movel %d4,%sp@-
42f98: 2068 0004 moveal %a0@(4),%a0
42f9c: 4e90 jsr %a0@
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
42f9e: 4fef 0018 lea %sp@(24),%sp
42fa2: 4a80 tstl %d0
42fa4: 6630 bnes 42fd6 <mknod+0xb6>
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
42fa6: 2f02 movel %d2,%sp@-
42fa8: 2f2e 0014 movel %fp@(20),%sp@-
42fac: 2f2e 0010 movel %fp@(16),%sp@-
42fb0: 206e fff0 moveal %fp@(-16),%a0
42fb4: 2f03 movel %d3,%sp@-
42fb6: 2f2e fffc movel %fp@(-4),%sp@-
42fba: 2068 0014 moveal %a0@(20),%a0
42fbe: 4e90 jsr %a0@
rtems_filesystem_freenode( &temp_loc );
42fc0: 2f02 movel %d2,%sp@-
42fc2: 2d40 ffe0 movel %d0,%fp@(-32)
42fc6: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
return result;
42fcc: 202e ffe0 movel %fp@(-32),%d0
42fd0: 4fef 0018 lea %sp@(24),%sp
42fd4: 6002 bras 42fd8 <mknod+0xb8>
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
return -1;
42fd6: 70ff moveq #-1,%d0
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
42fd8: 4cee 001c ffd4 moveml %fp@(-44),%d2-%d4
42fde: 4e5e unlk %fp
...
00043066 <mount>:
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
43066: 7001 moveq #1,%d0
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
43068: 4e56 ffbc linkw %fp,#-68
4306c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
43070: 2a2e 0008 movel %fp@(8),%d5
43074: 262e 000c movel %fp@(12),%d3
43078: 266e 0010 moveal %fp@(16),%a3
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
4307c: b0ae 0014 cmpl %fp@(20),%d0
43080: 6510 bcss 43092 <mount+0x2c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
43082: 2f0b movel %a3,%sp@-
43084: 4eb9 0004 a144 jsr 4a144 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
4308a: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
4308c: 2a40 moveal %d0,%a5
if ( !mount_h )
4308e: 4a80 tstl %d0
43090: 6610 bnes 430a2 <mount+0x3c>
rtems_set_errno_and_return_minus_one( EINVAL );
43092: 4eb9 0004 cd68 jsr 4cd68 <__errno>
43098: 7816 moveq #22,%d4
4309a: 2040 moveal %d0,%a0
4309c: 2084 movel %d4,%a0@
4309e: 6000 0222 braw 432c2 <mount+0x25c>
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
430a2: 4a83 tstl %d3
430a4: 56c2 sne %d2
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
430a6: 283c 0005 bdc8 movel #376264,%d4
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
430ac: 4482 negl %d2
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
430ae: 4a02 tstb %d2
430b0: 6702 beqs 430b4 <mount+0x4e>
430b2: 2803 movel %d3,%d4
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
430b4: 2f0b movel %a3,%sp@-
430b6: 45f9 0004 e0d4 lea 4e0d4 <strlen>,%a2
430bc: 4e92 jsr %a2@
430be: 588f addql #4,%sp
430c0: 2c00 movel %d0,%d6
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
430c2: 4a85 tstl %d5
430c4: 670c beqs 430d2 <mount+0x6c>
430c6: 2f05 movel %d5,%sp@-
430c8: 4e92 jsr %a2@
430ca: 588f addql #4,%sp
430cc: 2840 moveal %d0,%a4
430ce: 528c addql #1,%a4
430d0: 6002 bras 430d4 <mount+0x6e>
430d2: 99cc subal %a4,%a4
size_t target_size = strlen( target ) + 1;
430d4: 2f04 movel %d4,%sp@-
430d6: 4eb9 0004 e0d4 jsr 4e0d4 <strlen>
430dc: 588f addql #4,%sp
430de: 2200 movel %d0,%d1
430e0: 5281 addql #1,%d1
430e2: 2e00 movel %d0,%d7
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
430e4: 41f4 6875 lea %a4@(00000075,%d6:l),%a0
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
430e8: 2d41 ffe8 movel %d1,%fp@(-24)
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
430ec: 4870 1800 pea %a0@(00000000,%d1:l)
430f0: 4878 0001 pea 1 <ADD>
430f4: 4eb9 0004 27cc jsr 427cc <calloc>
if ( mt_entry != NULL ) {
430fa: 508f addql #8,%sp
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
430fc: 2440 moveal %d0,%a2
if ( mt_entry != NULL ) {
430fe: 4a80 tstl %d0
43100: 6770 beqs 43172 <mount+0x10c> <== NEVER TAKEN
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
43102: 2206 movel %d6,%d1
43104: 5281 addql #1,%d1
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
43106: 2c00 movel %d0,%d6
43108: 0686 0000 0074 addil #116,%d6
memcpy( str, filesystemtype, filesystemtype_size );
4310e: 2f01 movel %d1,%sp@-
43110: 2f0b movel %a3,%sp@-
43112: 47f9 0004 d588 lea 4d588 <memcpy>,%a3
43118: 2f06 movel %d6,%sp@-
4311a: 2d41 ffe4 movel %d1,%fp@(-28)
4311e: 4e93 jsr %a3@
mt_entry->type = str;
str += filesystemtype_size;
43120: 222e ffe4 movel %fp@(-28),%d1
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
43124: 2546 006c movel %d6,%a2@(108)
str += filesystemtype_size;
43128: dc81 addl %d1,%d6
memcpy( str, source_or_null, source_size );
4312a: 2f0c movel %a4,%sp@-
4312c: 2f05 movel %d5,%sp@-
4312e: 2f06 movel %d6,%sp@-
43130: 4e93 jsr %a3@
mt_entry->dev = str;
43132: 2546 0070 movel %d6,%a2@(112)
str += source_size;
memcpy( str, target, target_size );
43136: 2f2e ffe8 movel %fp@(-24),%sp@-
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
4313a: dc8c addl %a4,%d6
memcpy( str, target, target_size );
4313c: 2f04 movel %d4,%sp@-
4313e: 2f06 movel %d6,%sp@-
43140: 4e93 jsr %a3@
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
43142: 206e 0014 moveal %fp@(20),%a0
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
43146: 4fef 0024 lea %sp@(36),%sp
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
4314a: 2546 0068 movel %d6,%a2@(104)
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
4314e: 254a 002c movel %a2,%a2@(44)
mt_entry->options = options;
43152: 2548 0030 movel %a0,%a2@(48)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
43156: 4878 0030 pea 30 <OPER2+0x1c>
4315a: 4879 0005 c27c pea 5c27c <rtems_filesystem_default_pathconf>
43160: 486a 0038 pea %a2@(56)
43164: 4e93 jsr %a3@
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
43166: 4fef 000c lea %sp@(12),%sp
4316a: 4a02 tstb %d2
4316c: 6700 00b2 beqw 43220 <mount+0x1ba>
43170: 6010 bras 43182 <mount+0x11c>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
43172: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
43178: 760c moveq #12,%d3 <== NOT EXECUTED
4317a: 2040 moveal %d0,%a0 <== NOT EXECUTED
4317c: 2083 movel %d3,%a0@ <== NOT EXECUTED
4317e: 6000 0142 braw 432c2 <mount+0x25c> <== NOT EXECUTED
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
43182: 4878 0001 pea 1 <ADD>
43186: 280e movel %fp,%d4
43188: 0684 ffff ffec addil #-20,%d4
4318e: 2f04 movel %d4,%sp@-
43190: 4878 0007 pea 7 <TRUNCDFSF>
43194: 2f07 movel %d7,%sp@-
43196: 2f03 movel %d3,%sp@-
43198: 4eb9 0004 2a88 jsr 42a88 <rtems_filesystem_evaluate_path>
4319e: 4fef 0014 lea %sp@(20),%sp
431a2: 72ff moveq #-1,%d1
431a4: b280 cmpl %d0,%d1
431a6: 6700 00fa beqw 432a2 <mount+0x23c>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
431aa: 206e fff8 moveal %fp@(-8),%a0
431ae: 2f04 movel %d4,%sp@-
431b0: 2068 0010 moveal %a0@(16),%a0
431b4: 4e90 jsr %a0@
431b6: 588f addql #4,%sp
431b8: 7201 moveq #1,%d1
431ba: b280 cmpl %d0,%d1
431bc: 670e beqs 431cc <mount+0x166>
errno = ENOTDIR;
431be: 4eb9 0004 cd68 jsr 4cd68 <__errno>
431c4: 7414 moveq #20,%d2
431c6: 2040 moveal %d0,%a0
431c8: 2082 movel %d2,%a0@
431ca: 6020 bras 431ec <mount+0x186>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
431cc: 2f2e ffec movel %fp@(-20),%sp@-
431d0: 487a fe12 pea %pc@(42fe4 <is_node_fs_root>)
431d4: 4eb9 0004 3018 jsr 43018 <rtems_filesystem_mount_iterate>
431da: 508f addql #8,%sp
431dc: 4a00 tstb %d0
431de: 6712 beqs 431f2 <mount+0x18c>
errno = EBUSY;
431e0: 4eb9 0004 cd68 jsr 4cd68 <__errno>
431e6: 7210 moveq #16,%d1
431e8: 2040 moveal %d0,%a0
431ea: 2081 movel %d1,%a0@
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
target, target_length, RTEMS_LIBIO_PERMS_RWX, &loc, true ) == -1 )
goto cleanup_and_bail;
loc_to_free = &loc;
431ec: 2604 movel %d4,%d3
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
errno = EBUSY;
goto cleanup_and_bail;
431ee: 6000 00b4 braw 432a4 <mount+0x23e>
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
431f2: 206e fff8 moveal %fp@(-8),%a0
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
target, target_length, RTEMS_LIBIO_PERMS_RWX, &loc, true ) == -1 )
goto cleanup_and_bail;
loc_to_free = &loc;
431f6: 2604 movel %d4,%d3
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
431f8: 256e ffec 0008 movel %fp@(-20),%a2@(8)
mt_entry->mt_point_node.handlers = loc.handlers;
431fe: 256e fff4 0010 movel %fp@(-12),%a2@(16)
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
43204: 256e fffc 0018 movel %fp@(-4),%a2@(24)
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
4320a: 2548 0014 movel %a0,%a2@(20)
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
4320e: 2f0a movel %a2,%sp@-
43210: 2068 0020 moveal %a0@(32),%a0
43214: 4e90 jsr %a0@
43216: 588f addql #4,%sp
43218: 4a80 tstl %d0
4321a: 6600 0088 bnew 432a4 <mount+0x23e>
4321e: 601e bras 4323e <mount+0x1d8>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
43220: 203c 0005 d308 movel #381704,%d0
43226: b0b9 0005 d304 cmpl 5d304 <mount_chain>,%d0
4322c: 670e beqs 4323c <mount+0x1d6> <== ALWAYS TAKEN
errno = EINVAL;
4322e: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
43234: 2040 moveal %d0,%a0 <== NOT EXECUTED
43236: 7016 moveq #22,%d0 <== NOT EXECUTED
43238: 2080 movel %d0,%a0@ <== NOT EXECUTED
4323a: 6066 bras 432a2 <mount+0x23c> <== NOT EXECUTED
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
4323c: 4283 clrl %d3
* mt_point_node.node_access will be left to null to indicate that this
* is the root of the entire file system.
*/
}
if ( (*mount_h)( mt_entry, data ) ) {
4323e: 2f2e 0018 movel %fp@(24),%sp@-
43242: 2f0a movel %a2,%sp@-
43244: 4e95 jsr %a5@
43246: 508f addql #8,%sp
43248: 4a80 tstl %d0
4324a: 6710 beqs 4325c <mount+0x1f6>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
4324c: 206e fff8 moveal %fp@(-8),%a0
43250: 2f0a movel %a2,%sp@-
43252: 2068 0028 moveal %a0@(40),%a0
43256: 4e90 jsr %a0@
goto cleanup_and_bail;
43258: 588f addql #4,%sp
4325a: 6048 bras 432a4 <mount+0x23e>
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
4325c: 4eba fd9e jsr %pc@(42ffc <rtems_libio_lock>)
43260: 2f0a movel %a2,%sp@-
43262: 4879 0005 d304 pea 5d304 <mount_chain>
43268: 4eb9 0004 63b4 jsr 463b4 <_Chain_Append>
4326e: 2f39 0005 ea4c movel 5ea4c <rtems_libio_semaphore>,%sp@-
43274: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
4327a: 4fef 000c lea %sp@(12),%sp
4327e: 4a02 tstb %d2
43280: 663c bnes 432be <mount+0x258>
rtems_filesystem_root = mt_entry->mt_fs_root;
43282: 4878 0014 pea 14 <OPER2>
43286: 486a 001c pea %a2@(28)
4328a: 2079 0005 d420 moveal 5d420 <rtems_current_user_env>,%a0
43290: 41e8 0018 lea %a0@(24),%a0
43294: 2f08 movel %a0,%sp@-
43296: 4eb9 0004 d588 jsr 4d588 <memcpy>
4329c: 4fef 000c lea %sp@(12),%sp
432a0: 601c bras 432be <mount+0x258>
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
432a2: 4283 clrl %d3 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
432a4: 2f0a movel %a2,%sp@-
432a6: 4eb9 0004 2b68 jsr 42b68 <free>
if ( loc_to_free )
432ac: 588f addql #4,%sp
432ae: 4a83 tstl %d3
432b0: 6710 beqs 432c2 <mount+0x25c> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
432b2: 2f03 movel %d3,%sp@-
432b4: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
432ba: 588f addql #4,%sp
432bc: 6004 bras 432c2 <mount+0x25c>
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
432be: 4280 clrl %d0
432c0: 6002 bras 432c4 <mount+0x25e>
free( mt_entry );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
432c2: 70ff moveq #-1,%d0
}
432c4: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
432ca: 4e5e unlk %fp
...
00043454 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
43454: 4e56 ffec linkw %fp,#-20
43458: 48d7 007c moveml %d2-%d6,%sp@
4345c: 262e 0008 movel %fp@(8),%d3
43460: 242e 000c movel %fp@(12),%d2
43464: 282e 0010 movel %fp@(16),%d4
43468: 2a2e 0014 movel %fp@(20),%d5
4346c: 2c2e 0018 movel %fp@(24),%d6
int rv = -1;
if (target != NULL) {
43470: 4a82 tstl %d2
43472: 6734 beqs 434a8 <mount_and_make_target_path+0x54>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
43474: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
43478: 2f02 movel %d2,%sp@-
4347a: 4eb9 0004 3d1c jsr 43d1c <rtems_mkdir>
if (rv == 0) {
43480: 508f addql #8,%sp
43482: 4a80 tstl %d0
43484: 6630 bnes 434b6 <mount_and_make_target_path+0x62><== NEVER TAKEN
rv = mount(
43486: 2d46 0018 movel %d6,%fp@(24)
4348a: 2d45 0014 movel %d5,%fp@(20)
4348e: 2d44 0010 movel %d4,%fp@(16)
43492: 2d42 000c movel %d2,%fp@(12)
43496: 2d43 0008 movel %d3,%fp@(8)
} else {
errno = EINVAL;
}
return rv;
}
4349a: 4cee 007c ffec moveml %fp@(-20),%d2-%d6
434a0: 4e5e unlk %fp
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
434a2: 4ef9 0004 3542 jmp 43542 <mount>
options,
data
);
}
} else {
errno = EINVAL;
434a8: 4eb9 0004 d1f0 jsr 4d1f0 <__errno>
434ae: 2040 moveal %d0,%a0
434b0: 7016 moveq #22,%d0
434b2: 2080 movel %d0,%a0@
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
434b4: 70ff moveq #-1,%d0
} else {
errno = EINVAL;
}
return rv;
}
434b6: 4cee 007c ffec moveml %fp@(-20),%d2-%d6
434bc: 4e5e unlk %fp <== NOT EXECUTED
00054958 <msdos_creat_node>:
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
54958: 72ff moveq #-1,%d1
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
5495a: 4e56 ff40 linkw %fp,#-192
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
time_t time_ret = 0;
uint16_t time_val = 0;
5495e: 4240 clrw %d0
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
54960: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
54964: 246e 0008 moveal %fp@(8),%a2
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
54968: 47ee ffa8 lea %fp@(-88),%a3
5496c: 2a3c 0005 957c movel #365948,%d5
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
54972: 206a 0010 moveal %a2@(16),%a0
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
54976: 2612 movel %a2@,%d3
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
54978: 2868 0034 moveal %a0@(52),%a4
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
5497c: 4878 0020 pea 20 <OPER2+0xc>
54980: 2045 moveal %d5,%a0
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
54982: 242e 0010 movel %fp@(16),%d2
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
54986: 42a7 clrl %sp@-
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
54988: 2c2e 0014 movel %fp@(20),%d6
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
5498c: 2f0b movel %a3,%sp@-
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
5498e: 2a6e 000c moveal %fp@(12),%a5
54992: 2d41 fff0 movel %d1,%fp@(-16)
54996: 282e 001c movel %fp@(28),%d4
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
5499a: 2d41 fff4 movel %d1,%fp@(-12)
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
time_t time_ret = 0;
uint16_t time_val = 0;
5499e: 3d40 fffc movew %d0,%fp@(-4)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
549a2: 42ae fff8 clrl %fp@(-8)
time_t time_ret = 0;
uint16_t time_val = 0;
uint16_t date = 0;
549a6: 3d40 fffe movew %d0,%fp@(-2)
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
549aa: 42ae ffe8 clrl %fp@(-24)
dir_pos->sname.ofs = 0;
549ae: 42ae ffec clrl %fp@(-20)
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
549b2: 4e90 jsr %a0@
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
549b4: 4878 0040 pea 40 <DBL_MANT_DIG+0xb>
549b8: 2045 moveal %d5,%a0
549ba: 42a7 clrl %sp@-
549bc: 486e ff68 pea %fp@(-152)
549c0: 4e90 jsr %a0@
name_type = msdos_long_to_short (name, name_len,
549c2: 4878 000b pea b <LASTO+0x1>
549c6: 2f0b movel %a3,%sp@-
549c8: 2f06 movel %d6,%sp@-
549ca: 2f02 movel %d2,%sp@-
549cc: 4eb9 0005 58bc jsr 558bc <msdos_long_to_short>
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
549d2: 4fef 0024 lea %sp@(36),%sp
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
name_type = msdos_long_to_short (name, name_len,
549d6: 2e00 movel %d0,%d7
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
549d8: 4200 clrb %d0
/* set up last write date and time */
time_ret = time(NULL);
549da: 4297 clrl %sp@
name_type = msdos_long_to_short (name, name_len,
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
549dc: 1d40 ffb4 moveb %d0,%fp@(-76)
/* set up last write date and time */
time_ret = time(NULL);
549e0: 4eb9 0005 c9b4 jsr 5c9b4 <time>
if ( time_ret == -1 )
549e6: 588f addql #4,%sp
549e8: 72ff moveq #-1,%d1
549ea: b280 cmpl %d0,%d1
549ec: 6700 02c2 beqw 54cb0 <msdos_creat_node+0x358>
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
549f0: 486e fffc pea %fp@(-4)
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
549f4: 4285 clrl %d5
/* set up last write date and time */
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
549f6: 486e fffe pea %fp@(-2)
549fa: 2f00 movel %d0,%sp@-
549fc: 4eb9 0005 7ff4 jsr 57ff4 <msdos_date_unix2dos>
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
54a02: 4fef 000c lea %sp@(12),%sp
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
54a06: 4280 clrl %d0
54a08: 302e fffc movew %fp@(-4),%d0
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
54a0c: 3a2e fffe movew %fp@(-2),%d5
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
54a10: 42ae ffc4 clrl %fp@(-60)
static inline uint16_t m68k_swap_u16(
uint16_t value
)
{
return (((value & 0xff) << 8) | ((value >> 8) & 0xff));
54a14: 2200 movel %d0,%d1
54a16: e088 lsrl #8,%d0
54a18: e189 lsll #8,%d1
54a1a: 8280 orl %d0,%d1
54a1c: 2005 movel %d5,%d0
54a1e: e08d lsrl #8,%d5
54a20: e188 lsll #8,%d0
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
54a22: 3d41 ffb6 movew %d1,%fp@(-74)
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
54a26: 3d41 ffbe movew %d1,%fp@(-66)
54a2a: 8085 orl %d5,%d0
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
54a2c: 7a01 moveq #1,%d5
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
54a2e: 3d40 ffb8 movew %d0,%fp@(-72)
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
54a32: 3d40 ffc0 movew %d0,%fp@(-64)
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
54a36: 3d40 ffba movew %d0,%fp@(-70)
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
54a3a: ba8d cmpl %a5,%d5
54a3c: 660a bnes 54a48 <msdos_creat_node+0xf0>
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
54a3e: 7210 moveq #16,%d1
54a40: 102b 000b moveb %a3@(11),%d0
54a44: 6000 009c braw 54ae2 <msdos_creat_node+0x18a>
}
else if (type == MSDOS_HARD_LINK) {
54a48: 7a03 moveq #3,%d5
54a4a: ba8d cmpl %a5,%d5
54a4c: 6600 0098 bnew 54ae6 <msdos_creat_node+0x18e>
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
54a50: 2044 moveal %d4,%a0 <== NOT EXECUTED
54a52: 226a 0010 moveal %a2@(16),%a1 <== NOT EXECUTED
54a56: 2028 0020 movel %a0@(32),%d0 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
54a5a: 2069 0034 moveal %a1@(52),%a0 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
54a5e: 6610 bnes 54a70 <msdos_creat_node+0x118> <== NOT EXECUTED
54a60: 4281 clrl %d1 <== NOT EXECUTED
54a62: 1228 000a moveb %a0@(10),%d1 <== NOT EXECUTED
54a66: c285 andl %d5,%d1 <== NOT EXECUTED
54a68: 6706 beqs 54a70 <msdos_creat_node+0x118> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
54a6a: 2028 001a movel %a0@(26),%d0 <== NOT EXECUTED
54a6e: 600e bras 54a7e <msdos_creat_node+0x126> <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
54a70: 4281 clrl %d1 <== NOT EXECUTED
54a72: 1228 0005 moveb %a0@(5),%d1 <== NOT EXECUTED
54a76: 5580 subql #2,%d0 <== NOT EXECUTED
54a78: e3a8 lsll %d1,%d0 <== NOT EXECUTED
54a7a: d0a8 002c addl %a0@(44),%d0 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
54a7e: 2044 moveal %d4,%a0 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
54a80: 47ee ffc8 lea %fp@(-56),%a3 <== NOT EXECUTED
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
54a84: 4284 clrl %d4 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
54a86: 2228 0024 movel %a0@(36),%d1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
54a8a: 2040 moveal %d0,%a0 <== NOT EXECUTED
54a8c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
54a8e: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
54a92: 3814 movew %a4@,%d4 <== NOT EXECUTED
54a94: 5384 subql #1,%d4 <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
54a96: c881 andl %d1,%d4 <== NOT EXECUTED
54a98: 2f04 movel %d4,%sp@- <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
54a9a: 4284 clrl %d4 <== NOT EXECUTED
54a9c: 182c 0002 moveb %a4@(2),%d4 <== NOT EXECUTED
54aa0: e8a9 lsrl %d4,%d1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
54aa2: 4870 1800 pea %a0@(00000000,%d1:l) <== NOT EXECUTED
54aa6: 2f09 movel %a1,%sp@- <== NOT EXECUTED
54aa8: 4eb9 0005 08b2 jsr 508b2 <_fat_block_read> <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
54aae: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
54ab2: 4a80 tstl %d0 <== NOT EXECUTED
54ab4: 6d00 01fa bltw 54cb0 <msdos_creat_node+0x358> <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
54ab8: 7220 moveq #32,%d1 <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
54aba: 102e ffd3 moveb %fp@(-45),%d0 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
54abe: 1d6e ffd5 ffb5 moveb %fp@(-43),%fp@(-75) <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
54ac4: 3d6e ffd6 ffb6 movew %fp@(-42),%fp@(-74) <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
54aca: 3d6e ffd8 ffb8 movew %fp@(-40),%fp@(-72) <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
54ad0: 3d6e ffe2 ffc2 movew %fp@(-30),%fp@(-62) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
54ad6: 3d6e ffdc ffbc movew %fp@(-36),%fp@(-68) <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
54adc: 2d6e ffe4 ffc4 movel %fp@(-28),%fp@(-60) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
54ae2: 8081 orl %d1,%d0
54ae4: 6008 bras 54aee <msdos_creat_node+0x196>
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
54ae6: 7a20 moveq #32,%d5
54ae8: 102b 000b moveb %a3@(11),%d0
54aec: 8085 orl %d5,%d0
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
name_type, &dir_pos, short_node);
54aee: 280e movel %fp,%d4
54af0: 0684 ffff ffa8 addil #-88,%d4
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
54af6: 2a0e movel %fp,%d5
54af8: 0685 ffff ffe8 addil #-24,%d5
54afe: 2f04 movel %d4,%sp@-
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
54b00: 1d40 ffb3 moveb %d0,%fp@(-77)
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
54b04: 2f05 movel %d5,%sp@-
54b06: 2f07 movel %d7,%sp@-
54b08: 2f06 movel %d6,%sp@-
54b0a: 2f02 movel %d2,%sp@-
54b0c: 4878 0001 pea 1 <ADD>
54b10: 2f0a movel %a2,%sp@-
54b12: 4eb9 0005 6a4e jsr 56a4e <msdos_get_name_node>
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
54b18: 4fef 001c lea %sp@(28),%sp
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
54b1c: 2400 movel %d0,%d2
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
54b1e: 6600 0192 bnew 54cb2 <msdos_creat_node+0x35a>
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
54b22: 7001 moveq #1,%d0
54b24: b08d cmpl %a5,%d0
54b26: 6600 018a bnew 54cb2 <msdos_creat_node+0x35a>
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
54b2a: 486e fff8 pea %fp@(-8)
54b2e: 2f05 movel %d5,%sp@-
54b30: 2f2a 0010 movel %a2@(16),%sp@-
54b34: 4eb9 0004 fb18 jsr 4fb18 <fat_file_open>
if (rc != RC_OK)
54b3a: 4fef 000c lea %sp@(12),%sp
* to do
*/
if (type == MSDOS_DIRECTORY)
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
54b3e: 2400 movel %d0,%d2
if (rc != RC_OK)
54b40: 6600 0156 bnew 54c98 <msdos_creat_node+0x340>
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
54b44: 266e fff8 moveal %fp@(-8),%a3
fat_fd->fat_file_type = FAT_DIRECTORY;
54b48: 7201 moveq #1,%d1
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
54b4a: 4bf9 0005 950c lea 5950c <memcpy>,%a5
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
54b50: 240e movel %fp,%d2
54b52: 0682 ffff ff88 addil #-120,%d2
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
54b58: 7a20 moveq #32,%d5
54b5a: 4845 swap %d5
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
54b5c: 2741 0010 movel %d1,%a3@(16)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
54b60: 2745 0014 movel %d5,%a3@(20)
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
54b64: 2a0e movel %fp,%d5
54b66: 0685 ffff ff68 addil #-152,%d5
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
54b6c: 42ab 0018 clrl %a3@(24)
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
54b70: 4878 0020 pea 20 <OPER2+0xc>
54b74: 2f04 movel %d4,%sp@-
54b76: 2f05 movel %d5,%sp@-
54b78: 4e95 jsr %a5@
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
54b7a: 4878 0020 pea 20 <OPER2+0xc>
54b7e: 2f04 movel %d4,%sp@-
54b80: 2f02 movel %d2,%sp@-
54b82: 4e95 jsr %a5@
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
54b84: 4878 000b pea b <LASTO+0x1>
54b88: 2f39 0006 8f18 movel 68f18 <MSDOS_DOT_NAME>,%sp@-
54b8e: 2f05 movel %d5,%sp@-
54b90: 4e95 jsr %a5@
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
54b92: 4fef 0024 lea %sp@(36),%sp
54b96: 4878 000b pea b <LASTO+0x1>
54b9a: 2f39 0006 8f14 movel 68f14 <MSDOS_DOTDOT_NAME>,%sp@-
54ba0: 2f02 movel %d2,%sp@-
54ba2: 4e95 jsr %a5@
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
54ba4: 4fef 000c lea %sp@(12),%sp
54ba8: 7001 moveq #1,%d0
54baa: 2043 moveal %d3,%a0
54bac: b0a8 0020 cmpl %a0@(32),%d0
54bb0: 6618 bnes 54bca <msdos_creat_node+0x272>
54bb2: 4aa8 0024 tstl %a0@(36)
54bb6: 6612 bnes 54bca <msdos_creat_node+0x272> <== NEVER TAKEN
(fs_info->fat.vol.type & FAT_FAT32))
54bb8: 4280 clrl %d0
54bba: 102c 000a moveb %a4@(10),%d0
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
54bbe: 44c0 movew %d0,%ccr
54bc0: 6608 bnes 54bca <msdos_creat_node+0x272> <== ALWAYS TAKEN
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
54bc2: 4240 clrw %d0 <== NOT EXECUTED
54bc4: 3d40 ffa2 movew %d0,%fp@(-94) <== NOT EXECUTED
54bc8: 6022 bras 54bec <msdos_creat_node+0x294> <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
54bca: 2043 moveal %d3,%a0
54bcc: 4282 clrl %d2
54bce: 2228 001c movel %a0@(28),%d1
54bd2: 3401 movew %d1,%d2
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
54bd4: 4241 clrw %d1
54bd6: 4841 swap %d1
54bd8: 2002 movel %d2,%d0
54bda: e08a lsrl #8,%d2
54bdc: e188 lsll #8,%d0
54bde: 8082 orl %d2,%d0
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
54be0: 3d40 ffa2 movew %d0,%fp@(-94)
54be4: 2001 movel %d1,%d0
54be6: e089 lsrl #8,%d1
54be8: e188 lsll #8,%d0
54bea: 8081 orl %d1,%d0
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
54bec: 240e movel %fp,%d2
54bee: 0682 ffff ff68 addil #-152,%d2
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54bf4: 2f02 movel %d2,%sp@-
54bf6: 4878 0040 pea 40 <DBL_MANT_DIG+0xb>
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
54bfa: 3d40 ff9c movew %d0,%fp@(-100)
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54bfe: 42a7 clrl %sp@-
54c00: 2f0b movel %a3,%sp@-
54c02: 2f2a 0010 movel %a2@(16),%sp@-
54c06: 47f9 0005 01a2 lea 501a2 <fat_file_write>,%a3
54c0c: 4e93 jsr %a3@
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
54c0e: 4fef 0014 lea %sp@(20),%sp
54c12: 4a80 tstl %d0
54c14: 6d70 blts 54c86 <msdos_creat_node+0x32e> <== NEVER TAKEN
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
54c16: 206e fff8 moveal %fp@(-8),%a0
54c1a: 4280 clrl %d0
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
54c1c: 4283 clrl %d3
54c1e: 2228 001c movel %a0@(28),%d1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
54c22: 302c 0006 movew %a4@(6),%d0
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
54c26: 3601 movew %d1,%d3
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
54c28: 4241 clrw %d1
54c2a: 4841 swap %d1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
54c2c: d1a8 0018 addl %d0,%a0@(24)
54c30: 2003 movel %d3,%d0
54c32: e08b lsrl #8,%d3
54c34: e188 lsll #8,%d0
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54c36: 2f02 movel %d2,%sp@-
54c38: 4878 0020 pea 20 <OPER2+0xc>
54c3c: 8083 orl %d3,%d0
54c3e: 42a7 clrl %sp@-
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
54c40: 3d40 ff82 movew %d0,%fp@(-126)
54c44: 2001 movel %d1,%d0
54c46: e089 lsrl #8,%d1
54c48: e188 lsll #8,%d0
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54c4a: 2f08 movel %a0,%sp@-
54c4c: 2f2a 0010 movel %a2@(16),%sp@-
54c50: 8081 orl %d1,%d0
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
54c52: 3d40 ff7c movew %d0,%fp@(-132)
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54c56: 4e93 jsr %a3@
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
54c58: 4fef 0014 lea %sp@(20),%sp
54c5c: 4a80 tstl %d0
54c5e: 6d26 blts 54c86 <msdos_creat_node+0x32e> <== NEVER TAKEN
rc = -1;
goto error;
}
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
54c60: 2f2e fff8 movel %fp@(-8),%sp@-
54c64: 2f2a 0010 movel %a2@(16),%sp@-
54c68: 4eb9 0005 5bc8 jsr 55bc8 <msdos_set_first_cluster_num>
if (rc != RC_OK)
54c6e: 508f addql #8,%sp
rc = -1;
goto error;
}
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
54c70: 2400 movel %d0,%d2
if (rc != RC_OK)
54c72: 6614 bnes 54c88 <msdos_creat_node+0x330> <== NEVER TAKEN
goto error;
fat_file_close(parent_loc->mt_entry, fat_fd);
54c74: 2f2e fff8 movel %fp@(-8),%sp@-
54c78: 2f2a 0010 movel %a2@(16),%sp@-
54c7c: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close>
54c82: 508f addql #8,%sp
54c84: 602c bras 54cb2 <msdos_creat_node+0x35a>
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
{
rc = -1;
54c86: 74ff moveq #-1,%d2 <== NOT EXECUTED
fat_file_close(parent_loc->mt_entry, fat_fd);
}
return RC_OK;
error:
fat_file_close(parent_loc->mt_entry, fat_fd);
54c88: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
54c8c: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
54c90: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
54c96: 508f addql #8,%sp <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
54c98: 4878 00e5 pea e5 <DBL_MANT_DIG+0xb0> <== NOT EXECUTED
54c9c: 486e ffe8 pea %fp@(-24) <== NOT EXECUTED
54ca0: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
54ca4: 4eb9 0005 5cea jsr 55cea <msdos_set_first_char4file_name> <== NOT EXECUTED
return rc;
54caa: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
54cae: 6002 bras 54cb2 <msdos_creat_node+0x35a> <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
return -1;
54cb0: 74ff moveq #-1,%d2 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
54cb2: 2002 movel %d2,%d0
54cb4: 4cee 3cfc ff40 moveml %fp@(-192),%d2-%d7/%a2-%a5
54cba: 4e5e unlk %fp
...
000580ee <msdos_date_dos2unix>:
* called from the stat(), and fstat() system calls and so probably need
* not be too efficient.
*/
unsigned int
msdos_date_dos2unix(unsigned int dd, unsigned int dt)
{
580ee: 4e56 ffec linkw %fp,#-20
580f2: 222e 0008 movel %fp@(8),%d1
580f6: 48d7 043c moveml %d2-%d5/%a2,%sp@
580fa: 262e 000c movel %fp@(12),%d3
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
580fe: 2003 movel %d3,%d0
58100: 740b moveq #11,%d2
58102: 2a3c 0000 0708 movel #1800,%d5
58108: 0280 0000 f800 andil #63488,%d0
5810e: e4a8 lsrl %d2,%d0
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
58110: 2403 movel %d3,%d2
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
58112: 4c05 0800 mulsl %d5,%d0
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
58116: 0282 0000 07e0 andil #2016,%d2
5811c: ea8a lsrl #5,%d2
5811e: 2802 movel %d2,%d4
58120: eb8a lsll #5,%d2
58122: d884 addl %d4,%d4
58124: 9484 subl %d4,%d2
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
58126: d082 addl %d2,%d0
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
58128: 741f moveq #31,%d2
5812a: c682 andl %d2,%d3
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
5812c: 4282 clrl %d2
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
5812e: d083 addl %d3,%d0
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
58130: 3439 0006 ac98 movew 6ac98 <lastdosdate>,%d2
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
58136: d080 addl %d0,%d0
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
58138: b282 cmpl %d2,%d1
5813a: 6700 0088 beqw 581c4 <msdos_date_dos2unix+0xd6>
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
5813e: 2601 movel %d1,%d3
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
58140: 91c8 subal %a0,%a0
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
58142: 4282 clrl %d2
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
58144: 0283 0000 fe00 andil #65024,%d3
5814a: 3a3c 0009 movew #9,%d5
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
5814e: 33c1 0006 ac98 movew %d1,6ac98 <lastdosdate>
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
58154: eaab lsrl %d5,%d3
for (y = 0; y < year; y++)
58156: 6012 bras 5816a <msdos_date_dos2unix+0x7c>
days += y & 0x03 ? 365 : 366;
58158: 4a84 tstl %d4
5815a: 57c4 seq %d4
5815c: 2a3c 0000 016d movel #365,%d5
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
58162: 5282 addql #1,%d2
days += y & 0x03 ? 365 : 366;
58164: 49c4 extbl %d4
58166: 9a84 subl %d4,%d5
58168: d1c5 addal %d5,%a0
5816a: 7803 moveq #3,%d4
5816c: c882 andl %d2,%d4
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
5816e: b682 cmpl %d2,%d3
58170: 66e6 bnes 58158 <msdos_date_dos2unix+0x6a>
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
58172: 45f9 0006 9d50 lea 69d50 <leapyear>,%a2
58178: 4a84 tstl %d4
5817a: 6706 beqs 58182 <msdos_date_dos2unix+0x94> <== ALWAYS TAKEN
5817c: 45f9 0006 9d38 lea 69d38 <regyear>,%a2 <== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
58182: 2401 movel %d1,%d2
58184: 0282 0000 01e0 andil #480,%d2
5818a: ea8a lsrl #5,%d2
if (month == 0) {
5818c: 6604 bnes 58192 <msdos_date_dos2unix+0xa4> <== ALWAYS TAKEN
month = 1;
5818e: 143c 0001 moveb #1,%d2 <== NOT EXECUTED
}
for (m = 0; m < month - 1; m++)
58192: 93c9 subal %a1,%a1
58194: 5382 subql #1,%d2
58196: 6008 bras 581a0 <msdos_date_dos2unix+0xb2>
days += months[m];
58198: 4283 clrl %d3 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
5819a: 5289 addql #1,%a1 <== NOT EXECUTED
days += months[m];
5819c: 361a movew %a2@+,%d3 <== NOT EXECUTED
5819e: d1c3 addal %d3,%a0 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
581a0: b489 cmpl %a1,%d2
581a2: 62f4 bhis 58198 <msdos_date_dos2unix+0xaa> <== NEVER TAKEN
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
581a4: 741f moveq #31,%d2
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
581a6: 2a3c 0001 5180 movel #86400,%d5
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
581ac: c282 andl %d2,%d1
581ae: 41f0 18ff lea %a0@(ffffffff,%d1:l),%a0
581b2: 2208 movel %a0,%d1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
581b4: 4c05 1800 mulsl %d5,%d1
581b8: 0681 12ce a600 addil #315532800,%d1
581be: 23c1 0006 ac9a movel %d1,6ac9a <lastseconds>
}
return seconds + lastseconds;
}
581c4: d0b9 0006 ac9a addl 6ac9a <lastseconds>,%d0
581ca: 4cd7 043c moveml %sp@,%d2-%d5/%a2
581ce: 4e5e unlk %fp <== NOT EXECUTED
00057ff4 <msdos_date_unix2dos>:
* file timestamps. The passed in unix time is assumed to be in GMT.
*/
void
msdos_date_unix2dos(unsigned int t, uint16_t *ddp,
uint16_t *dtp)
{
57ff4: 4e56 fff0 linkw %fp,#-16
57ff8: 202e 0008 movel %fp@(8),%d0
57ffc: 48d7 003c moveml %d2-%d5,%sp@
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
58000: b0b9 0006 ac8c cmpl 6ac8c <lasttime>,%d0
58006: 6700 00ca beqw 580d2 <msdos_date_unix2dos+0xde>
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
5800a: 723c moveq #60,%d1
5800c: 2600 movel %d0,%d3
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
5800e: 2a3c 0000 0e10 movel #3600,%d5
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
58014: 4c41 3004 remul %d1,%d4,%d3
58018: 4c41 3003 remul %d1,%d3,%d3
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
5801c: 23c0 0006 ac8c movel %d0,6ac8c <lasttime>
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
58022: 4c41 3002 remul %d1,%d2,%d3
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
58026: 2600 movel %d0,%d3
58028: 4c45 3003 remul %d5,%d3,%d3
5802c: 3a3c 0018 movew #24,%d5
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
58030: eb8a lsll #5,%d2
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
58032: 4c45 3001 remul %d5,%d1,%d3
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
58036: 760b moveq #11,%d3
58038: e7a9 lsll %d3,%d1
5803a: 2604 movel %d4,%d3
5803c: e28b lsrl #1,%d3
5803e: d481 addl %d1,%d2
58040: 2202 movel %d2,%d1
58042: d283 addl %d3,%d1
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
58044: 283c 0001 5180 movel #86400,%d4
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
5804a: 33c1 0006 ac90 movew %d1,6ac90 <lastdtime>
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
58050: 4c44 0000 remul %d4,%d0,%d0
if (days != lastday) {
58054: b0b9 0006 ac92 cmpl 6ac92 <lastday>,%d0
5805a: 6776 beqs 580d2 <msdos_date_unix2dos+0xde> <== NEVER TAKEN
lastday = days;
5805c: 23c0 0006 ac92 movel %d0,6ac92 <lastday>
for (year = 1970;; year++) {
58062: 223c 0000 07b2 movel #1970,%d1
inc = year & 0x03 ? 365 : 366;
58068: 7603 moveq #3,%d3
5806a: 2a3c 0000 016d movel #365,%d5
58070: c681 andl %d1,%d3
58072: 57c2 seq %d2
58074: 49c2 extbl %d2
58076: 9a82 subl %d2,%d5
if (days < inc)
58078: ba80 cmpl %d0,%d5
5807a: 6206 bhis 58082 <msdos_date_unix2dos+0x8e>
break;
days -= inc;
5807c: 9085 subl %d5,%d0
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
for (year = 1970;; year++) {
5807e: 5281 addql #1,%d1
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
}
58080: 60e6 bras 58068 <msdos_date_unix2dos+0x74>
months = year & 0x03 ? regyear : leapyear;
58082: 43f9 0006 9d50 lea 69d50 <leapyear>,%a1
58088: 4a83 tstl %d3
5808a: 6706 beqs 58092 <msdos_date_unix2dos+0x9e> <== ALWAYS TAKEN
5808c: 43f9 0006 9d38 lea 69d38 <regyear>,%a1 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
58092: 91c8 subal %a0,%a0
if (days < months[month])
58094: 4282 clrl %d2
58096: 3419 movew %a1@+,%d2
58098: b480 cmpl %d0,%d2
5809a: 620a bhis 580a6 <msdos_date_unix2dos+0xb2> <== ALWAYS TAKEN
break;
days -= months[month];
5809c: 9082 subl %d2,%d0 <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
5809e: 5288 addql #1,%a0 <== NOT EXECUTED
580a0: 740c moveq #12,%d2 <== NOT EXECUTED
580a2: b488 cmpl %a0,%d2 <== NOT EXECUTED
580a4: 66ee bnes 58094 <msdos_date_unix2dos+0xa0> <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
580a6: 2408 movel %a0,%d2
580a8: 5282 addql #1,%d2
580aa: 2240 moveal %d0,%a1
580ac: eb8a lsll #5,%d2
580ae: 41f1 2801 lea %a1@(00000001,%d2:l),%a0
580b2: 33c8 0006 ac96 movew %a0,6ac96 <lastddate>
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
580b8: 0c81 0000 07bc cmpil #1980,%d1
580be: 6312 blss 580d2 <msdos_date_unix2dos+0xde> <== NEVER TAKEN
lastddate += (year - 1980) <<
580c0: 0681 ffff f844 addil #-1980,%d1
580c6: 7009 moveq #9,%d0
580c8: e1a9 lsll %d0,%d1
580ca: d288 addl %a0,%d1
580cc: 33c1 0006 ac96 movew %d1,6ac96 <lastddate>
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
580d2: 206e 0010 moveal %fp@(16),%a0
580d6: 30b9 0006 ac90 movew 6ac90 <lastdtime>,%a0@
*ddp = lastddate;
580dc: 206e 000c moveal %fp@(12),%a0
}
580e0: 4cd7 003c moveml %sp@,%d2-%d5
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
580e4: 30b9 0006 ac96 movew 6ac96 <lastddate>,%a0@
}
580ea: 4e5e unlk %fp <== NOT EXECUTED
000589ba <msdos_dir_chmod>:
int
msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
589ba: 4280 clrl %d0 <== NOT EXECUTED
* RC_OK always
*/
int
msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
589bc: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return RC_OK;
}
589c0: 4e5e unlk %fp <== NOT EXECUTED
0005834a <msdos_dir_close>:
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
5834a: 4e56 fff4 linkw %fp,#-12
5834e: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
58352: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
58356: 206b 0028 moveal %a3@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
5835a: 242b 0018 movel %a3@(24),%d2
int
msdos_dir_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
5835e: 2468 0034 moveal %a0@(52),%a2
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
58362: 42a7 clrl %sp@-
58364: 42a7 clrl %sp@-
58366: 2f2a 0088 movel %a2@(136),%sp@-
5836a: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
58370: 4fef 000c lea %sp@(12),%sp
58374: 4a80 tstl %d0
58376: 6710 beqs 58388 <msdos_dir_close+0x3e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
58378: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5837e: 74ff moveq #-1,%d2 <== NOT EXECUTED
58380: 7205 moveq #5,%d1 <== NOT EXECUTED
58382: 2040 moveal %d0,%a0 <== NOT EXECUTED
58384: 2081 movel %d1,%a0@ <== NOT EXECUTED
58386: 601e bras 583a6 <msdos_dir_close+0x5c> <== NOT EXECUTED
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
58388: 2f02 movel %d2,%sp@-
5838a: 2f2b 0028 movel %a3@(40),%sp@-
5838e: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close>
if (rc != RC_OK)
58394: 508f addql #8,%sp
58396: 41f9 0004 901c lea 4901c <rtems_semaphore_release>,%a0
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
5839c: 2400 movel %d0,%d2
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rtems_semaphore_release(fs_info->vol_sema);
5839e: 2f2a 0088 movel %a2@(136),%sp@-
583a2: 4e90 jsr %a0@
return RC_OK;
583a4: 588f addql #4,%sp
}
583a6: 2002 movel %d2,%d0
583a8: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
583ae: 4e5e unlk %fp <== NOT EXECUTED
00055e04 <msdos_dir_is_empty>:
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
55e04: 4e56 ffd4 linkw %fp,#-44 <== NOT EXECUTED
55e08: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
55e0c: 2a2e 0008 movel %fp@(8),%d5 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55e10: 2045 moveal %d5,%a0 <== NOT EXECUTED
uint32_t j = 0, i = 0;
55e12: 4283 clrl %d3 <== NOT EXECUTED
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
55e14: 2c3c 0004 fc56 movel #326742,%d6 <== NOT EXECUTED
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
55e1a: 4bf9 0005 a30c lea 5a30c <strncmp>,%a5 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
55e20: 286e 0010 moveal %fp@(16),%a4 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55e24: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
55e28: 2e2e 000c movel %fp@(12),%d7 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
55e2c: 4214 clrb %a4@ <== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
55e2e: 6000 00a2 braw 55ed2 <msdos_dir_is_empty+0xce> <== NOT EXECUTED
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
55e32: 721f moveq #31,%d1 <== NOT EXECUTED
55e34: b280 cmpl %d0,%d1 <== NOT EXECUTED
55e36: 6c00 00c2 bgew 55efa <msdos_dir_is_empty+0xf6> <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
55e3a: 4281 clrl %d1 <== NOT EXECUTED
55e3c: 3212 movew %a2@,%d1 <== NOT EXECUTED
55e3e: b280 cmpl %d0,%d1 <== NOT EXECUTED
55e40: 6700 0082 beqw 55ec4 <msdos_dir_is_empty+0xc0> <== NOT EXECUTED
55e44: 4879 0006 8e7b pea 68e7b <msdos_file_handlers+0x51> <== NOT EXECUTED
55e4a: 4879 0006 8f1c pea 68f1c <__FUNCTION__.7100> <== NOT EXECUTED
55e50: 4878 03b5 pea 3b5 <DBL_MANT_DIG+0x380> <== NOT EXECUTED
55e54: 4879 0006 8e97 pea 68e97 <msdos_file_handlers+0x6d> <== NOT EXECUTED
55e5a: 4eb9 0005 2244 jsr 52244 <__assert_func> <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
55e60: 266a 008c moveal %a2@(140),%a3 <== NOT EXECUTED
55e64: d7c2 addal %d2,%a3 <== NOT EXECUTED
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
55e66: 4280 clrl %d0 <== NOT EXECUTED
55e68: 1813 moveb %a3@,%d4 <== NOT EXECUTED
55e6a: 1004 moveb %d4,%d0 <== NOT EXECUTED
55e6c: 0c80 0000 00e5 cmpil #229,%d0 <== NOT EXECUTED
55e72: 673e beqs 55eb2 <msdos_dir_is_empty+0xae> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
55e74: 4280 clrl %d0 <== NOT EXECUTED
55e76: 102b 000b moveb %a3@(11),%d0 <== NOT EXECUTED
55e7a: 723f moveq #63,%d1 <== NOT EXECUTED
55e7c: c081 andl %d1,%d0 <== NOT EXECUTED
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
55e7e: 123c 000f moveb #15,%d1 <== NOT EXECUTED
55e82: b280 cmpl %d0,%d1 <== NOT EXECUTED
55e84: 672c beqs 55eb2 <msdos_dir_is_empty+0xae> <== NOT EXECUTED
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
55e86: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
55e8a: 4879 0006 8ee1 pea 68ee1 <msdos_file_handlers+0xb7> <== NOT EXECUTED
55e90: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55e92: 4e95 jsr %a5@ <== NOT EXECUTED
55e94: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
55e98: 4a80 tstl %d0 <== NOT EXECUTED
55e9a: 6716 beqs 55eb2 <msdos_dir_is_empty+0xae> <== NOT EXECUTED
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
55e9c: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
55ea0: 4879 0006 8eed pea 68eed <msdos_file_handlers+0xc3> <== NOT EXECUTED
55ea6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55ea8: 4e95 jsr %a5@ <== NOT EXECUTED
55eaa: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
55eae: 4a80 tstl %d0 <== NOT EXECUTED
55eb0: 6608 bnes 55eba <msdos_dir_is_empty+0xb6> <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
55eb2: 0682 0000 0020 addil #32,%d2 <== NOT EXECUTED
55eb8: 6010 bras 55eca <msdos_dir_is_empty+0xc6> <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
55eba: 4a04 tstb %d4 <== NOT EXECUTED
55ebc: 6640 bnes 55efe <msdos_dir_is_empty+0xfa> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
55ebe: 18bc 0001 moveb #1,%a4@ <== NOT EXECUTED
55ec2: 603a bras 55efe <msdos_dir_is_empty+0xfa> <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
55ec4: 4282 clrl %d2 <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
55ec6: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
55eca: b4ae fffc cmpl %fp@(-4),%d2 <== NOT EXECUTED
55ece: 6590 bcss 55e60 <msdos_dir_is_empty+0x5c> <== NOT EXECUTED
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
55ed0: 5283 addql #1,%d3 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
55ed2: 4280 clrl %d0 <== NOT EXECUTED
55ed4: 2046 moveal %d6,%a0 <== NOT EXECUTED
55ed6: 3012 movew %a2@,%d0 <== NOT EXECUTED
55ed8: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED
55edc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
55ede: 4c03 0800 mulsl %d3,%d0 <== NOT EXECUTED
55ee2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
55ee4: 2f07 movel %d7,%sp@- <== NOT EXECUTED
55ee6: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55ee8: 4e90 jsr %a0@ <== NOT EXECUTED
55eea: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
55eee: 4a80 tstl %d0 <== NOT EXECUTED
55ef0: 6600 ff40 bnew 55e32 <msdos_dir_is_empty+0x2e> <== NOT EXECUTED
*/
return RC_OK;
}
j++;
}
*ret_val = true;
55ef4: 18bc 0001 moveb #1,%a4@ <== NOT EXECUTED
return RC_OK;
55ef8: 6006 bras 55f00 <msdos_dir_is_empty+0xfc> <== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
55efa: 70ff moveq #-1,%d0 <== NOT EXECUTED
55efc: 6002 bras 55f00 <msdos_dir_is_empty+0xfc> <== NOT EXECUTED
}
/*
* Short file name entries mean not empty.
*/
return RC_OK;
55efe: 4280 clrl %d0 <== NOT EXECUTED
}
j++;
}
*ret_val = true;
return RC_OK;
}
55f00: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5 <== NOT EXECUTED
55f06: 4e5e unlk %fp <== NOT EXECUTED
00058888 <msdos_dir_lseek>:
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
switch (whence)
58888: 7001 moveq #1,%d0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
5888a: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
switch (whence)
5888e: b0ae 0014 cmpl %fp@(20),%d0 <== NOT EXECUTED
58892: 6412 bccs 588a6 <msdos_dir_lseek+0x1e> <== NOT EXECUTED
* Movement past the end of the directory via lseek is not a
* permitted operation
*/
case SEEK_END:
default:
rtems_set_errno_and_return_minus_one( EINVAL );
58894: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5889a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5889c: 7016 moveq #22,%d0 <== NOT EXECUTED
5889e: 2080 movel %d0,%a0@ <== NOT EXECUTED
588a0: 70ff moveq #-1,%d0 <== NOT EXECUTED
588a2: 72ff moveq #-1,%d1 <== NOT EXECUTED
588a4: 6004 bras 588aa <msdos_dir_lseek+0x22> <== NOT EXECUTED
break;
}
return RC_OK;
588a6: 4280 clrl %d0 <== NOT EXECUTED
588a8: 4281 clrl %d1 <== NOT EXECUTED
}
588aa: 4e5e unlk %fp <== NOT EXECUTED
000582d8 <msdos_dir_open>:
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
582d8: 4e56 fff4 linkw %fp,#-12
582dc: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
582e0: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
582e4: 206b 0028 moveal %a3@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
582e8: 242b 0018 movel %a3@(24),%d2
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
582ec: 2468 0034 moveal %a0@(52),%a2
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
582f0: 42a7 clrl %sp@-
582f2: 42a7 clrl %sp@-
582f4: 2f2a 0088 movel %a2@(136),%sp@-
582f8: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
582fe: 4fef 000c lea %sp@(12),%sp
58302: 4a80 tstl %d0
58304: 6710 beqs 58316 <msdos_dir_open+0x3e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
58306: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5830c: 74ff moveq #-1,%d2 <== NOT EXECUTED
5830e: 2040 moveal %d0,%a0 <== NOT EXECUTED
58310: 7005 moveq #5,%d0 <== NOT EXECUTED
58312: 2080 movel %d0,%a0@ <== NOT EXECUTED
58314: 6028 bras 5833e <msdos_dir_open+0x66> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
58316: 2f02 movel %d2,%sp@-
58318: 4eb9 0004 fc44 jsr 4fc44 <fat_file_reopen>
if (rc != RC_OK)
5831e: 588f addql #4,%sp
58320: 41f9 0004 901c lea 4901c <rtems_semaphore_release>,%a0
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_reopen(fat_fd);
58326: 2400 movel %d0,%d2
if (rc != RC_OK)
58328: 660c bnes 58336 <msdos_dir_open+0x5e> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
iop->offset = 0;
5832a: 4280 clrl %d0
5832c: 4281 clrl %d1
5832e: 2740 000c movel %d0,%a3@(12)
58332: 2741 0010 movel %d1,%a3@(16)
rtems_semaphore_release(fs_info->vol_sema);
58336: 2f2a 0088 movel %a2@(136),%sp@-
5833a: 4e90 jsr %a0@
return RC_OK;
5833c: 588f addql #4,%sp
}
5833e: 2002 movel %d2,%d0
58340: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
58346: 4e5e unlk %fp <== NOT EXECUTED
000583b2 <msdos_dir_read>:
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
583b2: 7001 moveq #1,%d0 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
583b4: 4e56 fe80 linkw %fp,#-384 <== NOT EXECUTED
583b8: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
583bc: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
583c0: 206b 0028 moveal %a3@(40),%a0 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
583c4: 2c2e 0010 movel %fp@(16),%d6 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
583c8: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
583cc: 286b 0018 moveal %a3@(24),%a4 <== NOT EXECUTED
fat_file_fd_t *tmp_fat_fd = NULL;
583d0: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
583d4: 242b 000c movel %a3@(12),%d2 <== NOT EXECUTED
583d8: 262b 0010 movel %a3@(16),%d3 <== NOT EXECUTED
uint32_t start = 0;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t j = 0, i = 0;
uint32_t bts2rd = 0;
uint32_t cur_cln = 0;
583dc: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
583e0: b0ac 0020 cmpl %a4@(32),%d0 <== NOT EXECUTED
583e4: 661c bnes 58402 <msdos_dir_read+0x50> <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
583e6: 4aac 0024 tstl %a4@(36) <== NOT EXECUTED
583ea: 6616 bnes 58402 <msdos_dir_read+0x50> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
583ec: 4280 clrl %d0 <== NOT EXECUTED
583ee: 102a 000a moveb %a2@(10),%d0 <== NOT EXECUTED
583f2: 7203 moveq #3,%d1 <== NOT EXECUTED
583f4: c081 andl %d1,%d0 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
583f6: 670a beqs 58402 <msdos_dir_read+0x50> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
583f8: 2a2c 0018 movel %a4@(24),%d5 <== NOT EXECUTED
583fc: 2d45 fec2 movel %d5,%fp@(-318) <== NOT EXECUTED
58400: 600a bras 5840c <msdos_dir_read+0x5a> <== NOT EXECUTED
58402: 4287 clrl %d7 <== NOT EXECUTED
58404: 3e2a 0006 movew %a2@(6),%d7 <== NOT EXECUTED
58408: 2d47 fec2 movel %d7,%fp@(-318) <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
5840c: 42a7 clrl %sp@- <== NOT EXECUTED
5840e: 42a7 clrl %sp@- <== NOT EXECUTED
58410: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
58414: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
5841a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5841e: 4a80 tstl %d0 <== NOT EXECUTED
58420: 6648 bnes 5846a <msdos_dir_read+0xb8> <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
58422: 4878 0110 pea 110 <DBL_MANT_DIG+0xdb> <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
58426: 4285 clrl %d5 <== NOT EXECUTED
58428: 7eff moveq #-1,%d7 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
5842a: 42a7 clrl %sp@- <== NOT EXECUTED
5842c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
5842e: 4283 clrl %d3 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
58430: 2f02 movel %d2,%sp@- <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
58432: 4202 clrb %d2 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
58434: 4eb9 0006 5528 jsr 65528 <__divdi3> <== NOT EXECUTED
5843a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
5843e: 41ee fed8 lea %fp@(-296),%a0 <== NOT EXECUTED
58442: 41e8 0010 lea %a0@(16),%a0 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
58446: 2d41 fec8 movel %d1,%fp@(-312) <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
5844a: 223c 0000 0110 movel #272,%d1 <== NOT EXECUTED
58450: 4c41 6006 remul %d1,%d6,%d6 <== NOT EXECUTED
58454: 1d42 fec7 moveb %d2,%fp@(-313) <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
58458: 2d48 fed0 movel %a0,%fp@(-304) <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
5845c: 2006 movel %d6,%d0 <== NOT EXECUTED
5845e: 4282 clrl %d2 <== NOT EXECUTED
58460: e988 lsll #4,%d0 <== NOT EXECUTED
58462: e18e lsll #8,%d6 <== NOT EXECUTED
58464: dc80 addl %d0,%d6 <== NOT EXECUTED
58466: 6000 03b2 braw 5881a <msdos_dir_read+0x468> <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
5846a: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
58470: 7605 moveq #5,%d3 <== NOT EXECUTED
58472: 2240 moveal %d0,%a1 <== NOT EXECUTED
58474: 2283 movel %d3,%a1@ <== NOT EXECUTED
58476: 603e bras 584b6 <msdos_dir_read+0x104> <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
58478: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED
5847c: 2f2e fec2 movel %fp@(-318),%sp@- <== NOT EXECUTED
58480: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58482: 2f0c movel %a4,%sp@- <== NOT EXECUTED
58484: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
58488: 4eb9 0004 fc56 jsr 4fc56 <fat_file_read> <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
5848e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
58492: 721f moveq #31,%d1 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
58494: 2d40 feba movel %d0,%fp@(-326) <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
58498: b280 cmpl %d0,%d1 <== NOT EXECUTED
5849a: 6d00 0368 bltw 58804 <msdos_dir_read+0x452> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
5849e: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
584a2: 7405 moveq #5,%d2 <== NOT EXECUTED
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
rtems_semaphore_release(fs_info->vol_sema);
584a4: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
584aa: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
584b0: 588f addql #4,%sp <== NOT EXECUTED
584b2: 2040 moveal %d0,%a0 <== NOT EXECUTED
584b4: 2082 movel %d2,%a0@ <== NOT EXECUTED
584b6: 72ff moveq #-1,%d1 <== NOT EXECUTED
584b8: 6000 0374 braw 5882e <msdos_dir_read+0x47c> <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
584bc: 2a6a 008c moveal %a2@(140),%a5 <== NOT EXECUTED
584c0: dbc4 addal %d4,%a5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
584c2: 1a15 moveb %a5@,%d5 <== NOT EXECUTED
584c4: 6700 035a beqw 58820 <msdos_dir_read+0x46e> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
584c8: 4281 clrl %d1 <== NOT EXECUTED
584ca: 1205 moveb %d5,%d1 <== NOT EXECUTED
584cc: 0c81 0000 00e5 cmpil #229,%d1 <== NOT EXECUTED
584d2: 6700 0328 beqw 587fc <msdos_dir_read+0x44a> <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
584d6: 4280 clrl %d0 <== NOT EXECUTED
584d8: 102d 000b moveb %a5@(11),%d0 <== NOT EXECUTED
584dc: 2040 moveal %d0,%a0 <== NOT EXECUTED
584de: 703f moveq #63,%d0 <== NOT EXECUTED
584e0: 2208 movel %a0,%d1 <== NOT EXECUTED
584e2: c280 andl %d0,%d1 <== NOT EXECUTED
584e4: 2008 movel %a0,%d0 <== NOT EXECUTED
584e6: 44c0 movew %d0,%ccr <== NOT EXECUTED
584e8: 6a08 bpls 584f2 <msdos_dir_read+0x140> <== NOT EXECUTED
584ea: 700f moveq #15,%d0 <== NOT EXECUTED
584ec: b081 cmpl %d1,%d0 <== NOT EXECUTED
584ee: 6600 030c bnew 587fc <msdos_dir_read+0x44a> <== NOT EXECUTED
/*
* Check the attribute to see if the entry is for a long file
* name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
584f2: 700f moveq #15,%d0 <== NOT EXECUTED
584f4: b081 cmpl %d1,%d0 <== NOT EXECUTED
584f6: 6600 00ae bnew 585a6 <msdos_dir_read+0x1f4> <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
584fa: 72ff moveq #-1,%d1 <== NOT EXECUTED
584fc: b287 cmpl %d7,%d1 <== NOT EXECUTED
584fe: 6634 bnes 58534 <msdos_dir_read+0x182> <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
58500: 4280 clrl %d0 <== NOT EXECUTED
58502: 1005 moveb %d5,%d0 <== NOT EXECUTED
58504: 0800 0006 btst #6,%d0 <== NOT EXECUTED
58508: 6700 02f2 beqw 587fc <msdos_dir_read+0x44a> <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
5850c: 2e2e feb2 movel %fp@(-334),%d7 <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
58510: 763f moveq #63,%d3 <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
58512: de84 addl %d4,%d7 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
58514: ea8f lsrl #5,%d7 <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
58516: 1a2d 000d moveb %a5@(13),%d5 <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
5851a: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
5851e: c680 andl %d0,%d3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
58520: 42a7 clrl %sp@- <== NOT EXECUTED
58522: 2f2e fed0 movel %fp@(-304),%sp@- <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
58526: 1d45 fec7 moveb %d5,%fp@(-313) <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
5852a: 4eb9 0005 957c jsr 5957c <memset> <== NOT EXECUTED
58530: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
58534: 4280 clrl %d0 <== NOT EXECUTED
58536: 1015 moveb %a5@,%d0 <== NOT EXECUTED
58538: 723f moveq #63,%d1 <== NOT EXECUTED
5853a: c081 andl %d1,%d0 <== NOT EXECUTED
5853c: b083 cmpl %d3,%d0 <== NOT EXECUTED
5853e: 6600 02ba bnew 587fa <msdos_dir_read+0x448> <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
58542: 4281 clrl %d1 <== NOT EXECUTED
58544: 4280 clrl %d0 <== NOT EXECUTED
58546: 122e fec7 moveb %fp@(-313),%d1 <== NOT EXECUTED
5854a: 102d 000d moveb %a5@(13),%d0 <== NOT EXECUTED
5854e: b081 cmpl %d1,%d0 <== NOT EXECUTED
58550: 6600 02a8 bnew 587fa <msdos_dir_read+0x448> <== NOT EXECUTED
* The DOS maximum length is 255 characters without the
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
58554: 5383 subql #1,%d3 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
58556: 720d moveq #13,%d1 <== NOT EXECUTED
58558: 4c03 1800 mulsl %d3,%d1 <== NOT EXECUTED
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
5855c: 528d addql #1,%a5 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
5855e: 4280 clrl %d0 <== NOT EXECUTED
58560: 2242 moveal %d2,%a1 <== NOT EXECUTED
58562: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
58566: 0c81 0000 00fe cmpil #254,%d1 <== NOT EXECUTED
5856c: 6200 0280 bhiw 587ee <msdos_dir_read+0x43c> <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
58570: 206e fed0 moveal %fp@(-304),%a0 <== NOT EXECUTED
58574: 1195 1800 moveb %a5@,%a0@(00000000,%d1:l) <== NOT EXECUTED
58578: 5281 addql #1,%d1 <== NOT EXECUTED
if (*p == '\0')
5857a: 4a15 tstb %a5@ <== NOT EXECUTED
5857c: 6700 0270 beqw 587ee <msdos_dir_read+0x43c> <== NOT EXECUTED
break;
switch (q)
58580: 7404 moveq #4,%d2 <== NOT EXECUTED
58582: b480 cmpl %d0,%d2 <== NOT EXECUTED
58584: 670a beqs 58590 <msdos_dir_read+0x1de> <== NOT EXECUTED
58586: 143c 000a moveb #10,%d2 <== NOT EXECUTED
5858a: b480 cmpl %d0,%d2 <== NOT EXECUTED
5858c: 660a bnes 58598 <msdos_dir_read+0x1e6> <== NOT EXECUTED
5858e: 6004 bras 58594 <msdos_dir_read+0x1e2> <== NOT EXECUTED
{
case 4:
p += 5;
58590: 5a8d addql #5,%a5 <== NOT EXECUTED
break;
58592: 6006 bras 5859a <msdos_dir_read+0x1e8> <== NOT EXECUTED
case 10:
p += 4;
58594: 588d addql #4,%a5 <== NOT EXECUTED
break;
58596: 6002 bras 5859a <msdos_dir_read+0x1e8> <== NOT EXECUTED
default:
p += 2;
58598: 548d addql #2,%a5 <== NOT EXECUTED
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
5859a: 5280 addql #1,%d0 <== NOT EXECUTED
5859c: 740d moveq #13,%d2 <== NOT EXECUTED
5859e: b480 cmpl %d0,%d2 <== NOT EXECUTED
585a0: 66c4 bnes 58566 <msdos_dir_read+0x1b4> <== NOT EXECUTED
585a2: 6000 024a braw 587ee <msdos_dir_read+0x43c> <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
585a6: 4aae fec8 tstl %fp@(-312) <== NOT EXECUTED
585aa: 6708 beqs 585b4 <msdos_dir_read+0x202> <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
585ac: 53ae fec8 subql #1,%fp@(-312) <== NOT EXECUTED
585b0: 6000 0248 braw 587fa <msdos_dir_read+0x448> <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
585b4: 486e fffc pea %fp@(-4) <== NOT EXECUTED
585b8: 2f2e feb2 movel %fp@(-334),%sp@- <== NOT EXECUTED
585bc: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
585c0: 2f0c movel %a4,%sp@- <== NOT EXECUTED
585c2: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
585c6: 4eb9 0004 ff7c jsr 4ff7c <fat_file_ioctl> <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
585cc: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
585d0: 4a80 tstl %d0 <== NOT EXECUTED
585d2: 6600 0204 bnew 587d8 <msdos_dir_read+0x426> <== NOT EXECUTED
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
585d6: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
585da: 7aff moveq #-1,%d5 <== NOT EXECUTED
585dc: 486e ffe8 pea %fp@(-24) <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
585e0: 2d6e fffc ffe8 movel %fp@(-4),%fp@(-24) <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
585e6: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
585ea: 2d45 fff0 movel %d5,%fp@(-16) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
585ee: 2d45 fff4 movel %d5,%fp@(-12) <== NOT EXECUTED
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
585f2: 2d44 ffec movel %d4,%fp@(-20) <== NOT EXECUTED
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
585f6: 4eb9 0004 fb18 jsr 4fb18 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
585fc: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
58600: 4a80 tstl %d0 <== NOT EXECUTED
58602: 6600 01d4 bnew 587d8 <msdos_dir_read+0x426> <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
58606: 2d42 fee0 movel %d2,%fp@(-288) <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
5860a: 70ff moveq #-1,%d0 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
5860c: 307c 0110 moveaw #272,%a0 <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
58610: 42ae fedc clrl %fp@(-292) <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
58614: 3d48 fee4 movew %a0,%fp@(-284) <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
58618: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
5861c: 2d68 000c fed8 movel %a0@(12),%fp@(-296) <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
58622: b087 cmpl %d7,%d0 <== NOT EXECUTED
58624: 6752 beqs 58678 <msdos_dir_read+0x2c6> <== NOT EXECUTED
58626: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
5862a: 204d moveal %a5,%a0 <== NOT EXECUTED
5862c: 700b moveq #11,%d0 <== NOT EXECUTED
5862e: 4201 clrb %d1 <== NOT EXECUTED
58630: 2d42 fecc movel %d2,%fp@(-308) <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
58634: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
5863a: 2241 moveal %d1,%a1 <== NOT EXECUTED
5863c: 0801 0000 btst #0,%d1 <== NOT EXECUTED
58640: 6704 beqs 58646 <msdos_dir_read+0x294> <== NOT EXECUTED
58642: 7280 moveq #-128,%d1 <== NOT EXECUTED
58644: 6002 bras 58648 <msdos_dir_read+0x296> <== NOT EXECUTED
58646: 4201 clrb %d1 <== NOT EXECUTED
58648: 2409 movel %a1,%d2 <== NOT EXECUTED
5864a: e28a lsrl #1,%d2 <== NOT EXECUTED
5864c: 2242 moveal %d2,%a1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
5864e: 5380 subql #1,%d0 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
58650: 1418 moveb %a0@+,%d2 <== NOT EXECUTED
58652: d3c2 addal %d2,%a1 <== NOT EXECUTED
58654: d289 addl %a1,%d1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
58656: 4a80 tstl %d0 <== NOT EXECUTED
58658: 66da bnes 58634 <msdos_dir_read+0x282> <== NOT EXECUTED
5865a: 242e fecc movel %fp@(-308),%d2 <== NOT EXECUTED
5865e: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
58662: 4a83 tstl %d3 <== NOT EXECUTED
58664: 6612 bnes 58678 <msdos_dir_read+0x2c6> <== NOT EXECUTED
58666: 4280 clrl %d0 <== NOT EXECUTED
58668: 102e fec7 moveb %fp@(-313),%d0 <== NOT EXECUTED
5866c: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
58672: b280 cmpl %d0,%d1 <== NOT EXECUTED
58674: 6700 01c4 beqw 5883a <msdos_dir_read+0x488> <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
58678: 41ed 0008 lea %a5@(8),%a0 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
5867c: 7008 moveq #8,%d0 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
5867e: 2d48 fed4 movel %a0,%fp@(-300) <== NOT EXECUTED
58682: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
58686: 6004 bras 5868c <msdos_dir_read+0x2da> <== NOT EXECUTED
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
58688: 5380 subql #1,%d0 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
5868a: 670a beqs 58696 <msdos_dir_read+0x2e4> <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
5868c: 7e20 moveq #32,%d7 <== NOT EXECUTED
5868e: 1220 moveb %a0@-,%d1 <== NOT EXECUTED
58690: 49c1 extbl %d1 <== NOT EXECUTED
58692: be81 cmpl %d1,%d7 <== NOT EXECUTED
58694: 67f2 beqs 58688 <msdos_dir_read+0x2d6> <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
58696: 2079 0006 9d68 moveal 69d68 <__ctype_ptr__>,%a0 <== NOT EXECUTED
5869c: 2200 movel %d0,%d1 <== NOT EXECUTED
5869e: 224d moveal %a5,%a1 <== NOT EXECUTED
586a0: 2d48 febe movel %a0,%fp@(-322) <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
586a4: 206e fed0 moveal %fp@(-304),%a0 <== NOT EXECUTED
586a8: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
586ac: 2d48 fecc movel %a0,%fp@(-308) <== NOT EXECUTED
586b0: 2d42 feae movel %d2,%fp@(-338) <== NOT EXECUTED
586b4: 2d40 feaa movel %d0,%fp@(-342) <== NOT EXECUTED
586b8: 602c bras 586e6 <msdos_dir_read+0x334> <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
586ba: 4287 clrl %d7 <== NOT EXECUTED
586bc: 1e19 moveb %a1@+,%d7 <== NOT EXECUTED
586be: 7403 moveq #3,%d2 <== NOT EXECUTED
586c0: 206e febe moveal %fp@(-322),%a0 <== NOT EXECUTED
586c4: 1030 7801 moveb %a0@(00000001,%d7:l),%d0 <== NOT EXECUTED
586c8: 49c0 extbl %d0 <== NOT EXECUTED
586ca: c082 andl %d2,%d0 <== NOT EXECUTED
586cc: 143c 0001 moveb #1,%d2 <== NOT EXECUTED
586d0: b480 cmpl %d0,%d2 <== NOT EXECUTED
586d2: 6606 bnes 586da <msdos_dir_read+0x328> <== NOT EXECUTED
586d4: 0687 0000 0020 addil #32,%d7 <== NOT EXECUTED
586da: 206e fecc moveal %fp@(-308),%a0 <== NOT EXECUTED
586de: 5381 subql #1,%d1 <== NOT EXECUTED
586e0: 52ae fecc addql #1,%fp@(-308) <== NOT EXECUTED
586e4: 10c7 moveb %d7,%a0@+ <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
586e6: 4a81 tstl %d1 <== NOT EXECUTED
586e8: 6ed0 bgts 586ba <msdos_dir_read+0x308> <== NOT EXECUTED
586ea: 202e feaa movel %fp@(-342),%d0 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
586ee: 2e00 movel %d0,%d7 <== NOT EXECUTED
586f0: 4687 notl %d7 <== NOT EXECUTED
586f2: 41ee fee8 lea %fp@(-280),%a0 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
586f6: 7220 moveq #32,%d1 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
586f8: de87 addl %d7,%d7 <== NOT EXECUTED
586fa: 9f87 subxl %d7,%d7 <== NOT EXECUTED
586fc: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
58700: 242e feae movel %fp@(-338),%d2 <== NOT EXECUTED
58704: ce80 andl %d0,%d7 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
58706: 1a2d 000a moveb %a5@(10),%d5 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
5870a: 43f0 7800 lea %a0@(00000000,%d7:l),%a1 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
5870e: 49c5 extbl %d5 <== NOT EXECUTED
58710: b285 cmpl %d5,%d1 <== NOT EXECUTED
58712: 6600 013a bnew 5884e <msdos_dir_read+0x49c> <== NOT EXECUTED
58716: 1a2d 0009 moveb %a5@(9),%d5 <== NOT EXECUTED
5871a: 49c5 extbl %d5 <== NOT EXECUTED
5871c: b285 cmpl %d5,%d1 <== NOT EXECUTED
5871e: 6600 0132 bnew 58852 <msdos_dir_read+0x4a0> <== NOT EXECUTED
58722: 1a2d 0008 moveb %a5@(8),%d5 <== NOT EXECUTED
58726: 49c5 extbl %d5 <== NOT EXECUTED
58728: b285 cmpl %d5,%d1 <== NOT EXECUTED
5872a: 6754 beqs 58780 <msdos_dir_read+0x3ce> <== NOT EXECUTED
5872c: 123c 0001 moveb #1,%d1 <== NOT EXECUTED
58730: 6000 0122 braw 58854 <msdos_dir_read+0x4a2> <== NOT EXECUTED
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
58734: 226e fed4 moveal %fp@(-300),%a1 <== NOT EXECUTED
58738: 4287 clrl %d7 <== NOT EXECUTED
5873a: 1e19 moveb %a1@+,%d7 <== NOT EXECUTED
5873c: 7203 moveq #3,%d1 <== NOT EXECUTED
5873e: 52ae fed4 addql #1,%fp@(-300) <== NOT EXECUTED
58742: 226e febe moveal %fp@(-322),%a1 <== NOT EXECUTED
58746: 1031 7801 moveb %a1@(00000001,%d7:l),%d0 <== NOT EXECUTED
5874a: 49c0 extbl %d0 <== NOT EXECUTED
5874c: c081 andl %d1,%d0 <== NOT EXECUTED
5874e: 123c 0001 moveb #1,%d1 <== NOT EXECUTED
58752: b280 cmpl %d0,%d1 <== NOT EXECUTED
58754: 6606 bnes 5875c <msdos_dir_read+0x3aa> <== NOT EXECUTED
58756: 0687 0000 0020 addil #32,%d7 <== NOT EXECUTED
5875c: 5388 subql #1,%a0 <== NOT EXECUTED
5875e: 1ac7 moveb %d7,%a5@+ <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
58760: 4a88 tstl %a0 <== NOT EXECUTED
58762: 6ed0 bgts 58734 <msdos_dir_read+0x382> <== NOT EXECUTED
58764: 222e feae movel %fp@(-338),%d1 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
58768: 2001 movel %d1,%d0 <== NOT EXECUTED
5876a: 4680 notl %d0 <== NOT EXECUTED
5876c: d080 addl %d0,%d0 <== NOT EXECUTED
5876e: 9180 subxl %d0,%d0 <== NOT EXECUTED
58770: 226e feaa moveal %fp@(-342),%a1 <== NOT EXECUTED
58774: c081 andl %d1,%d0 <== NOT EXECUTED
58776: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
5877a: d3c0 addal %d0,%a1 <== NOT EXECUTED
5877c: d0ae fecc addl %fp@(-308),%d0 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
58780: 7eff moveq #-1,%d7 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
58782: 4211 clrb %a1@ <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
58784: 3d40 fee6 movew %d0,%fp@(-282) <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
58788: 4878 0110 pea 110 <DBL_MANT_DIG+0xdb> <== NOT EXECUTED
5878c: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
58790: 486e fed8 pea %fp@(-296) <== NOT EXECUTED
58794: 4870 2800 pea %a0@(00000000,%d2:l) <== NOT EXECUTED
58798: 4eb9 0005 950c jsr 5950c <memcpy> <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
5879e: 4280 clrl %d0 <== NOT EXECUTED
587a0: 223c 0000 0110 movel #272,%d1 <== NOT EXECUTED
587a6: d3ab 0010 addl %d1,%a3@(16) <== NOT EXECUTED
587aa: 2a2b 000c movel %a3@(12),%d5 <== NOT EXECUTED
587ae: db80 addxl %d0,%d5 <== NOT EXECUTED
587b0: 2745 000c movel %d5,%a3@(12) <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
587b4: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
587b8: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
587bc: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
587c2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
587c6: 4a80 tstl %d0 <== NOT EXECUTED
587c8: 660e bnes 587d8 <msdos_dir_read+0x426> <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
587ca: 0682 0000 0110 addil #272,%d2 <== NOT EXECUTED
count -= (sizeof(struct dirent));
587d0: 0686 ffff fef0 addil #-272,%d6 <== NOT EXECUTED
587d6: 601c bras 587f4 <msdos_dir_read+0x442> <== NOT EXECUTED
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
587d8: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
587dc: 2d40 feb6 movel %d0,%fp@(-330) <== NOT EXECUTED
587e0: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
587e6: 222e feb6 movel %fp@(-330),%d1 <== NOT EXECUTED
587ea: 588f addql #4,%sp <== NOT EXECUTED
587ec: 6040 bras 5882e <msdos_dir_read+0x47c> <== NOT EXECUTED
587ee: 2409 movel %a1,%d2 <== NOT EXECUTED
587f0: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
}
}
if (count <= 0)
587f4: 4a86 tstl %d6 <== NOT EXECUTED
587f6: 6604 bnes 587fc <msdos_dir_read+0x44a> <== NOT EXECUTED
587f8: 6018 bras 58812 <msdos_dir_read+0x460> <== NOT EXECUTED
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
587fa: 7eff moveq #-1,%d7 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
587fc: 0684 0000 0020 addil #32,%d4 <== NOT EXECUTED
58802: 6006 bras 5880a <msdos_dir_read+0x458> <== NOT EXECUTED
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
58804: 4284 clrl %d4 <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
58806: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
5880a: b8ae feba cmpl %fp@(-326),%d4 <== NOT EXECUTED
5880e: 6500 fcac bcsw 584bc <msdos_dir_read+0x10a> <== NOT EXECUTED
58812: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
58816: daae fec2 addl %fp@(-318),%d5 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
5881a: 4a86 tstl %d6 <== NOT EXECUTED
5881c: 6600 fc5a bnew 58478 <msdos_dir_read+0xc6> <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
58820: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
58824: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return cmpltd;
5882a: 588f addql #4,%sp <== NOT EXECUTED
5882c: 2202 movel %d2,%d1 <== NOT EXECUTED
}
5882e: 2001 movel %d1,%d0 <== NOT EXECUTED
58830: 4cee 3cfc fe80 moveml %fp@(-384),%d2-%d7/%a2-%a5 <== NOT EXECUTED
58836: 4e5e unlk %fp <== NOT EXECUTED
58838: 4e75 rts <== NOT EXECUTED
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
tmp_dirent.d_name, entry); /* src text */
}
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
5883a: 2f2e fed0 movel %fp@(-304),%sp@- <== NOT EXECUTED
5883e: 4eb9 0005 a2f0 jsr 5a2f0 <strlen> <== NOT EXECUTED
58844: 588f addql #4,%sp <== NOT EXECUTED
58846: 3d40 fee6 movew %d0,%fp@(-282) <== NOT EXECUTED
5884a: 6000 ff3c braw 58788 <msdos_dir_read+0x3d6> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
5884e: 7203 moveq #3,%d1 <== NOT EXECUTED
58850: 6002 bras 58854 <msdos_dir_read+0x4a2> <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
58852: 7202 moveq #2,%d1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
58854: 41f6 7800 lea %fp@(00000000,%d7:l),%a0 <== NOT EXECUTED
58858: 5289 addql #1,%a1 <== NOT EXECUTED
5885a: 2a49 moveal %a1,%a5 <== NOT EXECUTED
5885c: 7e2e moveq #46,%d7 <== NOT EXECUTED
5885e: 2d41 feae movel %d1,%fp@(-338) <== NOT EXECUTED
58862: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
58866: 1147 fee8 moveb %d7,%a0@(-280) <== NOT EXECUTED
len += i + 1; /* extension + dot */
5886a: 2041 moveal %d1,%a0 <== NOT EXECUTED
5886c: 41f0 0801 lea %a0@(00000001,%d0:l),%a0 <== NOT EXECUTED
58870: 2d49 feaa movel %a1,%fp@(-342) <== NOT EXECUTED
58874: 2d48 fecc movel %a0,%fp@(-308) <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
58878: 2079 0006 9d68 moveal 69d68 <__ctype_ptr__>,%a0 <== NOT EXECUTED
5887e: 2d48 febe movel %a0,%fp@(-322) <== NOT EXECUTED
58882: 2041 moveal %d1,%a0 <== NOT EXECUTED
58884: 6000 feda braw 58760 <msdos_dir_read+0x3ae> <== NOT EXECUTED
000589c4 <msdos_dir_rmnod>:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
589c4: 4e56 ffec linkw %fp,#-20 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
589c8: 4200 clrb %d0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
589ca: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED
589ce: 266e 000c moveal %fp@(12),%a3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
589d2: 206b 0010 moveal %a3@(16),%a0 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
589d6: 2853 moveal %a3@,%a4 <== NOT EXECUTED
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
589d8: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
589dc: 42a7 clrl %sp@- <== NOT EXECUTED
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
589de: 1d40 ffff moveb %d0,%fp@(-1) <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
589e2: 42a7 clrl %sp@- <== NOT EXECUTED
589e4: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
589e8: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
589ee: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
589f2: 4a80 tstl %d0 <== NOT EXECUTED
589f4: 670e beqs 58a04 <msdos_dir_rmnod+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
589f6: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
589fc: 7405 moveq #5,%d2 <== NOT EXECUTED
589fe: 2040 moveal %d0,%a0 <== NOT EXECUTED
58a00: 2082 movel %d2,%a0@ <== NOT EXECUTED
58a02: 6020 bras 58a24 <msdos_dir_rmnod+0x60> <== NOT EXECUTED
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
58a04: 7001 moveq #1,%d0 <== NOT EXECUTED
58a06: b0ac 0008 cmpl %a4@(8),%d0 <== NOT EXECUTED
58a0a: 641e bccs 58a2a <msdos_dir_rmnod+0x66> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
58a0c: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
58a10: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EBUSY);
58a16: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
58a1c: 7210 moveq #16,%d1 <== NOT EXECUTED
58a1e: 2040 moveal %d0,%a0 <== NOT EXECUTED
58a20: 2081 movel %d1,%a0@ <== NOT EXECUTED
58a22: 588f addql #4,%sp <== NOT EXECUTED
58a24: 74ff moveq #-1,%d2 <== NOT EXECUTED
58a26: 6000 0084 braw 58aac <msdos_dir_rmnod+0xe8> <== NOT EXECUTED
}
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
58a2a: 486e ffff pea %fp@(-1) <== NOT EXECUTED
58a2e: 2f0c movel %a4,%sp@- <== NOT EXECUTED
58a30: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
58a34: 4eb9 0005 5e04 jsr 55e04 <msdos_dir_is_empty> <== NOT EXECUTED
if (rc != RC_OK)
58a3a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
58a3e: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
58a40: 6642 bnes 58a84 <msdos_dir_rmnod+0xc0> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (!is_empty)
58a42: 4a2e ffff tstb %fp@(-1) <== NOT EXECUTED
58a46: 6618 bnes 58a60 <msdos_dir_rmnod+0x9c> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
58a48: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
58a4c: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
58a52: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
58a58: 2040 moveal %d0,%a0 <== NOT EXECUTED
58a5a: 705a moveq #90,%d0 <== NOT EXECUTED
58a5c: 2080 movel %d0,%a0@ <== NOT EXECUTED
58a5e: 60c2 bras 58a22 <msdos_dir_rmnod+0x5e> <== NOT EXECUTED
58a60: 206b 0010 moveal %a3@(16),%a0 <== NOT EXECUTED
}
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_is_root_location(pathloc))
58a64: 2013 movel %a3@,%d0 <== NOT EXECUTED
58a66: b0a8 001c cmpl %a0@(28),%d0 <== NOT EXECUTED
58a6a: 67a0 beqs 58a0c <msdos_dir_rmnod+0x48> <== NOT EXECUTED
* You cannot remove a mountpoint.
* not used - mount() not implemenetd yet.
*/
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
58a6c: 4878 00e5 pea e5 <DBL_MANT_DIG+0xb0> <== NOT EXECUTED
58a70: 486c 0020 pea %a4@(32) <== NOT EXECUTED
58a74: 2f08 movel %a0,%sp@- <== NOT EXECUTED
58a76: 4eb9 0005 5cea jsr 55cea <msdos_set_first_char4file_name> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
58a7c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* You cannot remove a mountpoint.
* not used - mount() not implemenetd yet.
*/
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
58a80: 2400 movel %d0,%d2 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
58a82: 670e beqs 58a92 <msdos_dir_rmnod+0xce> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
58a84: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
58a88: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
58a8e: 588f addql #4,%sp <== NOT EXECUTED
58a90: 601a bras 58aac <msdos_dir_rmnod+0xe8> <== NOT EXECUTED
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
58a92: 2f0c movel %a4,%sp@- <== NOT EXECUTED
58a94: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
58a98: 4eb9 0005 035a jsr 5035a <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
58a9e: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
58aa2: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
58aa8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
58aac: 2002 movel %d2,%d0 <== NOT EXECUTED
58aae: 4cee 1c04 ffec moveml %fp@(-20),%d2/%a2-%a4 <== NOT EXECUTED
58ab4: 4e5e unlk %fp <== NOT EXECUTED
000588ae <msdos_dir_stat>:
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
588ae: 4e56 fff4 linkw %fp,#-12
588b2: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
588b6: 2268 0010 moveal %a0@(16),%a1
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
588ba: 48d7 1c00 moveml %a2-%a4,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
588be: 2669 0034 moveal %a1@(52),%a3
fat_file_fd_t *fat_fd = loc->node_access;
588c2: 2850 moveal %a0@,%a4
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
588c4: 42a7 clrl %sp@-
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
588c6: 246e 000c moveal %fp@(12),%a2
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
588ca: 42a7 clrl %sp@-
588cc: 2f2b 0088 movel %a3@(136),%sp@-
588d0: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
588d6: 4fef 000c lea %sp@(12),%sp
588da: 4a80 tstl %d0
588dc: 6710 beqs 588ee <msdos_dir_stat+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
588de: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
588e4: 7205 moveq #5,%d1 <== NOT EXECUTED
588e6: 2040 moveal %d0,%a0 <== NOT EXECUTED
588e8: 70ff moveq #-1,%d0 <== NOT EXECUTED
588ea: 2081 movel %d1,%a0@ <== NOT EXECUTED
588ec: 605a bras 58948 <msdos_dir_stat+0x9a> <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
588ee: 202b 004a movel %a3@(74),%d0
588f2: 222b 004e movel %a3@(78),%d1
buf->st_ino = fat_fd->ino;
588f6: 256c 000c 0008 movel %a4@(12),%a2@(8)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
588fc: 2480 movel %d0,%a2@
588fe: 2541 0004 movel %d1,%a2@(4)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
58902: 223c 0000 41ff movel #16895,%d1
58908: 2541 000c movel %d1,%a2@(12)
buf->st_rdev = 0ll;
5890c: 4280 clrl %d0
5890e: 4281 clrl %d1
58910: 2540 0016 movel %d0,%a2@(22)
58914: 2541 001a movel %d1,%a2@(26)
buf->st_size = fat_fd->fat_file_size;
58918: 202c 0018 movel %a4@(24),%d0
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
5891c: 7209 moveq #9,%d1
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
5891e: 2540 0022 movel %d0,%a2@(34)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
58922: e2a8 lsrl %d1,%d0
58924: 2540 0042 movel %d0,%a2@(66)
buf->st_blksize = fs_info->fat.vol.bps;
58928: 4280 clrl %d0
5892a: 3013 movew %a3@,%d0
buf->st_mtime = fat_fd->mtime;
5892c: 256c 003e 002e movel %a4@(62),%a2@(46)
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
58932: 42aa 001e clrl %a2@(30)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
58936: 2540 003e movel %d0,%a2@(62)
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
5893a: 2f2b 0088 movel %a3@(136),%sp@-
5893e: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return RC_OK;
58944: 588f addql #4,%sp
58946: 4280 clrl %d0
}
58948: 4cee 1c00 fff4 moveml %fp@(-12),%a2-%a4
5894e: 4e5e unlk %fp <== NOT EXECUTED
00058952 <msdos_dir_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
58952: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
58956: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
5895a: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
5895e: 206a 0028 moveal %a2@(40),%a0 <== NOT EXECUTED
int
msdos_dir_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
58962: 242a 0018 movel %a2@(24),%d2 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
58966: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
5896a: 42a7 clrl %sp@- <== NOT EXECUTED
5896c: 42a7 clrl %sp@- <== NOT EXECUTED
5896e: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
58972: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
58978: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5897c: 4a80 tstl %d0 <== NOT EXECUTED
5897e: 6712 beqs 58992 <msdos_dir_sync+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
58980: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
58986: 7405 moveq #5,%d2 <== NOT EXECUTED
58988: 2040 moveal %d0,%a0 <== NOT EXECUTED
5898a: 347c ffff moveaw #-1,%a2 <== NOT EXECUTED
5898e: 2082 movel %d2,%a0@ <== NOT EXECUTED
58990: 601c bras 589ae <msdos_dir_sync+0x5c> <== NOT EXECUTED
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
58992: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58994: 2f2a 0028 movel %a2@(40),%sp@- <== NOT EXECUTED
58998: 4eb9 0005 03b8 jsr 503b8 <fat_file_datasync> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
5899e: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
589a2: 2440 moveal %d0,%a2 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
589a4: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
589aa: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
589ae: 200a movel %a2,%d0 <== NOT EXECUTED
589b0: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
589b6: 4e5e unlk %fp <== NOT EXECUTED
00054eb2 <msdos_eval4make>:
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
54eb2: 4e56 ffbc linkw %fp,#-68
54eb6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
54eba: 246e 000c moveal %fp@(12),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
54ebe: 206a 0010 moveal %a2@(16),%a0
54ec2: 2868 0034 moveal %a0@(52),%a4
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54ec6: 42a7 clrl %sp@-
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
54ec8: 2a6e 0008 moveal %fp@(8),%a5
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54ecc: 42a7 clrl %sp@-
54ece: 2f2c 0088 movel %a4@(136),%sp@-
54ed2: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54ed8: 4fef 000c lea %sp@(12),%sp
54edc: 4a80 tstl %d0
54ede: 6712 beqs 54ef2 <msdos_eval4make+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
54ee0: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
54ee6: 76ff moveq #-1,%d3 <== NOT EXECUTED
54ee8: 7205 moveq #5,%d1 <== NOT EXECUTED
54eea: 2040 moveal %d0,%a0 <== NOT EXECUTED
54eec: 2081 movel %d1,%a0@ <== NOT EXECUTED
54eee: 6000 01f4 braw 550e4 <msdos_eval4make+0x232> <== NOT EXECUTED
if (!pathloc->node_access)
54ef2: 2012 movel %a2@,%d0
54ef4: 6612 bnes 54f08 <msdos_eval4make+0x56> <== ALWAYS TAKEN
{
errno = ENOENT;
54ef6: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
rc = -1;
54efc: 76ff moveq #-1,%d3 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
{
errno = ENOENT;
54efe: 2040 moveal %d0,%a0 <== NOT EXECUTED
54f00: 7002 moveq #2,%d0 <== NOT EXECUTED
54f02: 2080 movel %d0,%a0@ <== NOT EXECUTED
rc = -1;
goto err;
54f04: 6000 01d2 braw 550d8 <msdos_eval4make+0x226> <== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
54f08: 2f00 movel %d0,%sp@-
54f0a: 4eb9 0004 fc44 jsr 4fc44 <fat_file_reopen>
if (rc != RC_OK)
54f10: 588f addql #4,%sp
goto err;
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
54f12: 2600 movel %d0,%d3
if (rc != RC_OK)
54f14: 6600 01c2 bnew 550d8 <msdos_eval4make+0x226>
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
54f18: 2e0e movel %fp,%d7
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
54f1a: 4284 clrl %d4
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
54f1c: 5987 subql #4,%d7
54f1e: 2c3c 0005 5a20 movel #350752,%d6
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
54f24: 2a3c 0005 6b32 movel #355122,%d5
if (rc != RC_OK)
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
54f2a: 240d movel %a5,%d2
54f2c: d484 addl %d4,%d2
54f2e: 2f02 movel %d2,%sp@-
54f30: 4eb9 0005 a2f0 jsr 5a2f0 <strlen>
54f36: 588f addql #4,%sp
54f38: 2046 moveal %d6,%a0
54f3a: 486e fff8 pea %fp@(-8)
54f3e: 2f07 movel %d7,%sp@-
54f40: 2f00 movel %d0,%sp@-
54f42: 2f02 movel %d2,%sp@-
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
54f44: 7402 moveq #2,%d2
if (rc != RC_OK)
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
54f46: 4e90 jsr %a0@
i += token_len;
54f48: 222e fff8 movel %fp@(-8),%d1
fat_fd = pathloc->node_access;
switch (type)
54f4c: 4fef 0010 lea %sp@(16),%sp
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
i += token_len;
54f50: d881 addl %d1,%d4
fat_fd = pathloc->node_access;
54f52: 2652 moveal %a2@,%a3
switch (type)
54f54: b480 cmpl %d0,%d2
54f56: 671c beqs 54f74 <msdos_eval4make+0xc2>
54f58: 6508 bcss 54f62 <msdos_eval4make+0xb0>
54f5a: 4a80 tstl %d0
54f5c: 6700 00fa beqw 55058 <msdos_eval4make+0x1a6>
54f60: 60c8 bras 54f2a <msdos_eval4make+0x78>
54f62: 7403 moveq #3,%d2
54f64: b480 cmpl %d0,%d2
54f66: 6700 00c8 beqw 55030 <msdos_eval4make+0x17e>
54f6a: 7204 moveq #4,%d1 <== NOT EXECUTED
54f6c: b280 cmpl %d0,%d1 <== NOT EXECUTED
54f6e: 66ba bnes 54f2a <msdos_eval4make+0x78> <== NOT EXECUTED
54f70: 6000 00f4 braw 55066 <msdos_eval4make+0x1b4> <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
54f74: 7401 moveq #1,%d2
54f76: b4ab 0010 cmpl %a3@(16),%d2
54f7a: 6600 012c bnew 550a8 <msdos_eval4make+0x1f6>
54f7e: 206a 0010 moveal %a2@(16),%a0
54f82: 2428 001c movel %a0@(28),%d2
}
/*
* Am I at the root of this mounted filesystem?
*/
if (rtems_filesystem_is_root_location(pathloc))
54f86: b7c2 cmpal %d2,%a3
54f88: 6672 bnes 54ffc <msdos_eval4make+0x14a> <== NEVER TAKEN
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
54f8a: 2279 0006 9c40 moveal 69c40 <rtems_current_user_env>,%a1
{
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
54f90: b4a9 0018 cmpl %a1@(24),%d2
54f94: 6794 beqs 54f2a <msdos_eval4make+0x78> <== ALWAYS TAKEN
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
54f96: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
54f9a: 260e movel %fp,%d3 <== NOT EXECUTED
54f9c: 4868 0008 pea %a0@(8) <== NOT EXECUTED
54fa0: 0683 ffff ffe4 addil #-28,%d3 <== NOT EXECUTED
54fa6: 47f9 0005 950c lea 5950c <memcpy>,%a3 <== NOT EXECUTED
54fac: 2f03 movel %d3,%sp@- <== NOT EXECUTED
54fae: 4e93 jsr %a3@ <== NOT EXECUTED
*pathloc = newloc;
54fb0: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
54fb4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
54fb6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
54fb8: 4e93 jsr %a3@ <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
54fba: 2f02 movel %d2,%sp@- <== NOT EXECUTED
54fbc: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
54fc0: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
54fc6: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
54fca: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
54fcc: 6600 010a bnew 550d8 <msdos_eval4make+0x226> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
54fd0: 2f2c 0088 movel %a4@(136),%sp@- <== NOT EXECUTED
54fd4: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(&path[i-token_len],
54fda: 206a 000c moveal %a2@(12),%a0 <== NOT EXECUTED
54fde: 98ae fff8 subl %fp@(-8),%d4 <== NOT EXECUTED
54fe2: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
54fe6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
54fe8: 4875 4800 pea %a5@(00000000,%d4:l) <== NOT EXECUTED
54fec: 2068 0004 moveal %a0@(4),%a0 <== NOT EXECUTED
54ff0: 4e90 jsr %a0@ <== NOT EXECUTED
54ff2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
54ff6: 2600 movel %d0,%d3 <== NOT EXECUTED
54ff8: 6000 00ea braw 550e4 <msdos_eval4make+0x232> <== NOT EXECUTED
pathloc, name);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
54ffc: 2f01 movel %d1,%sp@- <== NOT EXECUTED
54ffe: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
55002: 2045 moveal %d5,%a0 <== NOT EXECUTED
55004: 2f0a movel %a2,%sp@- <== NOT EXECUTED
55006: 4e90 jsr %a0@ <== NOT EXECUTED
if (rc != RC_OK)
55008: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5500c: 4a80 tstl %d0 <== NOT EXECUTED
5500e: 6700 ff1a beqw 54f2a <msdos_eval4make+0x78> <== NOT EXECUTED
55012: 2400 movel %d0,%d2 <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
55014: 0c80 0000 7d01 cmpil #32001,%d0 <== NOT EXECUTED
5501a: 6600 00ac bnew 550c8 <msdos_eval4make+0x216> <== NOT EXECUTED
{
errno = ENOENT;
5501e: 4eb9 0005 8b98 jsr 58b98 <__errno>
55024: 7e02 moveq #2,%d7
55026: 2040 moveal %d0,%a0
55028: 2087 movel %d7,%a0@
rc = -1;
5502a: 74ff moveq #-1,%d2
5502c: 6000 009a braw 550c8 <msdos_eval4make+0x216>
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
55030: 7001 moveq #1,%d0
55032: b0ab 0010 cmpl %a3@(16),%d0
55036: 6670 bnes 550a8 <msdos_eval4make+0x1f6>
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
55038: 2f01 movel %d1,%sp@-
5503a: 2f2e fffc movel %fp@(-4),%sp@-
5503e: 2045 moveal %d5,%a0
55040: 2f0a movel %a2,%sp@-
55042: 4e90 jsr %a0@
if (rc)
55044: 4fef 000c lea %sp@(12),%sp
55048: 4a80 tstl %d0
5504a: 6700 fede beqw 54f2a <msdos_eval4make+0x78>
{
if (rc != MSDOS_NAME_NOT_FOUND_ERR)
5504e: 0c80 0000 7d01 cmpil #32001,%d0
55054: 671e beqs 55074 <msdos_eval4make+0x1c2> <== ALWAYS TAKEN
55056: 60c6 bras 5501e <msdos_eval4make+0x16c> <== NOT EXECUTED
done = true;
}
break;
case MSDOS_NO_MORE_PATH:
errno = EEXIST;
55058: 4eb9 0005 8b98 jsr 58b98 <__errno>
5505e: 7c11 moveq #17,%d6
55060: 2040 moveal %d0,%a0
55062: 2086 movel %d6,%a0@
55064: 60c4 bras 5502a <msdos_eval4make+0x178>
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
55066: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5506c: 7a5b moveq #91,%d5 <== NOT EXECUTED
5506e: 2040 moveal %d0,%a0 <== NOT EXECUTED
55070: 2085 movel %d5,%a0@ <== NOT EXECUTED
55072: 60b6 bras 5502a <msdos_eval4make+0x178> <== NOT EXECUTED
break;
}
}
*name = &path[i - token_len];
55074: 2004 movel %d4,%d0
55076: 90ae fff8 subl %fp@(-8),%d0
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
{
if (!msdos_is_separator(path[i]))
5507a: 243c 0004 6a68 movel #289384,%d2
break;
}
}
*name = &path[i - token_len];
55080: d08d addl %a5,%d0
* RETURNS:
* RC_OK, filled pathloc for parent directory and name of new node on
* success, or -1 if error occured (errno set appropriately)
*/
int
msdos_eval4make(
55082: dbc4 addal %d4,%a5
break;
}
}
*name = &path[i - token_len];
55084: 206e 0010 moveal %fp@(16),%a0
55088: 2080 movel %d0,%a0@
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
5508a: 600e bras 5509a <msdos_eval4make+0x1e8>
{
if (!msdos_is_separator(path[i]))
5508c: 49c0 extbl %d0
5508e: 2042 moveal %d2,%a0
55090: 2f00 movel %d0,%sp@-
55092: 4e90 jsr %a0@
55094: 588f addql #4,%sp
55096: 4a80 tstl %d0
55098: 6784 beqs 5501e <msdos_eval4make+0x16c>
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
5509a: 101d moveb %a5@+,%d0
5509c: 66ee bnes 5508c <msdos_eval4make+0x1da>
rc = -1;
goto error;
}
}
fat_fd = pathloc->node_access;
5509e: 2652 moveal %a2@,%a3
if (fat_fd->fat_file_type != FAT_DIRECTORY)
550a0: 7001 moveq #1,%d0
550a2: b0ab 0010 cmpl %a3@(16),%d0
550a6: 6710 beqs 550b8 <msdos_eval4make+0x206> <== ALWAYS TAKEN
{
errno = ENOTDIR;
550a8: 4eb9 0005 8b98 jsr 58b98 <__errno>
550ae: 7814 moveq #20,%d4
550b0: 2040 moveal %d0,%a0
550b2: 2084 movel %d4,%a0@
550b4: 6000 ff74 braw 5502a <msdos_eval4make+0x178>
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
550b8: 206a 0010 moveal %a2@(16),%a0
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
550bc: 2068 0034 moveal %a0@(52),%a0
550c0: 2568 0080 0008 movel %a0@(128),%a2@(8)
550c6: 6010 bras 550d8 <msdos_eval4make+0x226>
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
550c8: 2f0b movel %a3,%sp@-
550ca: 2f2a 0010 movel %a2@(16),%sp@-
550ce: 2602 movel %d2,%d3
550d0: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close>
550d6: 508f addql #8,%sp
err:
rtems_semaphore_release(fs_info->vol_sema);
550d8: 2f2c 0088 movel %a4@(136),%sp@-
550dc: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
550e2: 588f addql #4,%sp
}
550e4: 2003 movel %d3,%d0
550e6: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
550ec: 4e5e unlk %fp <== NOT EXECUTED
00054cc0 <msdos_eval_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
54cc0: 4e56 ffbc linkw %fp,#-68
54cc4: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
54cc8: 246e 0014 moveal %fp@(20),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
54ccc: 206a 0010 moveal %a2@(16),%a0
54cd0: 2668 0034 moveal %a0@(52),%a3
int i = 0;
int token_len = 0;
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54cd4: 42a7 clrl %sp@-
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
54cd6: 2a2e 0008 movel %fp@(8),%d5
int i = 0;
int token_len = 0;
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54cda: 42a7 clrl %sp@-
54cdc: 2f2b 0088 movel %a3@(136),%sp@-
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
54ce0: 2a6e 000c moveal %fp@(12),%a5
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
rtems_filesystem_location_info_t newloc;
int i = 0;
int token_len = 0;
54ce4: 42ae fff8 clrl %fp@(-8)
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54ce8: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54cee: 4fef 000c lea %sp@(12),%sp
54cf2: 4a80 tstl %d0
54cf4: 6712 beqs 54d08 <msdos_eval_path+0x48> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
54cf6: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
54cfc: 7605 moveq #5,%d3 <== NOT EXECUTED
54cfe: 2040 moveal %d0,%a0 <== NOT EXECUTED
54d00: 2083 movel %d3,%a0@ <== NOT EXECUTED
54d02: 76ff moveq #-1,%d3 <== NOT EXECUTED
54d04: 6000 01a0 braw 54ea6 <msdos_eval_path+0x1e6> <== NOT EXECUTED
if (!pathloc->node_access)
54d08: 2012 movel %a2@,%d0
54d0a: 6612 bnes 54d1e <msdos_eval_path+0x5e> <== ALWAYS TAKEN
{
errno = ENOENT;
54d0c: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
54d12: 7402 moveq #2,%d2 <== NOT EXECUTED
rc = -1;
54d14: 76ff moveq #-1,%d3 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
{
errno = ENOENT;
54d16: 2040 moveal %d0,%a0 <== NOT EXECUTED
54d18: 2082 movel %d2,%a0@ <== NOT EXECUTED
rc = -1;
goto err;
54d1a: 6000 017e braw 54e9a <msdos_eval_path+0x1da> <== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
54d1e: 2f00 movel %d0,%sp@-
54d20: 4eb9 0004 fc44 jsr 4fc44 <fat_file_reopen>
if (rc != RC_OK)
54d26: 588f addql #4,%sp
goto err;
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
54d28: 2600 movel %d0,%d3
if (rc != RC_OK)
54d2a: 6600 016e bnew 54e9a <msdos_eval_path+0x1da>
54d2e: 4284 clrl %d4
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
54d30: 2e3c 0005 5a20 movel #350752,%d7
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
54d36: 2c3c 0005 6b32 movel #355122,%d6
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
54d3c: 486e fff8 pea %fp@(-8)
54d40: 2045 moveal %d5,%a0
54d42: 486e fffc pea %fp@(-4)
pathnamelen -= token_len;
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
54d46: 7403 moveq #3,%d2
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
54d48: 2f0d movel %a5,%sp@-
54d4a: 4870 4800 pea %a0@(00000000,%d4:l)
54d4e: 2047 moveal %d7,%a0
54d50: 4e90 jsr %a0@
pathnamelen -= token_len;
54d52: 222e fff8 movel %fp@(-8),%d1
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
54d56: 4fef 0010 lea %sp@(16),%sp
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
pathnamelen -= token_len;
54d5a: 9bc1 subal %d1,%a5
i += token_len;
54d5c: d881 addl %d1,%d4
fat_fd = pathloc->node_access;
54d5e: 2852 moveal %a2@,%a4
switch (type)
54d60: b480 cmpl %d0,%d2
54d62: 6700 00d2 beqw 54e36 <msdos_eval_path+0x176>
54d66: 143c 0004 moveb #4,%d2
54d6a: b480 cmpl %d0,%d2
54d6c: 6700 00e0 beqw 54e4e <msdos_eval_path+0x18e>
54d70: 143c 0002 moveb #2,%d2
54d74: b480 cmpl %d0,%d2
54d76: 6600 00e4 bnew 54e5c <msdos_eval_path+0x19c>
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
54d7a: 7001 moveq #1,%d0
54d7c: b0ac 0010 cmpl %a4@(16),%d0
54d80: 6600 00bc bnew 54e3e <msdos_eval_path+0x17e>
54d84: 206a 0010 moveal %a2@(16),%a0
54d88: 2428 001c movel %a0@(28),%d2
}
/*
* Am I at the root of this mounted filesystem?
*/
if (rtems_filesystem_is_root_location(pathloc))
54d8c: b9c2 cmpal %d2,%a4
54d8e: 6678 bnes 54e08 <msdos_eval_path+0x148> <== ALWAYS TAKEN
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
54d90: 2279 0006 9c40 moveal 69c40 <rtems_current_user_env>,%a1 <== NOT EXECUTED
{
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
54d96: b4a9 0018 cmpl %a1@(24),%d2 <== NOT EXECUTED
54d9a: 67a0 beqs 54d3c <msdos_eval_path+0x7c> <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
54d9c: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
54da0: 260e movel %fp,%d3 <== NOT EXECUTED
54da2: 4868 0008 pea %a0@(8) <== NOT EXECUTED
54da6: 0683 ffff ffe4 addil #-28,%d3 <== NOT EXECUTED
54dac: 49f9 0005 950c lea 5950c <memcpy>,%a4 <== NOT EXECUTED
54db2: 2f03 movel %d3,%sp@- <== NOT EXECUTED
54db4: 4e94 jsr %a4@ <== NOT EXECUTED
*pathloc = newloc;
54db6: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
54dba: 2f03 movel %d3,%sp@- <== NOT EXECUTED
54dbc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
54dbe: 4e94 jsr %a4@ <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
54dc0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
54dc2: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
54dc6: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
54dcc: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
54dd0: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
54dd2: 6600 00c6 bnew 54e9a <msdos_eval_path+0x1da> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
54dd6: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54dda: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(&(pathname[i-token_len]),
54de0: 226a 000c moveal %a2@(12),%a1 <== NOT EXECUTED
54de4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
54de6: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
54dea: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
54dee: 4875 8800 pea %a5@(00000000,%a0:l) <== NOT EXECUTED
54df2: 9888 subl %a0,%d4 <== NOT EXECUTED
54df4: 2045 moveal %d5,%a0 <== NOT EXECUTED
54df6: 4870 4800 pea %a0@(00000000,%d4:l) <== NOT EXECUTED
54dfa: 2051 moveal %a1@,%a0 <== NOT EXECUTED
54dfc: 4e90 jsr %a0@ <== NOT EXECUTED
54dfe: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
54e02: 2600 movel %d0,%d3 <== NOT EXECUTED
54e04: 6000 00a0 braw 54ea6 <msdos_eval_path+0x1e6> <== NOT EXECUTED
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
54e08: 2f01 movel %d1,%sp@-
54e0a: 2f2e fffc movel %fp@(-4),%sp@-
54e0e: 2046 moveal %d6,%a0
54e10: 2f0a movel %a2,%sp@-
54e12: 4e90 jsr %a0@
if (rc != RC_OK)
54e14: 4fef 000c lea %sp@(12),%sp
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
54e18: 2400 movel %d0,%d2
if (rc != RC_OK)
54e1a: 6700 ff20 beqw 54d3c <msdos_eval_path+0x7c>
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
54e1e: 0c80 0000 7d01 cmpil #32001,%d0
54e24: 6664 bnes 54e8a <msdos_eval_path+0x1ca>
{
errno = ENOENT;
54e26: 4eb9 0005 8b98 jsr 58b98 <__errno>
54e2c: 7202 moveq #2,%d1
54e2e: 2040 moveal %d0,%a0
54e30: 2081 movel %d1,%a0@
rc = -1;
54e32: 74ff moveq #-1,%d2
54e34: 6054 bras 54e8a <msdos_eval_path+0x1ca>
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
54e36: 7001 moveq #1,%d0
54e38: b0ac 0010 cmpl %a4@(16),%d0
54e3c: 67ca beqs 54e08 <msdos_eval_path+0x148>
{
errno = ENOTSUP;
54e3e: 4eb9 0005 8b98 jsr 58b98 <__errno>
54e44: 2040 moveal %d0,%a0
54e46: 20bc 0000 0086 movel #134,%a0@
54e4c: 60e4 bras 54e32 <msdos_eval_path+0x172>
case MSDOS_NO_MORE_PATH:
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
54e4e: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
54e54: 2040 moveal %d0,%a0 <== NOT EXECUTED
54e56: 705b moveq #91,%d0 <== NOT EXECUTED
54e58: 2080 movel %d0,%a0@ <== NOT EXECUTED
54e5a: 60d6 bras 54e32 <msdos_eval_path+0x172> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
54e5c: 4a80 tstl %d0
54e5e: 6708 beqs 54e68 <msdos_eval_path+0x1a8>
54e60: 7204 moveq #4,%d1
54e62: b280 cmpl %d0,%d1
54e64: 6600 fed6 bnew 54d3c <msdos_eval_path+0x7c>
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
54e68: 206a 0010 moveal %a2@(16),%a0
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
54e6c: 7401 moveq #1,%d2
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
54e6e: 2068 0034 moveal %a0@(52),%a0
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
54e72: 2252 moveal %a2@,%a1
54e74: b4a9 0010 cmpl %a1@(16),%d2
54e78: 6608 bnes 54e82 <msdos_eval_path+0x1c2>
loc->handlers = fs_info->directory_handlers;
54e7a: 2568 0080 0008 movel %a0@(128),%a2@(8)
54e80: 6018 bras 54e9a <msdos_eval_path+0x1da>
else
loc->handlers = fs_info->file_handlers;
54e82: 2568 0084 0008 movel %a0@(132),%a2@(8)
54e88: 6010 bras 54e9a <msdos_eval_path+0x1da>
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
54e8a: 2f0c movel %a4,%sp@-
54e8c: 2f2a 0010 movel %a2@(16),%sp@-
54e90: 2602 movel %d2,%d3
54e92: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close>
54e98: 508f addql #8,%sp
err:
rtems_semaphore_release(fs_info->vol_sema);
54e9a: 2f2b 0088 movel %a3@(136),%sp@-
54e9e: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
54ea4: 588f addql #4,%sp
}
54ea6: 2003 movel %d3,%d0
54ea8: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
54eae: 4e5e unlk %fp <== NOT EXECUTED
00055686 <msdos_file_chmod>:
int
msdos_file_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
55686: 4280 clrl %d0 <== NOT EXECUTED
* RC_OK always
*/
int
msdos_file_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
55688: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return RC_OK;
}
5568c: 4e5e unlk %fp <== NOT EXECUTED
00055176 <msdos_file_close>:
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
55176: 4e56 fff0 linkw %fp,#-16
5517a: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
5517e: 246e 0008 moveal %fp@(8),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
55182: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
55186: 286a 0018 moveal %a2@(24),%a4
int
msdos_file_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
5518a: 2668 0034 moveal %a0@(52),%a3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
5518e: 42a7 clrl %sp@-
55190: 42a7 clrl %sp@-
55192: 2f2b 0088 movel %a3@(136),%sp@-
55196: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
5519c: 4fef 000c lea %sp@(12),%sp
551a0: 4a80 tstl %d0
551a2: 6710 beqs 551b4 <msdos_file_close+0x3e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
551a4: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
551aa: 74ff moveq #-1,%d2 <== NOT EXECUTED
551ac: 7205 moveq #5,%d1 <== NOT EXECUTED
551ae: 2040 moveal %d0,%a0 <== NOT EXECUTED
551b0: 2081 movel %d1,%a0@ <== NOT EXECUTED
551b2: 605c bras 55210 <msdos_file_close+0x9a> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
551b4: 4280 clrl %d0
551b6: 102c 0030 moveb %a4@(48),%d0
551ba: 0800 0000 btst #0,%d0
551be: 6634 bnes 551f4 <msdos_file_close+0x7e> <== NEVER TAKEN
551c0: 605a bras 5521c <msdos_file_close+0xa6>
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
551c2: 2f0c movel %a4,%sp@-
551c4: 2f2a 0028 movel %a2@(40),%sp@-
551c8: 4eb9 0005 5c7a jsr 55c7a <msdos_set_file_size>
if (rc != RC_OK)
551ce: 508f addql #8,%sp
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
551d0: 2400 movel %d0,%d2
if (rc != RC_OK)
551d2: 6612 bnes 551e6 <msdos_file_close+0x70> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
551d4: 2f0c movel %a4,%sp@-
551d6: 2f2a 0028 movel %a2@(40),%sp@-
551da: 4eb9 0005 5aee jsr 55aee <msdos_set_dir_wrt_time_and_date>
if (rc != RC_OK)
551e0: 508f addql #8,%sp
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
551e2: 2400 movel %d0,%d2
if (rc != RC_OK)
551e4: 670e beqs 551f4 <msdos_file_close+0x7e> <== ALWAYS TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
551e6: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
551ea: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
551f0: 588f addql #4,%sp <== NOT EXECUTED
551f2: 601c bras 55210 <msdos_file_close+0x9a> <== NOT EXECUTED
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
551f4: 2f0c movel %a4,%sp@-
551f6: 2f2a 0028 movel %a2@(40),%sp@-
551fa: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close>
rtems_semaphore_release(fs_info->vol_sema);
55200: 2f2b 0088 movel %a3@(136),%sp@-
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
55204: 2400 movel %d0,%d2
rtems_semaphore_release(fs_info->vol_sema);
55206: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
5520c: 4fef 000c lea %sp@(12),%sp
}
55210: 2002 movel %d2,%d0
55212: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
55218: 4e5e unlk %fp
5521a: 4e75 rts
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
5521c: 2f0c movel %a4,%sp@-
5521e: 2f2a 0028 movel %a2@(40),%sp@-
55222: 4eb9 0005 5bc8 jsr 55bc8 <msdos_set_first_cluster_num>
if (rc != RC_OK)
55228: 508f addql #8,%sp
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
5522a: 2400 movel %d0,%d2
if (rc != RC_OK)
5522c: 6794 beqs 551c2 <msdos_file_close+0x4c> <== ALWAYS TAKEN
5522e: 60b6 bras 551e6 <msdos_file_close+0x70> <== NOT EXECUTED
00055618 <msdos_file_datasync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
55618: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
5561c: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
55620: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
55624: 206a 0028 moveal %a2@(40),%a0 <== NOT EXECUTED
int
msdos_file_datasync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
55628: 242a 0018 movel %a2@(24),%d2 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
5562c: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
55630: 42a7 clrl %sp@- <== NOT EXECUTED
55632: 42a7 clrl %sp@- <== NOT EXECUTED
55634: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
55638: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
5563e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55642: 4a80 tstl %d0 <== NOT EXECUTED
55644: 6710 beqs 55656 <msdos_file_datasync+0x3e> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
55646: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5564c: 2040 moveal %d0,%a0 <== NOT EXECUTED
5564e: 7005 moveq #5,%d0 <== NOT EXECUTED
55650: 2080 movel %d0,%a0@ <== NOT EXECUTED
55652: 70ff moveq #-1,%d0 <== NOT EXECUTED
55654: 601c bras 55672 <msdos_file_datasync+0x5a> <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
55656: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55658: 2f2a 0028 movel %a2@(40),%sp@- <== NOT EXECUTED
5565c: 4eb9 0005 03b8 jsr 503b8 <fat_file_datasync> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
55662: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
55666: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
5566c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55670: 4280 clrl %d0 <== NOT EXECUTED
}
55672: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
55678: 4e5e unlk %fp <== NOT EXECUTED
000554b6 <msdos_file_ftruncate>:
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
554b6: 4280 clrl %d0
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
554b8: 4e56 ffdc linkw %fp,#-36
554bc: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
554c0: 246e 0008 moveal %fp@(8),%a2
554c4: 242e 000c movel %fp@(12),%d2
554c8: 262e 0010 movel %fp@(16),%d3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
554cc: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
554d0: 266a 0018 moveal %a2@(24),%a3
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
554d4: 2868 0034 moveal %a0@(52),%a4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
554d8: 222b 0018 movel %a3@(24),%d1
554dc: 2802 movel %d2,%d4
554de: 2a03 movel %d3,%d5
554e0: 9a81 subl %d1,%d5
554e2: 9980 subxl %d0,%d4
554e4: 6c66 bges 5554c <msdos_file_ftruncate+0x96>
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
554e6: 42a7 clrl %sp@-
554e8: 42a7 clrl %sp@-
554ea: 2f2c 0088 movel %a4@(136),%sp@-
554ee: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
554f4: 4fef 000c lea %sp@(12),%sp
554f8: 4a80 tstl %d0
554fa: 6710 beqs 5550c <msdos_file_ftruncate+0x56> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
554fc: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
55502: 7405 moveq #5,%d2 <== NOT EXECUTED
55504: 78ff moveq #-1,%d4 <== NOT EXECUTED
55506: 2040 moveal %d0,%a0 <== NOT EXECUTED
55508: 2082 movel %d2,%a0@ <== NOT EXECUTED
5550a: 6042 bras 5554e <msdos_file_ftruncate+0x98> <== NOT EXECUTED
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
5550c: 2f03 movel %d3,%sp@-
5550e: 2f0b movel %a3,%sp@-
55510: 2f2a 0028 movel %a2@(40),%sp@-
55514: 4eb9 0004 fdcc jsr 4fdcc <fat_file_truncate>
if (rc != RC_OK)
5551a: 4fef 000c lea %sp@(12),%sp
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
5551e: 2800 movel %d0,%d4
if (rc != RC_OK)
55520: 661c bnes 5553e <msdos_file_ftruncate+0x88> <== NEVER TAKEN
/*
* fat_file_truncate do nothing if new length >= fat-file size, so update
* file size only if length < fat-file size
*/
if (length < fat_fd->fat_file_size)
55522: 2e2b 0018 movel %a3@(24),%d7
55526: 4286 clrl %d6
55528: 2002 movel %d2,%d0
5552a: 2203 movel %d3,%d1
5552c: 9287 subl %d7,%d1
5552e: 9186 subxl %d6,%d0
55530: 6c0c bges 5553e <msdos_file_ftruncate+0x88> <== NEVER TAKEN
iop->size = fat_fd->fat_file_size = length;
55532: 2743 0018 movel %d3,%a3@(24)
55536: 2543 0008 movel %d3,%a2@(8)
5553a: 42aa 0004 clrl %a2@(4)
rtems_semaphore_release(fs_info->vol_sema);
5553e: 2f2c 0088 movel %a4@(136),%sp@-
55542: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return RC_OK;
55548: 588f addql #4,%sp
5554a: 6002 bras 5554e <msdos_file_ftruncate+0x98>
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
return RC_OK;
5554c: 4284 clrl %d4
if (length < fat_fd->fat_file_size)
iop->size = fat_fd->fat_file_size = length;
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
}
5554e: 2004 movel %d4,%d0
55550: 4cee 1cfc ffdc moveml %fp@(-36),%d2-%d7/%a2-%a4
55556: 4e5e unlk %fp <== NOT EXECUTED
0005567c <msdos_file_ioctl>:
msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer)
{
int rc = RC_OK;
return rc;
}
5567c: 4280 clrl %d0 <== NOT EXECUTED
* RETURNS:
*
*/
int
msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer)
{
5567e: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
int rc = RC_OK;
return rc;
}
55682: 4e5e unlk %fp <== NOT EXECUTED
00055360 <msdos_file_lseek>:
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
55360: 4e56 ffec linkw %fp,#-20
55364: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
55368: 246e 0008 moveal %fp@(8),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
5536c: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
55370: 266a 0018 moveal %a2@(24),%a3
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
55374: 2868 0034 moveal %a0@(52),%a4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
55378: 42a7 clrl %sp@-
5537a: 42a7 clrl %sp@-
5537c: 2f2c 0088 movel %a4@(136),%sp@-
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
55380: 42ae fffc clrl %fp@(-4)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
55384: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
5538a: 4fef 000c lea %sp@(12),%sp
5538e: 4a80 tstl %d0
55390: 6712 beqs 553a4 <msdos_file_lseek+0x44> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
55392: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
55398: 2040 moveal %d0,%a0 <== NOT EXECUTED
5539a: 7005 moveq #5,%d0 <== NOT EXECUTED
5539c: 2080 movel %d0,%a0@ <== NOT EXECUTED
5539e: 70ff moveq #-1,%d0 <== NOT EXECUTED
553a0: 72ff moveq #-1,%d1 <== NOT EXECUTED
553a2: 6064 bras 55408 <msdos_file_lseek+0xa8> <== NOT EXECUTED
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
553a4: 486e fffc pea %fp@(-4)
553a8: 2f2a 0010 movel %a2@(16),%sp@-
553ac: 2f0b movel %a3,%sp@-
553ae: 2f2a 0028 movel %a2@(40),%sp@-
553b2: 4eb9 0005 0014 jsr 50014 <fat_file_extend>
&real_size);
if (rc != RC_OK)
553b8: 4fef 0010 lea %sp@(16),%sp
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
553bc: 2400 movel %d0,%d2
&real_size);
if (rc != RC_OK)
553be: 6712 beqs 553d2 <msdos_file_lseek+0x72> <== ALWAYS TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
553c0: 2f2c 0088 movel %a4@(136),%sp@- <== NOT EXECUTED
553c4: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
553ca: 2202 movel %d2,%d1 <== NOT EXECUTED
553cc: 5bc0 smi %d0 <== NOT EXECUTED
553ce: 49c0 extbl %d0 <== NOT EXECUTED
553d0: 6034 bras 55406 <msdos_file_lseek+0xa6> <== NOT EXECUTED
}
if (real_size > fat_fd->fat_file_size)
553d2: 202e fffc movel %fp@(-4),%d0
553d6: b0ab 0018 cmpl %a3@(24),%d0
553da: 630c blss 553e8 <msdos_file_lseek+0x88> <== ALWAYS TAKEN
fat_fd->fat_file_size = iop->offset = real_size;
553dc: 2540 0010 movel %d0,%a2@(16) <== NOT EXECUTED
553e0: 42aa 000c clrl %a2@(12) <== NOT EXECUTED
553e4: 2740 0018 movel %d0,%a3@(24) <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
553e8: 202b 0018 movel %a3@(24),%d0
553ec: 42aa 0004 clrl %a2@(4)
553f0: 2540 0008 movel %d0,%a2@(8)
rtems_semaphore_release(fs_info->vol_sema);
553f4: 2f2c 0088 movel %a4@(136),%sp@-
553f8: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return iop->offset;
553fe: 202a 000c movel %a2@(12),%d0
55402: 222a 0010 movel %a2@(16),%d1
55406: 588f addql #4,%sp
}
55408: 4cee 1c04 ffec moveml %fp@(-20),%d2/%a2-%a4
5540e: 4e5e unlk %fp <== NOT EXECUTED
000550f0 <msdos_file_open>:
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
550f0: 4e56 fff0 linkw %fp,#-16
550f4: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
550f8: 246e 0008 moveal %fp@(8),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
550fc: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
55100: 286a 0018 moveal %a2@(24),%a4
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
55104: 2668 0034 moveal %a0@(52),%a3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
55108: 42a7 clrl %sp@-
5510a: 42a7 clrl %sp@-
5510c: 2f2b 0088 movel %a3@(136),%sp@-
55110: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
55116: 4fef 000c lea %sp@(12),%sp
5511a: 4a80 tstl %d0
5511c: 6710 beqs 5512e <msdos_file_open+0x3e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
5511e: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
55124: 74ff moveq #-1,%d2 <== NOT EXECUTED
55126: 2040 moveal %d0,%a0 <== NOT EXECUTED
55128: 7005 moveq #5,%d0 <== NOT EXECUTED
5512a: 2080 movel %d0,%a0@ <== NOT EXECUTED
5512c: 603c bras 5516a <msdos_file_open+0x7a> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
5512e: 2f0c movel %a4,%sp@-
55130: 4eb9 0004 fc44 jsr 4fc44 <fat_file_reopen>
if (rc != RC_OK)
55136: 588f addql #4,%sp
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_reopen(fat_fd);
55138: 2400 movel %d0,%d2
if (rc != RC_OK)
5513a: 6622 bnes 5515e <msdos_file_open+0x6e> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
5513c: 222a 0014 movel %a2@(20),%d1
55140: 0281 0000 0200 andil #512,%d1
55146: 202c 0018 movel %a4@(24),%d0
5514a: 4a81 tstl %d1
5514c: 6708 beqs 55156 <msdos_file_open+0x66>
iop->offset = fat_fd->fat_file_size;
5514e: 2540 0010 movel %d0,%a2@(16)
55152: 42aa 000c clrl %a2@(12)
iop->size = fat_fd->fat_file_size;
55156: 2540 0008 movel %d0,%a2@(8)
5515a: 42aa 0004 clrl %a2@(4)
rtems_semaphore_release(fs_info->vol_sema);
5515e: 2f2b 0088 movel %a3@(136),%sp@-
55162: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return RC_OK;
55168: 588f addql #4,%sp
}
5516a: 2002 movel %d2,%d0
5516c: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
55172: 4e5e unlk %fp <== NOT EXECUTED
00055230 <msdos_file_read>:
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
55230: 4e56 fff4 linkw %fp,#-12
55234: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
55238: 246e 0008 moveal %fp@(8),%a2
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
5523c: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
55240: 242a 0018 movel %a2@(24),%d2
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
55244: 2668 0034 moveal %a0@(52),%a3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
55248: 42a7 clrl %sp@-
5524a: 42a7 clrl %sp@-
5524c: 2f2b 0088 movel %a3@(136),%sp@-
55250: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
55256: 4fef 000c lea %sp@(12),%sp
5525a: 4a80 tstl %d0
5525c: 6712 beqs 55270 <msdos_file_read+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
5525e: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
55264: 7405 moveq #5,%d2 <== NOT EXECUTED
55266: 2040 moveal %d0,%a0 <== NOT EXECUTED
55268: 347c ffff moveaw #-1,%a2 <== NOT EXECUTED
5526c: 2082 movel %d2,%a0@ <== NOT EXECUTED
5526e: 6028 bras 55298 <msdos_file_read+0x68> <== NOT EXECUTED
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
55270: 2f2e 000c movel %fp@(12),%sp@-
55274: 2f2e 0010 movel %fp@(16),%sp@-
55278: 2f2a 0010 movel %a2@(16),%sp@-
5527c: 2f02 movel %d2,%sp@-
5527e: 2f2a 0028 movel %a2@(40),%sp@-
55282: 4eb9 0004 fc56 jsr 4fc56 <fat_file_read>
buffer);
rtems_semaphore_release(fs_info->vol_sema);
55288: 2f2b 0088 movel %a3@(136),%sp@-
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
5528c: 2440 moveal %d0,%a2
buffer);
rtems_semaphore_release(fs_info->vol_sema);
5528e: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return ret;
55294: 4fef 0018 lea %sp@(24),%sp
}
55298: 200a movel %a2,%d0
5529a: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
552a0: 4e5e unlk %fp <== NOT EXECUTED
00055690 <msdos_file_rmnod>:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
55690: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
55694: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED
55698: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
5569c: 206a 0010 moveal %a2@(16),%a0 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
556a0: 2852 moveal %a2@,%a4 <== NOT EXECUTED
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
556a2: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
556a6: 42a7 clrl %sp@- <== NOT EXECUTED
556a8: 42a7 clrl %sp@- <== NOT EXECUTED
556aa: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
556ae: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
556b4: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
556b8: 4a80 tstl %d0 <== NOT EXECUTED
556ba: 6710 beqs 556cc <msdos_file_rmnod+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
556bc: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
556c2: 74ff moveq #-1,%d2 <== NOT EXECUTED
556c4: 7205 moveq #5,%d1 <== NOT EXECUTED
556c6: 2040 moveal %d0,%a0 <== NOT EXECUTED
556c8: 2081 movel %d1,%a0@ <== NOT EXECUTED
556ca: 6042 bras 5570e <msdos_file_rmnod+0x7e> <== NOT EXECUTED
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry,
556cc: 4878 00e5 pea e5 <DBL_MANT_DIG+0xb0> <== NOT EXECUTED
556d0: 486c 0020 pea %a4@(32) <== NOT EXECUTED
556d4: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
556d8: 4eb9 0005 5cea jsr 55cea <msdos_set_first_char4file_name> <== NOT EXECUTED
&fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
556de: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry,
556e2: 2400 movel %d0,%d2 <== NOT EXECUTED
&fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
556e4: 670e beqs 556f4 <msdos_file_rmnod+0x64> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
556e6: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
556ea: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
556f0: 588f addql #4,%sp <== NOT EXECUTED
556f2: 601a bras 5570e <msdos_file_rmnod+0x7e> <== NOT EXECUTED
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
556f4: 2f0c movel %a4,%sp@- <== NOT EXECUTED
556f6: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
556fa: 4eb9 0005 035a jsr 5035a <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
55700: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
55704: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
5570a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
5570e: 2002 movel %d2,%d0 <== NOT EXECUTED
55710: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 <== NOT EXECUTED
55716: 4e5e unlk %fp <== NOT EXECUTED
...
00055412 <msdos_file_stat>:
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
55412: 4e56 fff4 linkw %fp,#-12
55416: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
5541a: 2268 0010 moveal %a0@(16),%a1
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
5541e: 48d7 1c00 moveml %a2-%a4,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
55422: 2669 0034 moveal %a1@(52),%a3
fat_file_fd_t *fat_fd = loc->node_access;
55426: 2850 moveal %a0@,%a4
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
55428: 42a7 clrl %sp@-
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
5542a: 246e 000c moveal %fp@(12),%a2
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
5542e: 42a7 clrl %sp@-
55430: 2f2b 0088 movel %a3@(136),%sp@-
55434: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
5543a: 4fef 000c lea %sp@(12),%sp
5543e: 4a80 tstl %d0
55440: 6710 beqs 55452 <msdos_file_stat+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
55442: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
55448: 7205 moveq #5,%d1 <== NOT EXECUTED
5544a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5544c: 70ff moveq #-1,%d0 <== NOT EXECUTED
5544e: 2081 movel %d1,%a0@ <== NOT EXECUTED
55450: 605a bras 554ac <msdos_file_stat+0x9a> <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
55452: 202b 004a movel %a3@(74),%d0
55456: 222b 004e movel %a3@(78),%d1
buf->st_ino = fat_fd->ino;
5545a: 256c 000c 0008 movel %a4@(12),%a2@(8)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
55460: 2480 movel %d0,%a2@
55462: 2541 0004 movel %d1,%a2@(4)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
55466: 223c 0000 81ff movel #33279,%d1
5546c: 2541 000c movel %d1,%a2@(12)
buf->st_rdev = 0ll;
55470: 4280 clrl %d0
55472: 4281 clrl %d1
55474: 2540 0016 movel %d0,%a2@(22)
55478: 2541 001a movel %d1,%a2@(26)
buf->st_size = fat_fd->fat_file_size;
5547c: 202c 0018 movel %a4@(24),%d0
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
55480: 7209 moveq #9,%d1
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
55482: 2540 0022 movel %d0,%a2@(34)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
55486: e2a8 lsrl %d1,%d0
55488: 2540 0042 movel %d0,%a2@(66)
buf->st_blksize = fs_info->fat.vol.bps;
5548c: 4280 clrl %d0
5548e: 3013 movew %a3@,%d0
buf->st_mtime = fat_fd->mtime;
55490: 256c 003e 002e movel %a4@(62),%a2@(46)
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
55496: 42aa 001e clrl %a2@(30)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
5549a: 2540 003e movel %d0,%a2@(62)
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
5549e: 2f2b 0088 movel %a3@(136),%sp@-
554a2: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return RC_OK;
554a8: 588f addql #4,%sp
554aa: 4280 clrl %d0
}
554ac: 4cee 1c00 fff4 moveml %fp@(-12),%a2-%a4
554b2: 4e5e unlk %fp <== NOT EXECUTED
0005555a <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
5555a: 4e56 ffec linkw %fp,#-20 <== NOT EXECUTED
5555e: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ <== NOT EXECUTED
55562: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
55566: 206b 0028 moveal %a3@(40),%a0 <== NOT EXECUTED
int
msdos_file_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
5556a: 286b 0018 moveal %a3@(24),%a4 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
5556e: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
55572: 42a7 clrl %sp@- <== NOT EXECUTED
55574: 42a7 clrl %sp@- <== NOT EXECUTED
55576: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
5557a: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
55580: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55584: 4a80 tstl %d0 <== NOT EXECUTED
55586: 6710 beqs 55598 <msdos_file_sync+0x3e> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
55588: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5558e: 7605 moveq #5,%d3 <== NOT EXECUTED
55590: 74ff moveq #-1,%d2 <== NOT EXECUTED
55592: 2040 moveal %d0,%a0 <== NOT EXECUTED
55594: 2083 movel %d3,%a0@ <== NOT EXECUTED
55596: 6060 bras 555f8 <msdos_file_sync+0x9e> <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
55598: 2f0c movel %a4,%sp@- <== NOT EXECUTED
5559a: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
5559e: 4eb9 0005 03b8 jsr 503b8 <fat_file_datasync> <== NOT EXECUTED
if (rc != RC_OK)
555a4: 508f addql #8,%sp <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
555a6: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
555a8: 6642 bnes 555ec <msdos_file_sync+0x92> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
555aa: 4280 clrl %d0 <== NOT EXECUTED
555ac: 102c 0030 moveb %a4@(48),%d0 <== NOT EXECUTED
555b0: 0800 0000 btst #0,%d0 <== NOT EXECUTED
555b4: 6636 bnes 555ec <msdos_file_sync+0x92> <== NOT EXECUTED
555b6: 604c bras 55604 <msdos_file_sync+0xaa> <== NOT EXECUTED
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
555b8: 2f0c movel %a4,%sp@- <== NOT EXECUTED
555ba: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
555be: 4eb9 0005 5c7a jsr 55c7a <msdos_set_file_size> <== NOT EXECUTED
if (rc != RC_OK)
555c4: 508f addql #8,%sp <== NOT EXECUTED
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
555c6: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
555c8: 6612 bnes 555dc <msdos_file_sync+0x82> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
555ca: 2f0c movel %a4,%sp@- <== NOT EXECUTED
555cc: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
555d0: 4eb9 0005 5aee jsr 55aee <msdos_set_dir_wrt_time_and_date> <== NOT EXECUTED
if (rc != RC_OK)
555d6: 508f addql #8,%sp <== NOT EXECUTED
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
555d8: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
555da: 6710 beqs 555ec <msdos_file_sync+0x92> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
555dc: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
return rc;
555e0: 2403 movel %d3,%d2 <== NOT EXECUTED
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
555e2: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
555e8: 588f addql #4,%sp <== NOT EXECUTED
555ea: 600c bras 555f8 <msdos_file_sync+0x9e> <== NOT EXECUTED
}
}
rtems_semaphore_release(fs_info->vol_sema);
555ec: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
555f0: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
555f6: 588f addql #4,%sp <== NOT EXECUTED
}
555f8: 2002 movel %d2,%d0 <== NOT EXECUTED
555fa: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4 <== NOT EXECUTED
55600: 4e5e unlk %fp <== NOT EXECUTED
55602: 4e75 rts <== NOT EXECUTED
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
55604: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55606: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
5560a: 4eb9 0005 5bc8 jsr 55bc8 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
55610: 508f addql #8,%sp <== NOT EXECUTED
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
55612: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
55614: 67a2 beqs 555b8 <msdos_file_sync+0x5e> <== NOT EXECUTED
55616: 60c4 bras 555dc <msdos_file_sync+0x82> <== NOT EXECUTED
000552a4 <msdos_file_write>:
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
552a4: 4e56 ffd8 linkw %fp,#-40
552a8: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
552ac: 246e 0008 moveal %fp@(8),%a2
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
552b0: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
552b4: 266a 0018 moveal %a2@(24),%a3
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
552b8: 2868 0034 moveal %a0@(52),%a4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
552bc: 42a7 clrl %sp@-
552be: 42a7 clrl %sp@-
552c0: 2f2c 0088 movel %a4@(136),%sp@-
552c4: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
552ca: 4fef 000c lea %sp@(12),%sp
552ce: 4a80 tstl %d0
552d0: 670e beqs 552e0 <msdos_file_write+0x3c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
552d2: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
552d8: 7605 moveq #5,%d3 <== NOT EXECUTED
552da: 2040 moveal %d0,%a0 <== NOT EXECUTED
552dc: 2083 movel %d3,%a0@ <== NOT EXECUTED
552de: 602c bras 5530c <msdos_file_write+0x68> <== NOT EXECUTED
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
552e0: 2f2e 000c movel %fp@(12),%sp@-
552e4: 2f2e 0010 movel %fp@(16),%sp@-
552e8: 2f2a 0010 movel %a2@(16),%sp@-
552ec: 2f0b movel %a3,%sp@-
552ee: 2f2a 0028 movel %a2@(40),%sp@-
552f2: 4eb9 0005 01a2 jsr 501a2 <fat_file_write>
buffer);
if (ret < 0)
552f8: 4fef 0014 lea %sp@(20),%sp
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
552fc: 2400 movel %d0,%d2
buffer);
if (ret < 0)
552fe: 6c10 bges 55310 <msdos_file_write+0x6c> <== ALWAYS TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
55300: 2f2c 0088 movel %a4@(136),%sp@- <== NOT EXECUTED
55304: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return -1;
5530a: 588f addql #4,%sp <== NOT EXECUTED
5530c: 74ff moveq #-1,%d2 <== NOT EXECUTED
5530e: 6044 bras 55354 <msdos_file_write+0xb0> <== NOT EXECUTED
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
if (iop->offset + ret > fat_fd->fat_file_size)
55310: 2a2b 0018 movel %a3@(24),%d5
55314: 4284 clrl %d4
55316: 206a 000c moveal %a2@(12),%a0
5531a: 226a 0010 moveal %a2@(16),%a1
5531e: 2200 movel %d0,%d1
55320: 5bc0 smi %d0
55322: 49c0 extbl %d0
55324: 2608 movel %a0,%d3
55326: d289 addl %a1,%d1
55328: d183 addxl %d3,%d0
5532a: 2c00 movel %d0,%d6
5532c: 2e01 movel %d1,%d7
5532e: 9e85 subl %d5,%d7
55330: 9d84 subxl %d4,%d6
55332: 6f08 bles 5533c <msdos_file_write+0x98>
fat_fd->fat_file_size = iop->offset + ret;
55334: 4bf1 2800 lea %a1@(00000000,%d2:l),%a5
55338: 274d 0018 movel %a5,%a3@(24)
iop->size = fat_fd->fat_file_size;
5533c: 202b 0018 movel %a3@(24),%d0
55340: 42aa 0004 clrl %a2@(4)
55344: 2540 0008 movel %d0,%a2@(8)
rtems_semaphore_release(fs_info->vol_sema);
55348: 2f2c 0088 movel %a4@(136),%sp@-
5534c: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return ret;
55352: 588f addql #4,%sp
}
55354: 2002 movel %d2,%d0
55356: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5
5535c: 4e5e unlk %fp <== NOT EXECUTED
000581d2 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
581d2: 4281 clrl %d1
* Convert a unix filename to a DOS filename. Return -1 if wrong name is
* supplied.
*/
int
msdos_filename_unix2dos(const char *un, int unlen, char *dn)
{
581d4: 4e56 ffe8 linkw %fp,#-24
581d8: 206e 0010 moveal %fp@(16),%a0
581dc: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
581e0: 226e 0008 moveal %fp@(8),%a1
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
581e4: 2448 moveal %a0,%a2
* Convert a unix filename to a DOS filename. Return -1 if wrong name is
* supplied.
*/
int
msdos_filename_unix2dos(const char *un, int unlen, char *dn)
{
581e6: 2648 moveal %a0,%a3
581e8: 202e 000c movel %fp@(12),%d0
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
581ec: 5281 addql #1,%d1
581ee: 740b moveq #11,%d2
dn[i] = ' ';
581f0: 16fc 0020 moveb #32,%a3@+
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
581f4: b481 cmpl %d1,%d2
581f6: 66f4 bnes 581ec <msdos_filename_unix2dos+0x1a>
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
581f8: 762e moveq #46,%d3
581fa: 1211 moveb %a1@,%d1
581fc: 49c1 extbl %d1
581fe: b681 cmpl %d1,%d3
58200: 661a bnes 5821c <msdos_filename_unix2dos+0x4a> <== ALWAYS TAKEN
58202: 7801 moveq #1,%d4 <== NOT EXECUTED
58204: b880 cmpl %d0,%d4 <== NOT EXECUTED
58206: 6608 bnes 58210 <msdos_filename_unix2dos+0x3e> <== NOT EXECUTED
dn[0] = '.';
58208: 10bc 002e moveb #46,%a0@ <== NOT EXECUTED
return 0;
5820c: 6000 00be braw 582cc <msdos_filename_unix2dos+0xfa> <== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
58210: 742e moveq #46,%d2 <== NOT EXECUTED
58212: 1229 0001 moveb %a1@(1),%d1 <== NOT EXECUTED
58216: 49c1 extbl %d1 <== NOT EXECUTED
58218: b481 cmpl %d1,%d2 <== NOT EXECUTED
5821a: 6704 beqs 58220 <msdos_filename_unix2dos+0x4e> <== NOT EXECUTED
5821c: 2209 movel %a1,%d1
5821e: 6016 bras 58236 <msdos_filename_unix2dos+0x64>
58220: 7602 moveq #2,%d3 <== NOT EXECUTED
58222: b680 cmpl %d0,%d3 <== NOT EXECUTED
58224: 66f6 bnes 5821c <msdos_filename_unix2dos+0x4a> <== NOT EXECUTED
dn[0] = '.';
dn[1] = '.';
58226: 782e moveq #46,%d4 <== NOT EXECUTED
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
dn[0] = '.';
58228: 10bc 002e moveb #46,%a0@ <== NOT EXECUTED
dn[1] = '.';
5822c: 1144 0001 moveb %d4,%a0@(1) <== NOT EXECUTED
return 0;
58230: 6000 009a braw 582cc <msdos_filename_unix2dos+0xfa> <== NOT EXECUTED
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
un++;
unlen--;
58234: 5380 subql #1,%d0 <== NOT EXECUTED
58236: 2241 moveal %d1,%a1
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
58238: 4a80 tstl %d0
5823a: 660a bnes 58246 <msdos_filename_unix2dos+0x74> <== ALWAYS TAKEN
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
5823c: 4282 clrl %d2
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
5823e: 47f9 0006 8f76 lea 68f76 <msdos_map>,%a3
58244: 6022 bras 58268 <msdos_filename_unix2dos+0x96>
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
58246: 5281 addql #1,%d1
58248: 762e moveq #46,%d3
5824a: 1411 moveb %a1@,%d2
5824c: 49c2 extbl %d2
5824e: b682 cmpl %d2,%d3
58250: 67e2 beqs 58234 <msdos_filename_unix2dos+0x62> <== NEVER TAKEN
58252: 60e8 bras 5823c <msdos_filename_unix2dos+0x6a>
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
58254: 1633 3800 moveb %a3@(00000000,%d3:l),%d3
58258: 673a beqs 58294 <msdos_filename_unix2dos+0xc2> <== NEVER TAKEN
break;
dn[i] = msdos_map[c];
un++;
5825a: 2209 movel %a1,%d1
unlen--;
5825c: 5380 subql #1,%d0
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
5825e: 5282 addql #1,%d2
58260: 7808 moveq #8,%d4
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
58262: 14c3 moveb %d3,%a2@+
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
58264: b882 cmpl %d2,%d4
58266: 672c beqs 58294 <msdos_filename_unix2dos+0xc2>
58268: 2209 movel %a1,%d1
5826a: 4a80 tstl %d0
5826c: 6726 beqs 58294 <msdos_filename_unix2dos+0xc2>
5826e: 2841 moveal %d1,%a4
58270: 5289 addql #1,%a1
58272: 1614 moveb %a4@,%d3
58274: 671e beqs 58294 <msdos_filename_unix2dos+0xc2> <== NEVER TAKEN
58276: 782e moveq #46,%d4
58278: 0283 0000 00ff andil #255,%d3
5827e: b883 cmpl %d3,%d4
58280: 66d2 bnes 58254 <msdos_filename_unix2dos+0x82> <== ALWAYS TAKEN
58282: 6010 bras 58294 <msdos_filename_unix2dos+0xc2> <== NOT EXECUTED
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
58284: 2241 moveal %d1,%a1
unlen--;
58286: 5380 subql #1,%d0
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
58288: 762e moveq #46,%d3
5828a: 0282 0000 00ff andil #255,%d2
58290: b682 cmpl %d2,%d3
58292: 670c beqs 582a0 <msdos_filename_unix2dos+0xce> <== NEVER TAKEN
58294: 2241 moveal %d1,%a1
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
58296: 4a80 tstl %d0
58298: 6706 beqs 582a0 <msdos_filename_unix2dos+0xce>
5829a: 5281 addql #1,%d1
5829c: 1411 moveb %a1@,%d2
5829e: 66e4 bnes 58284 <msdos_filename_unix2dos+0xb2> <== ALWAYS TAKEN
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
582a0: 7208 moveq #8,%d1
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
if (msdos_map[c] == 0)
582a2: 45f9 0006 8f76 lea 68f76 <msdos_map>,%a2
582a8: 601a bras 582c4 <msdos_filename_unix2dos+0xf2>
582aa: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
582b0: 1432 2800 moveb %a2@(00000000,%d2:l),%d2 <== NOT EXECUTED
582b4: 6716 beqs 582cc <msdos_filename_unix2dos+0xfa> <== NOT EXECUTED
break;
dn[i] = msdos_map[c];
un++;
unlen--;
582b6: 5380 subql #1,%d0 <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
582b8: 780b moveq #11,%d4 <== NOT EXECUTED
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
582ba: 1182 1800 moveb %d2,%a0@(00000000,%d1:l) <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
582be: 5281 addql #1,%d1 <== NOT EXECUTED
582c0: b881 cmpl %d1,%d4 <== NOT EXECUTED
582c2: 6708 beqs 582cc <msdos_filename_unix2dos+0xfa> <== NOT EXECUTED
582c4: 4a80 tstl %d0
582c6: 6704 beqs 582cc <msdos_filename_unix2dos+0xfa> <== ALWAYS TAKEN
582c8: 1419 moveb %a1@+,%d2 <== NOT EXECUTED
582ca: 66de bnes 582aa <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
582cc: 4280 clrl %d0
582ce: 4cd7 1c1c moveml %sp@,%d2-%d4/%a2-%a4
582d2: 4e5e unlk %fp
...
00056b32 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
56b32: 4e56 ffb4 linkw %fp,#-76
56b36: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
56b3a: 266e 0008 moveal %fp@(8),%a3
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56b3e: 45ee ffcc lea %fp@(-52),%a2
/*
* find the node which correspondes to the name in the directory pointed by
* 'parent_loc'
*/
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
56b42: 260e movel %fp,%d3
56b44: 0683 ffff ffec addil #-20,%d3
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
56b4a: 206b 0010 moveal %a3@(16),%a0
56b4e: 2a68 0034 moveal %a0@(52),%a5
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56b52: 4878 0020 pea 20 <OPER2+0xc>
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
56b56: 242e 000c movel %fp@(12),%d2
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56b5a: 42a7 clrl %sp@-
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
56b5c: 286e 0010 moveal %fp@(16),%a4
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56b60: 2f0a movel %a2,%sp@-
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
56b62: 42ae fffc clrl %fp@(-4)
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56b66: 4eb9 0005 957c jsr 5957c <memset>
name_type = msdos_long_to_short (name,
56b6c: 4878 000b pea b <LASTO+0x1>
56b70: 2f0a movel %a2,%sp@-
56b72: 2f0c movel %a4,%sp@-
56b74: 2f02 movel %d2,%sp@-
56b76: 4eb9 0005 58bc jsr 558bc <msdos_long_to_short>
/*
* find the node which correspondes to the name in the directory pointed by
* 'parent_loc'
*/
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
56b7c: 2f0a movel %a2,%sp@-
56b7e: 2f03 movel %d3,%sp@-
56b80: 2f00 movel %d0,%sp@-
56b82: 2f0c movel %a4,%sp@-
56b84: 2f02 movel %d2,%sp@-
56b86: 42a7 clrl %sp@-
56b88: 2f0b movel %a3,%sp@-
56b8a: 4eb9 0005 6a4e jsr 56a4e <msdos_get_name_node>
&dir_pos, node_entry);
if (rc != RC_OK)
56b90: 4fef 0038 lea %sp@(56),%sp
/*
* find the node which correspondes to the name in the directory pointed by
* 'parent_loc'
*/
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
56b94: 2400 movel %d0,%d2
&dir_pos, node_entry);
if (rc != RC_OK)
56b96: 6600 0166 bnew 56cfe <msdos_find_name+0x1cc>
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
56b9a: 4280 clrl %d0
56b9c: 102a 000b moveb %a2@(11),%d0
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
56ba0: 343c 7d01 movew #32001,%d2
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
&dir_pos, node_entry);
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
56ba4: 44c0 movew %d0,%ccr
56ba6: 6b00 0156 bmiw 56cfe <msdos_find_name+0x1cc>
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
56baa: 723f moveq #63,%d1
56bac: c081 andl %d1,%d0
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
&dir_pos, node_entry);
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
56bae: 123c 000f moveb #15,%d1
56bb2: b280 cmpl %d0,%d1
56bb4: 6700 0148 beqw 56cfe <msdos_find_name+0x1cc>
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
56bb8: 486e fffc pea %fp@(-4)
56bbc: 2f03 movel %d3,%sp@-
56bbe: 2f2b 0010 movel %a3@(16),%sp@-
56bc2: 4eb9 0004 fb18 jsr 4fb18 <fat_file_open>
if (rc != RC_OK)
56bc8: 4fef 000c lea %sp@(12),%sp
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
56bcc: 2400 movel %d0,%d2
if (rc != RC_OK)
56bce: 6600 012e bnew 56cfe <msdos_find_name+0x1cc>
return rc;
fat_fd->dir_pos = dir_pos;
56bd2: 4878 0010 pea 10 <INVALID_OPERATION>
56bd6: 286e fffc moveal %fp@(-4),%a4
56bda: 2f03 movel %d3,%sp@-
56bdc: 486c 0020 pea %a4@(32)
56be0: 4eb9 0005 950c jsr 5950c <memcpy>
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
56be6: 4fef 000c lea %sp@(12),%sp
56bea: 7001 moveq #1,%d0
56bec: b0ac 0008 cmpl %a4@(8),%d0
56bf0: 6600 00e6 bnew 56cd8 <msdos_find_name+0x1a6>
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
56bf4: 4281 clrl %d1
56bf6: 4282 clrl %d2
56bf8: 322a 0014 movew %a2@(20),%d1
56bfc: 342a 001a movew %a2@(26),%d2
56c00: 2001 movel %d1,%d0
56c02: e089 lsrl #8,%d1
56c04: e188 lsll #8,%d0
56c06: 8081 orl %d1,%d0
56c08: 2202 movel %d2,%d1
56c0a: e08a lsrl #8,%d2
56c0c: e189 lsll #8,%d1
56c0e: 4840 swap %d0
56c10: 4240 clrw %d0
56c12: 8282 orl %d2,%d1
56c14: 0281 0000 ffff andil #65535,%d1
56c1a: 8081 orl %d1,%d0
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
56c1c: 4281 clrl %d1
56c1e: 322a 0016 movew %a2@(22),%d1
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
56c22: 2940 001c movel %d0,%a4@(28)
56c26: 2001 movel %d1,%d0
56c28: e089 lsrl #8,%d1
56c2a: e188 lsll #8,%d0
56c2c: 8081 orl %d1,%d0
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
56c2e: 4281 clrl %d1
56c30: 3f00 movew %d0,%sp@-
56c32: 4267 clrw %sp@-
56c34: 322a 0018 movew %a2@(24),%d1
56c38: 2001 movel %d1,%d0
56c3a: e089 lsrl #8,%d1
56c3c: e188 lsll #8,%d0
56c3e: 8081 orl %d1,%d0
56c40: 3f00 movew %d0,%sp@-
56c42: 4267 clrw %sp@-
56c44: 4eb9 0005 80ee jsr 580ee <msdos_date_dos2unix>
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
56c4a: 508f addql #8,%sp
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
56c4c: 2940 003e movel %d0,%a4@(62)
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
56c50: 4280 clrl %d0
56c52: 102a 000b moveb %a2@(11),%d0
56c56: 286e fffc moveal %fp@(-4),%a4
56c5a: 0800 0004 btst #4,%d0
56c5e: 6730 beqs 56c90 <msdos_find_name+0x15e>
{
fat_fd->fat_file_type = FAT_DIRECTORY;
56c60: 7201 moveq #1,%d1
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
56c62: 7020 moveq #32,%d0
56c64: 4840 swap %d0
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
56c66: 2941 0010 movel %d1,%a4@(16)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
56c6a: 2940 0014 movel %d0,%a4@(20)
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
56c6e: 2f0c movel %a4,%sp@-
56c70: 2f2b 0010 movel %a3@(16),%sp@-
56c74: 4eb9 0005 04a6 jsr 504a6 <fat_file_size>
if (rc != RC_OK)
56c7a: 508f addql #8,%sp
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
56c7c: 2400 movel %d0,%d2
if (rc != RC_OK)
56c7e: 672a beqs 56caa <msdos_find_name+0x178> <== ALWAYS TAKEN
{
fat_file_close(parent_loc->mt_entry, fat_fd);
56c80: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56c84: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
56c88: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
56c8e: 6066 bras 56cf6 <msdos_find_name+0x1c4> <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
56c90: 2f2a 001c movel %a2@(28),%sp@-
56c94: 4eba eb4a jsr %pc@(557e0 <m68k_swap_u32>)
56c98: 588f addql #4,%sp
fat_fd->fat_file_type = FAT_FILE;
56c9a: 7205 moveq #5,%d1
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
56c9c: 2940 0018 movel %d0,%a4@(24)
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
56ca0: 70ff moveq #-1,%d0
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
fat_fd->fat_file_type = FAT_FILE;
56ca2: 2941 0010 movel %d1,%a4@(16)
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
56ca6: 2940 0014 movel %d0,%a4@(20)
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
56caa: 206e fffc moveal %fp@(-4),%a0
fat_fd->map.disk_cln = fat_fd->cln;
56cae: 2028 001c movel %a0@(28),%d0
if ((fat_fd->fat_file_size != 0) &&
56cb2: 2228 0018 movel %a0@(24),%d1
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
56cb6: 42a8 0032 clrl %a0@(50)
fat_fd->map.disk_cln = fat_fd->cln;
56cba: 2140 0036 movel %d0,%a0@(54)
if ((fat_fd->fat_file_size != 0) &&
56cbe: 4a81 tstl %d1
56cc0: 6710 beqs 56cd2 <msdos_find_name+0x1a0>
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
56cc2: 4282 clrl %d2
56cc4: 342d 0006 movew %a5@(6),%d2
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
56cc8: b481 cmpl %d1,%d2
56cca: 6506 bcss 56cd2 <msdos_find_name+0x1a0> <== NEVER TAKEN
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
{
fat_fd->map.last_cln = fat_fd->cln;
56ccc: 2140 003a movel %d0,%a0@(58)
56cd0: 6006 bras 56cd8 <msdos_find_name+0x1a6>
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
56cd2: 72ff moveq #-1,%d1
56cd4: 2141 003a movel %d1,%a0@(58)
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
56cd8: 2f13 movel %a3@,%sp@-
56cda: 45f9 0004 feb6 lea 4feb6 <fat_file_close>,%a2
56ce0: 2f2b 0010 movel %a3@(16),%sp@-
56ce4: 4e92 jsr %a2@
if (rc != RC_OK)
56ce6: 508f addql #8,%sp
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
56ce8: 2400 movel %d0,%d2
if (rc != RC_OK)
56cea: 670e beqs 56cfa <msdos_find_name+0x1c8> <== ALWAYS TAKEN
{
fat_file_close(parent_loc->mt_entry, fat_fd);
56cec: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56cf0: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
56cf4: 4e92 jsr %a2@ <== NOT EXECUTED
return rc;
56cf6: 508f addql #8,%sp <== NOT EXECUTED
56cf8: 6004 bras 56cfe <msdos_find_name+0x1cc> <== NOT EXECUTED
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
56cfa: 26ae fffc movel %fp@(-4),%a3@
return rc;
}
56cfe: 2002 movel %d2,%d0
56d00: 4cee 3c0c ffb4 moveml %fp@(-76),%d2-%d3/%a2-%a5
56d06: 4e5e unlk %fp
...
00055f0a <msdos_find_name_in_fat_file>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
55f0a: 4e56 ff94 linkw %fp,#-108
55f0e: 122e 0013 moveb %fp@(19),%d1
55f12: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
55f16: 2a6e 0008 moveal %fp@(8),%a5
55f1a: 246e 000c moveal %fp@(12),%a2
55f1e: 266e 0020 moveal %fp@(32),%a3
55f22: 286e 0024 moveal %fp@(36),%a4
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55f26: 282d 0034 movel %a5@(52),%d4
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
55f2a: 1d41 ffec moveb %d1,%fp@(-20)
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
55f2e: 4aae 0018 tstl %fp@(24)
55f32: 6e14 bgts 55f48 <msdos_find_name_in_fat_file+0x3e><== ALWAYS TAKEN
55f34: 4879 0006 8ef9 pea 68ef9 <msdos_file_handlers+0xcf> <== NOT EXECUTED
55f3a: 4879 0006 8f2f pea 68f2f <__FUNCTION__.7135> <== NOT EXECUTED
55f40: 4878 0419 pea 419 <DBL_MAX_EXP+0x18> <== NOT EXECUTED
55f44: 6000 00ae braw 55ff4 <msdos_find_name_in_fat_file+0xea><== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
55f48: 74ff moveq #-1,%d2
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
55f4a: 4293 clrl %a3@
dir_pos->sname.ofs = 0;
55f4c: 42ab 0004 clrl %a3@(4)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
55f50: 2742 0008 movel %d2,%a3@(8)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
55f54: 2742 000c movel %d2,%a3@(12)
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
55f58: 2d42 fff8 movel %d2,%fp@(-8)
55f5c: 2d42 fff4 movel %d2,%fp@(-12)
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
55f60: 4a2e ffec tstb %fp@(-20)
55f64: 6708 beqs 55f6e <msdos_find_name_in_fat_file+0x64>
55f66: 7601 moveq #1,%d3
55f68: b6ae 001c cmpl %fp@(28),%d3
55f6c: 6712 beqs 55f80 <msdos_find_name_in_fat_file+0x76>
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
55f6e: 262e 0018 movel %fp@(24),%d3
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
55f72: 7c0d moveq #13,%d6
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
55f74: 0683 0000 000c addil #12,%d3
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
55f7a: 4c46 3803 remsl %d6,%d3,%d3
55f7e: 6002 bras 55f82 <msdos_find_name_in_fat_file+0x78>
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
55f80: 4283 clrl %d3
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
55f82: 7e01 moveq #1,%d7
55f84: beaa 0020 cmpl %a2@(32),%d7
55f88: 661a bnes 55fa4 <msdos_find_name_in_fat_file+0x9a>
55f8a: 4aaa 0024 tstl %a2@(36)
55f8e: 6614 bnes 55fa4 <msdos_find_name_in_fat_file+0x9a><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
55f90: 2044 moveal %d4,%a0
55f92: 4280 clrl %d0
55f94: 1028 000a moveb %a0@(10),%d0
55f98: 7203 moveq #3,%d1
55f9a: c081 andl %d1,%d0
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
55f9c: 6706 beqs 55fa4 <msdos_find_name_in_fat_file+0x9a><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
55f9e: 242a 0018 movel %a2@(24),%d2
55fa2: 6008 bras 55fac <msdos_find_name_in_fat_file+0xa2>
else
bts2rd = fs_info->fat.vol.bpc;
55fa4: 2044 moveal %d4,%a0
55fa6: 4282 clrl %d2
55fa8: 3428 0006 movew %a0@(6),%d2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
55fac: 2043 moveal %d3,%a0
55fae: 5288 addql #1,%a0
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
55fb0: 4285 clrl %d5
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
55fb2: 4287 clrl %d7
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
55fb4: 4201 clrb %d1
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
55fb6: 4206 clrb %d6
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
55fb8: 42ae ffe0 clrl %fp@(-32)
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
55fbc: 1d41 ffce moveb %d1,%fp@(-50)
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
55fc0: 42ae ffe4 clrl %fp@(-28)
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
55fc4: 1d46 ffd2 moveb %d6,%fp@(-46)
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
55fc8: 42ae ffe8 clrl %fp@(-24)
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
55fcc: 42ae fff0 clrl %fp@(-16)
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
55fd0: 2d48 ffc2 movel %a0,%fp@(-62)
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
55fd4: 6000 030e braw 562e4 <msdos_find_name_in_fat_file+0x3da>
bool remainder_empty = false;
#if MSDOS_FIND_PRINT
printf ("MSFS:[2] dir_offset:%li\n", dir_offset);
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
55fd8: 7c1f moveq #31,%d6
55fda: bc80 cmpl %d0,%d6
55fdc: 6c00 0690 bgew 5666e <msdos_find_name_in_fat_file+0x764>
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
55fe0: b480 cmpl %d0,%d2
55fe2: 671c beqs 56000 <msdos_find_name_in_fat_file+0xf6><== ALWAYS TAKEN
55fe4: 4879 0006 8f06 pea 68f06 <msdos_file_handlers+0xdc> <== NOT EXECUTED
55fea: 4879 0006 8f2f pea 68f2f <__FUNCTION__.7135> <== NOT EXECUTED
55ff0: 4878 0449 pea 449 <DBL_MAX_EXP+0x48> <== NOT EXECUTED
55ff4: 4879 0006 8e97 pea 68e97 <msdos_file_handlers+0x6d> <== NOT EXECUTED
55ffa: 4eb9 0005 2244 jsr 52244 <__assert_func> <== NOT EXECUTED
56000: 4286 clrl %d6
56002: 1d41 ffdb moveb %d1,%fp@(-37)
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
56006: 2044 moveal %d4,%a0
56008: 2268 008c moveal %a0@(140),%a1
5600c: d3c6 addal %d6,%a1
/*
* See if the entry is empty or the remainder of the directory is
* empty ? Localise to make the code read better.
*/
bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
5600e: 1d51 ffdc moveb %a1@,%fp@(-36)
* to here and write the long file name if this is the start of
* a series of empty entries. If empty_space_count is 0 then
* we are currently not inside an empty series of entries. It
* is a count of empty entries.
*/
if (empty_space_count == 0)
56012: 4a85 tstl %d5
56014: 660c bnes 56022 <msdos_find_name_in_fat_file+0x118><== NEVER TAKEN
56016: 222e fff0 movel %fp@(-16),%d1
5601a: 2d46 ffe4 movel %d6,%fp@(-28)
5601e: 2d41 ffe8 movel %d1,%fp@(-24)
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
56022: 4a2e ffdc tstb %fp@(-36)
56026: 6624 bnes 5604c <msdos_find_name_in_fat_file+0x142>
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
56028: 2e3c 0000 7d01 movel #32001,%d7
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
5602e: 4a2e ffec tstb %fp@(-20)
56032: 6700 0664 beqw 56698 <msdos_find_name_in_fat_file+0x78e>
* Lets go and write the directory entries. If we have not found
* any available space add the remaining number of entries to any that
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
56036: 4a2e ffce tstb %fp@(-50)
5603a: 6600 02de bnew 5631a <msdos_find_name_in_fat_file+0x410>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
5603e: 2002 movel %d2,%d0
56040: ea88 lsrl #5,%d0
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56042: da80 addl %d0,%d5
56044: ea8e lsrl #5,%d6
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
56046: 9a86 subl %d6,%d5
56048: 6000 02d0 braw 5631a <msdos_find_name_in_fat_file+0x410>
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
5604c: 4280 clrl %d0
5604e: 102e ffdc moveb %fp@(-36),%d0
56052: 2040 moveal %d0,%a0
56054: b1fc 0000 00e5 cmpal #229,%a0
5605a: 6616 bnes 56072 <msdos_find_name_in_fat_file+0x168><== ALWAYS TAKEN
{
if (create_node)
5605c: 4a2e ffec tstb %fp@(-20) <== NOT EXECUTED
56060: 6700 026a beqw 562cc <msdos_find_name_in_fat_file+0x3c2><== NOT EXECUTED
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
56064: 5285 addql #1,%d5 <== NOT EXECUTED
if (empty_space_count == (lfn_entries + 1))
56066: baae ffc2 cmpl %fp@(-62),%d5 <== NOT EXECUTED
5606a: 6600 0260 bnew 562cc <msdos_find_name_in_fat_file+0x3c2><== NOT EXECUTED
5606e: 6000 0246 braw 562b6 <msdos_find_name_in_fat_file+0x3ac><== NOT EXECUTED
* A valid entry so handle it.
*
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
56072: 4a2e ffec tstb %fp@(-20)
56076: 670c beqs 56084 <msdos_find_name_in_fat_file+0x17a>
56078: 4a2e ffce tstb %fp@(-50)
5607c: 6606 bnes 56084 <msdos_find_name_in_fat_file+0x17a><== NEVER TAKEN
{
empty_space_entry = 0;
empty_space_count = 0;
5607e: 4285 clrl %d5
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
{
empty_space_entry = 0;
56080: 42ae ffe4 clrl %fp@(-28)
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
56084: 4281 clrl %d1
56086: 1229 000b moveb %a1@(11),%d1
5608a: 703f moveq #63,%d0
5608c: c280 andl %d0,%d1
5608e: 2041 moveal %d1,%a0
56090: 720f moveq #15,%d1
56092: b288 cmpl %a0,%d1
56094: 6600 0118 bnew 561ae <msdos_find_name_in_fat_file+0x2a4>
#endif
/*
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
56098: 70ff moveq #-1,%d0
5609a: b0ae fff4 cmpl %fp@(-12),%d0
5609e: 6636 bnes 560d6 <msdos_find_name_in_fat_file+0x1cc>
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
560a0: 4280 clrl %d0
560a2: 102e ffdc moveb %fp@(-36),%d0
560a6: 0800 0006 btst #6,%d0
560aa: 6700 0212 beqw 562be <msdos_find_name_in_fat_file+0x3b4>
* entry match the number we expect for this
* file name. Note we do not know the number of
* characters in the entry so this is check further
* on when the characters are checked.
*/
if (lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
560ae: 123c 003f moveb #63,%d1
560b2: c081 andl %d1,%d0
560b4: b083 cmpl %d3,%d0
560b6: 6600 020e bnew 562c6 <msdos_find_name_in_fat_file+0x3bc>
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
560ba: 2e2e fff0 movel %fp@(-16),%d7
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
560be: 1229 000d moveb %a1@(13),%d1
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
560c2: 4200 clrb %d0
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
560c4: 2d47 fff4 movel %d7,%fp@(-12)
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
560c8: 2e03 movel %d3,%d7
560ca: 1d41 ffd2 moveb %d1,%fp@(-46)
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
lfn_start.ofs = dir_entry;
560ce: 2d46 fff8 movel %d6,%fp@(-8)
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
560d2: 1d40 ffdb moveb %d0,%fp@(-37)
* If the entry number or the check sum do not match
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
560d6: 4280 clrl %d0
560d8: 1011 moveb %a1@,%d0
560da: 723f moveq #63,%d1
560dc: c081 andl %d1,%d0
560de: b087 cmpl %d7,%d0
560e0: 6610 bnes 560f2 <msdos_find_name_in_fat_file+0x1e8><== NEVER TAKEN
MSDOS_LAST_LONG_ENTRY_MASK)) ||
560e2: 4280 clrl %d0
560e4: 102e ffd2 moveb %fp@(-46),%d0
560e8: 2040 moveal %d0,%a0
560ea: 1029 000d moveb %a1@(13),%d0
560ee: b088 cmpl %a0,%d0
560f0: 670a beqs 560fc <msdos_find_name_in_fat_file+0x1f2><== ALWAYS TAKEN
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
560f2: 72ff moveq #-1,%d1 <== NOT EXECUTED
560f4: 2d41 fff4 movel %d1,%fp@(-12) <== NOT EXECUTED
continue;
560f8: 6000 01d2 braw 562cc <msdos_find_name_in_fat_file+0x3c2><== NOT EXECUTED
}
lfn_entry--;
560fc: 2047 moveal %d7,%a0
560fe: 5388 subql #1,%a0
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
56100: 2008 movel %a0,%d0
56102: 720d moveq #13,%d1
56104: 4c01 0800 mulsl %d1,%d0
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
56108: 2d48 ffdc movel %a0,%fp@(-36)
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
5610c: 91c8 subal %a0,%a0
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
5610e: 2d40 ffd6 movel %d0,%fp@(-42)
p = entry + 1;
56112: 2009 movel %a1,%d0
56114: 5280 addql #1,%d0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
56116: 226e 0014 moveal %fp@(20),%a1
5611a: d3ee ffd6 addal %fp@(-42),%a1
5611e: 2d49 ffc6 movel %a1,%fp@(-58)
56122: 2240 moveal %d0,%a1
56124: 2d4a ffca movel %a2,%fp@(-54)
{
#if MSDOS_FIND_PRINT > 1
printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
o, i, *p, *p, name[o + i], name[o + i]);
#endif
if (*p == '\0')
56128: 1011 moveb %a1@,%d0
5612a: 6614 bnes 56140 <msdos_find_name_in_fat_file+0x236>
5612c: 246e ffca moveal %fp@(-54),%a2
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
56130: b687 cmpl %d7,%d3
56132: 6658 bnes 5618c <msdos_find_name_in_fat_file+0x282><== NEVER TAKEN
((o + i) != name_len))
56134: d1ee ffd6 addal %fp@(-42),%a0
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
56138: b1ee 0018 cmpal %fp@(24),%a0
5613c: 6622 bnes 56160 <msdos_find_name_in_fat_file+0x256><== NEVER TAKEN
5613e: 604c bras 5618c <msdos_find_name_in_fat_file+0x282>
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
56140: 222e ffd6 movel %fp@(-42),%d1
56144: d288 addl %a0,%d1
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
56146: b2ae 0018 cmpl %fp@(24),%d1
5614a: 6c10 bges 5615c <msdos_find_name_in_fat_file+0x252>
5614c: 246e ffc6 moveal %fp@(-58),%a2
56150: 49c0 extbl %d0
56152: 1232 8800 moveb %a2@(00000000,%a0:l),%d1
56156: 49c1 extbl %d1
56158: b280 cmpl %d0,%d1
5615a: 670c beqs 56168 <msdos_find_name_in_fat_file+0x25e>
5615c: 246e ffca moveal %fp@(-54),%a2
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
56160: 70ff moveq #-1,%d0
56162: 2d40 fff4 movel %d0,%fp@(-12)
break;
56166: 6024 bras 5618c <msdos_find_name_in_fat_file+0x282>
}
switch (i)
56168: 7204 moveq #4,%d1
5616a: b288 cmpl %a0,%d1
5616c: 6708 beqs 56176 <msdos_find_name_in_fat_file+0x26c>
5616e: 700a moveq #10,%d0
56170: b088 cmpl %a0,%d0
56172: 660a bnes 5617e <msdos_find_name_in_fat_file+0x274>
56174: 6004 bras 5617a <msdos_find_name_in_fat_file+0x270>
{
case 4:
p += 5;
56176: 5a89 addql #5,%a1
break;
56178: 6006 bras 56180 <msdos_find_name_in_fat_file+0x276>
case 10:
p += 4;
5617a: 5889 addql #4,%a1
break;
5617c: 6002 bras 56180 <msdos_find_name_in_fat_file+0x276>
default:
p += 2;
5617e: 5489 addql #2,%a1
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
56180: 5288 addql #1,%a0
56182: 720d moveq #13,%d1
56184: b288 cmpl %a0,%d1
56186: 66a0 bnes 56128 <msdos_find_name_in_fat_file+0x21e>
56188: 246e ffca moveal %fp@(-54),%a2
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
5618c: 4aae ffdc tstl %fp@(-36)
56190: 660e bnes 561a0 <msdos_find_name_in_fat_file+0x296>
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
56192: 7eff moveq #-1,%d7
56194: beae fff4 cmpl %fp@(-12),%d7
56198: 56c1 sne %d1
5619a: 49c1 extbl %d1
5619c: 4481 negl %d1
5619e: 6002 bras 561a2 <msdos_find_name_in_fat_file+0x298>
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
561a0: 4281 clrl %d1
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
561a2: 2e2e ffdc movel %fp@(-36),%d7
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
561a6: 1d41 ffdb moveb %d1,%fp@(-37)
561aa: 6000 0120 braw 562cc <msdos_find_name_in_fat_file+0x3c2>
* If a LFN has been found and it matched check the
* entries have all been found and the checksum is
* correct. If this is the case return the short file
* name entry.
*/
if (lfn_matched)
561ae: 4a2e ffdb tstb %fp@(-37)
561b2: 674a beqs 561fe <msdos_find_name_in_fat_file+0x2f4>
561b4: 2049 moveal %a1,%a0
561b6: 700b moveq #11,%d0
561b8: 4201 clrb %d1
561ba: 2d42 ffca movel %d2,%fp@(-54)
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
561be: 0281 0000 00ff andil #255,%d1
561c4: 0801 0000 btst #0,%d1
561c8: 6704 beqs 561ce <msdos_find_name_in_fat_file+0x2c4>
561ca: 7480 moveq #-128,%d2
561cc: 6002 bras 561d0 <msdos_find_name_in_fat_file+0x2c6>
561ce: 4202 clrb %d2
561d0: e289 lsrl #1,%d1
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
561d2: 5380 subql #1,%d0
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
561d4: 1d42 ffdf moveb %d2,%fp@(-33)
561d8: 1418 moveb %a0@+,%d2
561da: d282 addl %d2,%d1
561dc: 142e ffdf moveb %fp@(-33),%d2
561e0: d282 addl %d2,%d1
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
561e2: 4a80 tstl %d0
561e4: 66d8 bnes 561be <msdos_find_name_in_fat_file+0x2b4>
561e6: 242e ffca movel %fp@(-54),%d2
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
561ea: 4a87 tstl %d7
561ec: 6610 bnes 561fe <msdos_find_name_in_fat_file+0x2f4><== NEVER TAKEN
561ee: 4280 clrl %d0
561f0: 102e ffd2 moveb %fp@(-46),%d0
561f4: 0281 0000 00ff andil #255,%d1
561fa: b280 cmpl %d0,%d1
561fc: 6732 beqs 56230 <msdos_find_name_in_fat_file+0x326><== ALWAYS TAKEN
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
561fe: 7001 moveq #1,%d0
56200: b0ae 001c cmpl %fp@(28),%d0
56204: 6600 00a8 bnew 562ae <msdos_find_name_in_fat_file+0x3a4>
((name_type == MSDOS_NAME_SHORT) &&
56208: 72ff moveq #-1,%d1
5620a: b2ae fff4 cmpl %fp@(-12),%d1
5620e: 6600 009e bnew 562ae <msdos_find_name_in_fat_file+0x3a4>
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
56212: 4878 000b pea b <LASTO+0x1>
56216: 2f0c movel %a4,%sp@-
56218: 2d49 ffbe movel %a1,%fp@(-66)
5621c: 2f09 movel %a1,%sp@-
5621e: 4eb9 0005 9484 jsr 59484 <memcmp>
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
56224: 226e ffbe moveal %fp@(-66),%a1
(memcmp(MSDOS_DIR_NAME(entry),
56228: 4fef 000c lea %sp@(12),%sp
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
5622c: 4a80 tstl %d0
5622e: 667e bnes 562ae <msdos_find_name_in_fat_file+0x3a4>
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
56230: 2f0b movel %a3,%sp@-
56232: 2f2e ffe0 movel %fp@(-32),%sp@-
56236: 4878 0001 pea 1 <ADD>
5623a: 263c 0004 ff7c movel #327548,%d3
56240: 2043 moveal %d3,%a0
56242: 2f0a movel %a2,%sp@-
56244: 2d49 ffbe movel %a1,%fp@(-66)
56248: 2f0d movel %a5,%sp@-
5624a: 4e90 jsr %a0@
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
5624c: 226e ffbe moveal %fp@(-66),%a1
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
56250: 2e00 movel %d0,%d7
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
56252: 4fef 0014 lea %sp@(20),%sp
56256: 6600 0440 bnew 56698 <msdos_find_name_in_fat_file+0x78e>
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
5625a: 202e fff4 movel %fp@(-12),%d0
5625e: 72ff moveq #-1,%d1
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
56260: 2746 0004 movel %d6,%a3@(4)
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
56264: b280 cmpl %d0,%d1
56266: 6724 beqs 5628c <msdos_find_name_in_fat_file+0x382>
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
56268: 486e fff4 pea %fp@(-12)
5626c: 4c00 2800 mulsl %d0,%d2
56270: 2043 moveal %d3,%a0
56272: 2f02 movel %d2,%sp@-
56274: 4878 0001 pea 1 <ADD>
56278: 2f0a movel %a2,%sp@-
5627a: 2f0d movel %a5,%sp@-
5627c: 4e90 jsr %a0@
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
5627e: 226e ffbe moveal %fp@(-66),%a1
56282: 4fef 0014 lea %sp@(20),%sp
56286: 4a80 tstl %d0
56288: 6600 0408 bnew 56692 <msdos_find_name_in_fat_file+0x788>
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
5628c: 276e fff4 0008 movel %fp@(-12),%a3@(8)
dir_pos->lname.ofs = lfn_start.ofs;
56292: 276e fff8 000c movel %fp@(-8),%a3@(12)
memcpy(name_dir_entry, entry,
56298: 4878 0020 pea 20 <OPER2+0xc>
5629c: 2f09 movel %a1,%sp@-
5629e: 2f0c movel %a4,%sp@-
562a0: 4eb9 0005 950c jsr 5950c <memcpy>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
562a6: 4fef 000c lea %sp@(12),%sp
562aa: 6000 03ec braw 56698 <msdos_find_name_in_fat_file+0x78e>
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
562ae: 70ff moveq #-1,%d0
562b0: 2d40 fff4 movel %d0,%fp@(-12)
562b4: 6010 bras 562c6 <msdos_find_name_in_fat_file+0x3bc>
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
562b6: 7201 moveq #1,%d1 <== NOT EXECUTED
562b8: 1d41 ffce moveb %d1,%fp@(-50) <== NOT EXECUTED
562bc: 600e bras 562cc <msdos_find_name_in_fat_file+0x3c2><== NOT EXECUTED
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
562be: 4200 clrb %d0
562c0: 1d40 ffdb moveb %d0,%fp@(-37)
562c4: 6006 bras 562cc <msdos_find_name_in_fat_file+0x3c2>
562c6: 4201 clrb %d1
562c8: 1d41 ffdb moveb %d1,%fp@(-37)
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
562cc: 0686 0000 0020 addil #32,%d6
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
562d2: b486 cmpl %d6,%d2
562d4: 6200 fd30 bhiw 56006 <msdos_find_name_in_fat_file+0xfc>
562d8: d5ae ffe0 addl %d2,%fp@(-32) <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
562dc: 52ae fff0 addql #1,%fp@(-16) <== NOT EXECUTED
562e0: 122e ffdb moveb %fp@(-37),%d1 <== NOT EXECUTED
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
562e4: 2044 moveal %d4,%a0
562e6: 2f28 008c movel %a0@(140),%sp@-
562ea: 2f02 movel %d2,%sp@-
562ec: 2f2e ffe0 movel %fp@(-32),%sp@-
562f0: 2f0a movel %a2,%sp@-
562f2: 2d41 ffbe movel %d1,%fp@(-66)
562f6: 2f0d movel %a5,%sp@-
562f8: 4eb9 0004 fc56 jsr 4fc56 <fat_file_read>
562fe: 222e ffbe movel %fp@(-66),%d1
56302: 4fef 0014 lea %sp@(20),%sp
56306: 4a80 tstl %d0
56308: 6600 fcce bnew 55fd8 <msdos_find_name_in_fat_file+0xce>
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
5630c: 2e3c 0000 7d01 movel #32001,%d7 <== NOT EXECUTED
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
56312: 4a2e ffec tstb %fp@(-20) <== NOT EXECUTED
56316: 6700 0380 beqw 56698 <msdos_find_name_in_fat_file+0x78e><== NOT EXECUTED
* data to place in each long file name entry. First set the short
* file name to the slot of the SFN entry. This will mean no clashes
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
5631a: 7002 moveq #2,%d0
5631c: b0ae 001c cmpl %fp@(28),%d0
56320: 6672 bnes 56394 <msdos_find_name_in_fat_file+0x48a>
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
56322: 202e ffe8 movel %fp@(-24),%d0
56326: 4c02 0800 mulsl %d2,%d0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
5632a: 2043 moveal %d3,%a0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
5632c: 7220 moveq #32,%d1
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
5632e: d0ae ffe4 addl %fp@(-28),%d0
56332: ea88 lsrl #5,%d0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
56334: 41f0 0801 lea %a0@(00000001,%d0:l),%a0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
56338: 1014 moveb %a4@,%d0
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
5633a: 2c08 movel %a0,%d6
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
5633c: 49c0 extbl %d0
5633e: b280 cmpl %d0,%d1
56340: 6606 bnes 56348 <msdos_find_name_in_fat_file+0x43e><== ALWAYS TAKEN
*c = '_';
56342: 18bc 005f moveb #95,%a4@ <== NOT EXECUTED
56346: 6006 bras 5634e <msdos_find_name_in_fat_file+0x444><== NOT EXECUTED
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
56348: 7e2e moveq #46,%d7
5634a: be80 cmpl %d0,%d7
5634c: 67f4 beqs 56342 <msdos_find_name_in_fat_file+0x438><== NEVER TAKEN
5634e: 7220 moveq #32,%d1
56350: 102c 0001 moveb %a4@(1),%d0
56354: 49c0 extbl %d0
56356: b280 cmpl %d0,%d1
56358: 6608 bnes 56362 <msdos_find_name_in_fat_file+0x458><== ALWAYS TAKEN
*c = '_';
5635a: 7e5f moveq #95,%d7 <== NOT EXECUTED
5635c: 1947 0001 moveb %d7,%a4@(1) <== NOT EXECUTED
56360: 6006 bras 56368 <msdos_find_name_in_fat_file+0x45e><== NOT EXECUTED
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
56362: 722e moveq #46,%d1
56364: b280 cmpl %d0,%d1
56366: 67f2 beqs 5635a <msdos_find_name_in_fat_file+0x450><== NEVER TAKEN
msdos_short_name_hex(char* sfn, int num)
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
56368: 41ec 0002 lea %a4@(2),%a0
5636c: 700c moveq #12,%d0
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
5636e: 43f9 0006 8702 lea 68702 <rtems_filesystem_default_pathconf+0xac>,%a1
56374: 2206 movel %d6,%d1
56376: e0a1 asrl %d0,%d1
56378: 7e0f moveq #15,%d7
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
5637a: 5980 subql #4,%d0
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
5637c: c287 andl %d7,%d1
5637e: 10f1 1800 moveb %a1@(00000000,%d1:l),%a0@+
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
56382: 72fc moveq #-4,%d1
56384: b280 cmpl %d0,%d1
56386: 66ec bnes 56374 <msdos_find_name_in_fat_file+0x46a>
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
56388: 7c7e moveq #126,%d6
*c++ = '1';
5638a: 7e31 moveq #49,%d7
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
5638c: 1946 0006 moveb %d6,%a4@(6)
*c++ = '1';
56390: 1947 0007 moveb %d7,%a4@(7)
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
}
if (lfn_entries)
56394: 4a83 tstl %d3
56396: 6730 beqs 563c8 <msdos_find_name_in_fat_file+0x4be>
56398: 204c moveal %a4,%a0
5639a: 700b moveq #11,%d0
5639c: 4201 clrb %d1
5639e: 1d41 ffef moveb %d1,%fp@(-17)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
((lfn_checksum & 1) ? 0x80 : 0) + (lfn_checksum >> 1) + *p;
563a2: 4286 clrl %d6
563a4: 1c2e ffef moveb %fp@(-17),%d6
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
563a8: 0806 0000 btst #0,%d6
563ac: 6704 beqs 563b2 <msdos_find_name_in_fat_file+0x4a8>
563ae: 7280 moveq #-128,%d1
563b0: 6002 bras 563b4 <msdos_find_name_in_fat_file+0x4aa>
563b2: 4201 clrb %d1
563b4: e28e lsrl #1,%d6
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
563b6: 5380 subql #1,%d0
lfn_checksum =
563b8: 1e18 moveb %a0@+,%d7
563ba: dc87 addl %d7,%d6
563bc: dc81 addl %d1,%d6
563be: 1d46 ffef moveb %d6,%fp@(-17)
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
563c2: 4a80 tstl %d0
563c4: 66dc bnes 563a2 <msdos_find_name_in_fat_file+0x498>
563c6: 6006 bras 563ce <msdos_find_name_in_fat_file+0x4c4>
* If a long file name calculate the checksum of the short file name
* data to place in each long file name entry. First set the short
* file name to the slot of the SFN entry. This will mean no clashes
* in this directory.
*/
lfn_checksum = 0;
563c8: 4201 clrb %d1
563ca: 1d41 ffef moveb %d1,%fp@(-17)
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
563ce: 4a85 tstl %d5
563d0: 670e beqs 563e0 <msdos_find_name_in_fat_file+0x4d6><== NEVER TAKEN
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
563d2: 2c2e ffe8 movel %fp@(-24),%d6
563d6: bcae fff0 cmpl %fp@(-16),%d6
563da: 56c0 sne %d0
563dc: 4480 negl %d0
563de: 600e bras 563ee <msdos_find_name_in_fat_file+0x4e4>
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
563e0: 2e2e fff0 movel %fp@(-16),%d7 <== NOT EXECUTED
{
read_cluster = true;
563e4: 7001 moveq #1,%d0 <== NOT EXECUTED
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
563e6: 2d47 ffe8 movel %d7,%fp@(-24) <== NOT EXECUTED
{
read_cluster = true;
empty_space_offset = dir_offset;
empty_space_entry = 0;
563ea: 42ae ffe4 clrl %fp@(-28) <== NOT EXECUTED
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
563ee: 72ff moveq #-1,%d1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
563f0: 2c03 movel %d3,%d6
563f2: 5286 addql #1,%d6
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
563f4: 4287 clrl %d7
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
563f6: 2d41 fff8 movel %d1,%fp@(-8)
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
563fa: 206e 0014 moveal %fp@(20),%a0
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
563fe: 2d41 fff4 movel %d1,%fp@(-12)
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
56402: 720d moveq #13,%d1
56404: 4c03 1800 mulsl %d3,%d1
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
56408: 2a2e ffe8 movel %fp@(-24),%d5
5640c: 4c02 5800 mulsl %d2,%d5
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
56410: 41f0 18f3 lea %a0@(fffffff3,%d1:l),%a0
56414: 2d4c ffca movel %a4,%fp@(-54)
56418: 284b moveal %a3,%a4
5641a: 2644 moveal %d4,%a3
5641c: 2d43 ffd6 movel %d3,%fp@(-42)
56420: 260a movel %a2,%d3
56422: 2d46 ffd2 movel %d6,%fp@(-46)
56426: 2d48 ffdc movel %a0,%fp@(-36)
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
5642a: 6000 025a braw 56686 <msdos_find_name_in_fat_file+0x77c>
{
int length = 0;
if (read_cluster)
5642e: 4a00 tstb %d0
56430: 671a beqs 5644c <msdos_find_name_in_fat_file+0x542><== ALWAYS TAKEN
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(mt_entry, fat_fd,
56432: 2f2b 008c movel %a3@(140),%sp@- <== NOT EXECUTED
56436: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56438: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5643a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5643c: 2f0d movel %a5,%sp@- <== NOT EXECUTED
5643e: 4eb9 0004 fc56 jsr 4fc56 <fat_file_read> <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
56444: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
56448: b480 cmpl %d0,%d2 <== NOT EXECUTED
5644a: 662c bnes 56478 <msdos_find_name_in_fat_file+0x56e><== NOT EXECUTED
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
5644c: 2007 movel %d7,%d0
5644e: 5280 addql #1,%d0
56450: 4284 clrl %d4
#endif
ret = fat_file_read(mt_entry, fat_fd,
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
56452: 222e ffd2 movel %fp@(-46),%d1
56456: 9280 subl %d0,%d1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
56458: 700d moveq #13,%d0
5645a: 4c07 0800 mulsl %d7,%d0
5645e: 226e ffdc moveal %fp@(-36),%a1
56462: 93c0 subal %d0,%a1
56464: 2c2e ffe4 movel %fp@(-28),%d6
56468: 42ae ffe0 clrl %fp@(-32)
5646c: 2d49 ffce movel %a1,%fp@(-50)
56470: 2d43 ffc2 movel %d3,%fp@(-62)
56474: 6000 01c0 braw 56636 <msdos_find_name_in_fat_file+0x72c>
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
{
if (ret != FAT_EOF)
56478: 4a80 tstl %d0 <== NOT EXECUTED
5647a: 6710 beqs 5648c <msdos_find_name_in_fat_file+0x582><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
5647c: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
56482: 7205 moveq #5,%d1 <== NOT EXECUTED
56484: 2440 moveal %d0,%a2 <== NOT EXECUTED
56486: 2481 movel %d1,%a2@ <== NOT EXECUTED
56488: 6000 020c braw 56696 <msdos_find_name_in_fat_file+0x78c><== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif
ret = fat_file_extend (mt_entry, fat_fd, empty_space_offset * bts2rd,
5648c: 486e fffc pea %fp@(-4) <== NOT EXECUTED
56490: 2f05 movel %d5,%sp@- <== NOT EXECUTED
56492: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56494: 2f0d movel %a5,%sp@- <== NOT EXECUTED
56496: 4eb9 0005 0014 jsr 50014 <fat_file_extend> <== NOT EXECUTED
&new_length);
if (ret != RC_OK)
5649c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
564a0: 4a80 tstl %d0 <== NOT EXECUTED
564a2: 6600 01ee bnew 56692 <msdos_find_name_in_fat_file+0x788><== NOT EXECUTED
return ret;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.3] extended: %d <-> %d\n", new_length, empty_space_offset * bts2rd);
#endif
if (new_length != (empty_space_offset * bts2rd))
564a6: baae fffc cmpl %fp@(-4),%d5 <== NOT EXECUTED
564aa: 6600 01c2 bnew 5666e <msdos_find_name_in_fat_file+0x764><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
564ae: 2f02 movel %d2,%sp@- <== NOT EXECUTED
564b0: 42a7 clrl %sp@- <== NOT EXECUTED
564b2: 2f2b 008c movel %a3@(140),%sp@- <== NOT EXECUTED
564b6: 4eb9 0005 957c jsr 5957c <memset> <== NOT EXECUTED
ret = fat_file_write(mt_entry, fat_fd,
564bc: 2f2b 008c movel %a3@(140),%sp@- <== NOT EXECUTED
564c0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
564c2: 2f05 movel %d5,%sp@- <== NOT EXECUTED
564c4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
564c6: 2f0d movel %a5,%sp@- <== NOT EXECUTED
564c8: 4eb9 0005 01a2 jsr 501a2 <fat_file_write> <== NOT EXECUTED
empty_space_offset * bts2rd,
bts2rd, fs_info->cl_buf);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.4] clear write: %d\n", ret);
#endif
if (ret == -1)
564ce: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
564d2: 72ff moveq #-1,%d1 <== NOT EXECUTED
564d4: b280 cmpl %d0,%d1 <== NOT EXECUTED
564d6: 6700 01be beqw 56696 <msdos_find_name_in_fat_file+0x78c><== NOT EXECUTED
return ret;
else if (ret != bts2rd)
564da: b480 cmpl %d0,%d2 <== NOT EXECUTED
564dc: 6700 ff6e beqw 5644c <msdos_find_name_in_fat_file+0x542><== NOT EXECUTED
564e0: 6000 018c braw 5666e <msdos_find_name_in_fat_file+0x764><== NOT EXECUTED
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
564e4: 246b 008c moveal %a3@(140),%a2
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
564e8: 0684 0000 0020 addil #32,%d4
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
564ee: d5c6 addal %d6,%a2
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
564f0: 5287 addql #1,%d7
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
564f2: beae ffd2 cmpl %fp@(-46),%d7
564f6: 667a bnes 56572 <msdos_find_name_in_fat_file+0x668>
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
564f8: 2f0c movel %a4,%sp@-
564fa: 262e ffc2 movel %fp@(-62),%d3
564fe: 2f05 movel %d5,%sp@-
56500: 4878 0001 pea 1 <ADD>
56504: 41f9 0004 ff7c lea 4ff7c <fat_file_ioctl>,%a0
5650a: 2f03 movel %d3,%sp@-
5650c: 2d48 ffbe movel %a0,%fp@(-66)
56510: 2f0d movel %a5,%sp@-
56512: 4e90 jsr %a0@
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
56514: 206e ffbe moveal %fp@(-66),%a0
56518: 4fef 0014 lea %sp@(20),%sp
5651c: 4a80 tstl %d0
5651e: 6600 0172 bnew 56692 <msdos_find_name_in_fat_file+0x788>
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
56522: 202e fff4 movel %fp@(-12),%d0
56526: 72ff moveq #-1,%d1
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
56528: 2946 0004 movel %d6,%a4@(4)
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
5652c: b280 cmpl %d0,%d1
5652e: 671e beqs 5654e <msdos_find_name_in_fat_file+0x644>
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
56530: 486e fff4 pea %fp@(-12)
56534: 4c02 0800 mulsl %d2,%d0
56538: 2f00 movel %d0,%sp@-
5653a: 4878 0001 pea 1 <ADD>
5653e: 2f03 movel %d3,%sp@-
56540: 2f0d movel %a5,%sp@-
56542: 4e90 jsr %a0@
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
56544: 4fef 0014 lea %sp@(20),%sp
56548: 4a80 tstl %d0
5654a: 6600 0146 bnew 56692 <msdos_find_name_in_fat_file+0x788>
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
5654e: 296e fff4 0008 movel %fp@(-12),%a4@(8)
dir_pos->lname.ofs = lfn_start.ofs;
56554: 296e fff8 000c movel %fp@(-8),%a4@(12)
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
5655a: 4878 0020 pea 20 <OPER2+0xc>
5655e: 2f2e ffca movel %fp@(-54),%sp@-
56562: 2f0a movel %a2,%sp@-
56564: 4eb9 0005 950c jsr 5950c <memcpy>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
5656a: 4fef 000c lea %sp@(12),%sp
5656e: 6000 00d0 braw 56640 <msdos_find_name_in_fat_file+0x736>
* This is a long file name and we need to write
* a long file name entry. See if this is the
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
56572: 76ff moveq #-1,%d3
56574: b6ae fff4 cmpl %fp@(-12),%d3
56578: 660c bnes 56586 <msdos_find_name_in_fat_file+0x67c>
{
lfn_start.cln = empty_space_offset;
5657a: 262e ffe8 movel %fp@(-24),%d3
lfn_start.ofs = dir_entry;
5657e: 2d46 fff8 movel %d6,%fp@(-8)
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_start.cln = empty_space_offset;
56582: 2d43 fff4 movel %d3,%fp@(-12)
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56586: 4878 0020 pea 20 <OPER2+0xc>
5658a: 42a7 clrl %sp@-
5658c: 2d41 ffbe movel %d1,%fp@(-66)
56590: 2f0a movel %a2,%sp@-
56592: 4eb9 0005 957c jsr 5957c <memset>
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
56598: 226e ffce moveal %fp@(-50),%a1
5659c: d3ee ffe0 addal %fp@(-32),%a1
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
565a0: 41ea 0001 lea %a2@(1),%a0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
565a4: 4fef 000c lea %sp@(12),%sp
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
565a8: 162e ffef moveb %fp@(-17),%d3
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
565ac: 4200 clrb %d0
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
565ae: 2d42 ffc6 movel %d2,%fp@(-58)
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
565b2: 1543 000d moveb %d3,%a2@(13)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
565b6: 1d40 fff0 moveb %d0,%fp@(-16)
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
565ba: 262e ffc2 movel %fp@(-62),%d3
565be: 4280 clrl %d0
565c0: 222e ffbe movel %fp@(-66),%d1
{
if (*n != 0)
565c4: 1411 moveb %a1@,%d2
565c6: 6706 beqs 565ce <msdos_find_name_in_fat_file+0x6c4>
{
*p = *n;
n++;
565c8: 5289 addql #1,%a1
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
{
*p = *n;
565ca: 1082 moveb %d2,%a0@
565cc: 6012 bras 565e0 <msdos_find_name_in_fat_file+0x6d6>
n++;
}
else
{
p [0] = fill;
p [1] = fill;
565ce: 142e fff0 moveb %fp@(-16),%d2
*p = *n;
n++;
}
else
{
p [0] = fill;
565d2: 10ae fff0 moveb %fp@(-16),%a0@
p [1] = fill;
565d6: 1142 0001 moveb %d2,%a0@(1)
fill = 0xff;
565da: 50c2 st %d2
565dc: 1d42 fff0 moveb %d2,%fp@(-16)
}
switch (i)
565e0: 7404 moveq #4,%d2
565e2: b480 cmpl %d0,%d2
565e4: 670a beqs 565f0 <msdos_find_name_in_fat_file+0x6e6>
565e6: 143c 000a moveb #10,%d2
565ea: b480 cmpl %d0,%d2
565ec: 660a bnes 565f8 <msdos_find_name_in_fat_file+0x6ee>
565ee: 6004 bras 565f4 <msdos_find_name_in_fat_file+0x6ea>
{
case 4:
p += 5;
565f0: 5a88 addql #5,%a0
break;
565f2: 6006 bras 565fa <msdos_find_name_in_fat_file+0x6f0>
case 10:
p += 4;
565f4: 5888 addql #4,%a0
break;
565f6: 6002 bras 565fa <msdos_find_name_in_fat_file+0x6f0>
default:
p += 2;
565f8: 5488 addql #2,%a0
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
565fa: 5280 addql #1,%d0
565fc: 740d moveq #13,%d2
565fe: b480 cmpl %d0,%d2
56600: 66c2 bnes 565c4 <msdos_find_name_in_fat_file+0x6ba>
56602: 2d43 ffc2 movel %d3,%fp@(-62)
56606: 242e ffc6 movel %fp@(-58),%d2
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
5660a: 7601 moveq #1,%d3
p += 2;
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
5660c: 1481 moveb %d1,%a2@
if (lfn_entry == 1)
5660e: b687 cmpl %d7,%d3
56610: 6606 bnes 56618 <msdos_find_name_in_fat_file+0x70e>
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
56612: 7040 moveq #64,%d0
56614: 8081 orl %d1,%d0
56616: 1480 moveb %d0,%a2@
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
56618: 0686 0000 0020 addil #32,%d6
5661e: 5381 subql #1,%d1
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
56620: 102a 000b moveb %a2@(11),%d0
56624: 3040 moveaw %d0,%a0
56626: 700f moveq #15,%d0
56628: 2608 movel %a0,%d3
5662a: 8680 orl %d0,%d3
5662c: 1543 000b moveb %d3,%a2@(11)
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
56630: 76f3 moveq #-13,%d3
56632: d7ae ffe0 addl %d3,%fp@(-32)
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
56636: b486 cmpl %d6,%d2
56638: 6200 feaa bhiw 564e4 <msdos_find_name_in_fat_file+0x5da>
5663c: 262e ffc2 movel %fp@(-62),%d3 <== NOT EXECUTED
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(mt_entry, fat_fd,
56640: 2c2e ffe4 movel %fp@(-28),%d6
56644: dcab 008c addl %a3@(140),%d6
56648: 2f06 movel %d6,%sp@-
5664a: 206e ffe4 moveal %fp@(-28),%a0
5664e: 2f04 movel %d4,%sp@-
56650: 4870 5800 pea %a0@(00000000,%d5:l)
56654: 2f03 movel %d3,%sp@-
56656: 2f0d movel %a5,%sp@-
56658: 4eb9 0005 01a2 jsr 501a2 <fat_file_write>
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
5665e: 4fef 0014 lea %sp@(20),%sp
56662: 72ff moveq #-1,%d1
56664: b280 cmpl %d0,%d1
56666: 672e beqs 56696 <msdos_find_name_in_fat_file+0x78c><== NEVER TAKEN
56668: da82 addl %d2,%d5
return ret;
else if (ret != length)
5666a: b880 cmpl %d0,%d4
5666c: 670e beqs 5667c <msdos_find_name_in_fat_file+0x772><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
5666e: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
56674: 2040 moveal %d0,%a0 <== NOT EXECUTED
56676: 7005 moveq #5,%d0 <== NOT EXECUTED
56678: 2080 movel %d0,%a0@ <== NOT EXECUTED
5667a: 601a bras 56696 <msdos_find_name_in_fat_file+0x78c><== NOT EXECUTED
empty_space_offset++;
5667c: 52ae ffe8 addql #1,%fp@(-24)
empty_space_entry = 0;
read_cluster = true;
56680: 7001 moveq #1,%d0
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
empty_space_entry = 0;
56682: 42ae ffe4 clrl %fp@(-28)
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
56686: beae ffd6 cmpl %fp@(-42),%d7
5668a: 6f00 fda2 blew 5642e <msdos_find_name_in_fat_file+0x524>
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
5668e: 4287 clrl %d7
56690: 6006 bras 56698 <msdos_find_name_in_fat_file+0x78e>
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
56692: 2e00 movel %d0,%d7 <== NOT EXECUTED
56694: 6002 bras 56698 <msdos_find_name_in_fat_file+0x78e><== NOT EXECUTED
}
ret = fat_file_write(mt_entry, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
56696: 7eff moveq #-1,%d7 <== NOT EXECUTED
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
56698: 2007 movel %d7,%d0
5669a: 4cee 3cfc ff94 moveml %fp@(-108),%d2-%d7/%a2-%a5
566a0: 4e5e unlk %fp <== NOT EXECUTED
000566a4 <msdos_find_node_by_cluster_num_in_fat_file>:
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
566a4: 7001 moveq #1,%d0 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
566a6: 4e56 ffd8 linkw %fp,#-40 <== NOT EXECUTED
566aa: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
566ae: 2a2e 0008 movel %fp@(8),%d5 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
566b2: 2045 moveal %d5,%a0 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
566b4: 266e 000c moveal %fp@(12),%a3 <== NOT EXECUTED
566b8: 286e 0014 moveal %fp@(20),%a4 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
566bc: 2a68 0034 moveal %a0@(52),%a5 <== NOT EXECUTED
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
566c0: b0ab 0020 cmpl %a3@(32),%d0 <== NOT EXECUTED
566c4: 6622 bnes 566e8 <msdos_find_node_by_cluster_num_in_fat_file+0x44><== NOT EXECUTED
566c6: 4aab 0024 tstl %a3@(36) <== NOT EXECUTED
566ca: 661c bnes 566e8 <msdos_find_node_by_cluster_num_in_fat_file+0x44><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
566cc: 4280 clrl %d0 <== NOT EXECUTED
566ce: 102d 000a moveb %a5@(10),%d0 <== NOT EXECUTED
566d2: 7203 moveq #3,%d1 <== NOT EXECUTED
566d4: c081 andl %d1,%d0 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
566d6: 6710 beqs 566e8 <msdos_find_node_by_cluster_num_in_fat_file+0x44><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
566d8: 242b 0018 movel %a3@(24),%d2 <== NOT EXECUTED
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
566dc: 4284 clrl %d4 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
566de: 2e3c 0004 fc56 movel #326742,%d7 <== NOT EXECUTED
566e4: 6000 00dc braw 567c2 <msdos_find_node_by_cluster_num_in_fat_file+0x11e><== NOT EXECUTED
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
566e8: 4282 clrl %d2 <== NOT EXECUTED
566ea: 342d 0006 movew %a5@(6),%d2 <== NOT EXECUTED
566ee: 60ec bras 566dc <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
566f0: 7c1f moveq #31,%d6 <== NOT EXECUTED
566f2: bc80 cmpl %d0,%d6 <== NOT EXECUTED
566f4: 6d12 blts 56708 <msdos_find_node_by_cluster_num_in_fat_file+0x64><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
566f6: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
566fc: 7405 moveq #5,%d2 <== NOT EXECUTED
566fe: 2040 moveal %d0,%a0 <== NOT EXECUTED
56700: 2082 movel %d2,%a0@ <== NOT EXECUTED
56702: 74ff moveq #-1,%d2 <== NOT EXECUTED
56704: 6000 00dc braw 567e2 <msdos_find_node_by_cluster_num_in_fat_file+0x13e><== NOT EXECUTED
assert(ret == bts2rd);
56708: b480 cmpl %d0,%d2 <== NOT EXECUTED
5670a: 671c beqs 56728 <msdos_find_node_by_cluster_num_in_fat_file+0x84><== NOT EXECUTED
5670c: 4879 0006 8f06 pea 68f06 <msdos_file_handlers+0xdc> <== NOT EXECUTED
56712: 4879 0006 8f4b pea 68f4b <__FUNCTION__.7203> <== NOT EXECUTED
56718: 4878 069e pea 69e <DBL_MAX_EXP+0x29d> <== NOT EXECUTED
5671c: 4879 0006 8e97 pea 68e97 <msdos_file_handlers+0x6d> <== NOT EXECUTED
56722: 4eb9 0005 2244 jsr 52244 <__assert_func> <== NOT EXECUTED
56728: 246d 008c moveal %a5@(140),%a2 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
5672c: 4283 clrl %d3 <== NOT EXECUTED
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
5672e: 1012 moveb %a2@,%d0 <== NOT EXECUTED
56730: 6700 00aa beqw 567dc <msdos_find_node_by_cluster_num_in_fat_file+0x138><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
/* if this entry is empty - skip it */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
56734: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
5673a: 0c80 0000 00e5 cmpil #229,%d0 <== NOT EXECUTED
56740: 676e beqs 567b0 <msdos_find_node_by_cluster_num_in_fat_file+0x10c><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
56742: 4281 clrl %d1 <== NOT EXECUTED
56744: 322a 0014 movew %a2@(20),%d1 <== NOT EXECUTED
56748: 2001 movel %d1,%d0 <== NOT EXECUTED
5674a: e089 lsrl #8,%d1 <== NOT EXECUTED
5674c: e188 lsll #8,%d0 <== NOT EXECUTED
5674e: 8081 orl %d1,%d0 <== NOT EXECUTED
56750: 4281 clrl %d1 <== NOT EXECUTED
56752: 322a 001a movew %a2@(26),%d1 <== NOT EXECUTED
56756: 4840 swap %d0 <== NOT EXECUTED
56758: 4240 clrw %d0 <== NOT EXECUTED
5675a: 2041 moveal %d1,%a0 <== NOT EXECUTED
5675c: 2c08 movel %a0,%d6 <== NOT EXECUTED
5675e: e08e lsrl #8,%d6 <== NOT EXECUTED
56760: e189 lsll #8,%d1 <== NOT EXECUTED
56762: 8286 orl %d6,%d1 <== NOT EXECUTED
56764: 0281 0000 ffff andil #65535,%d1 <== NOT EXECUTED
5676a: 8081 orl %d1,%d0 <== NOT EXECUTED
5676c: b0ae 0010 cmpl %fp@(16),%d0 <== NOT EXECUTED
56770: 663e bnes 567b0 <msdos_find_node_by_cluster_num_in_fat_file+0x10c><== NOT EXECUTED
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
56772: 2f0c movel %a4,%sp@- <== NOT EXECUTED
56774: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56776: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5677a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5677c: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5677e: 4eb9 0004 ff7c jsr 4ff7c <fat_file_ioctl> <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
56784: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
56788: 2400 movel %d0,%d2 <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
5678a: 6656 bnes 567e2 <msdos_find_node_by_cluster_num_in_fat_file+0x13e><== NOT EXECUTED
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
5678c: 70ff moveq #-1,%d0 <== NOT EXECUTED
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = i;
5678e: 2943 0004 movel %d3,%a4@(4) <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
56792: 2940 0008 movel %d0,%a4@(8) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
56796: 2940 000c movel %d0,%a4@(12) <== NOT EXECUTED
memcpy(dir_entry, entry,
5679a: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
5679e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
567a0: 2f2e 0018 movel %fp@(24),%sp@- <== NOT EXECUTED
567a4: 4eb9 0005 950c jsr 5950c <memcpy> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
567aa: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
567ae: 6032 bras 567e2 <msdos_find_node_by_cluster_num_in_fat_file+0x13e><== NOT EXECUTED
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
567b0: 0683 0000 0020 addil #32,%d3 <== NOT EXECUTED
567b6: 45ea 0020 lea %a2@(32),%a2 <== NOT EXECUTED
567ba: b483 cmpl %d3,%d2 <== NOT EXECUTED
567bc: 6200 ff70 bhiw 5672e <msdos_find_node_by_cluster_num_in_fat_file+0x8a><== NOT EXECUTED
567c0: d882 addl %d2,%d4 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
567c2: 2f2d 008c movel %a5@(140),%sp@- <== NOT EXECUTED
567c6: 2047 moveal %d7,%a0 <== NOT EXECUTED
567c8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
567ca: 2f04 movel %d4,%sp@- <== NOT EXECUTED
567cc: 2f0b movel %a3,%sp@- <== NOT EXECUTED
567ce: 2f05 movel %d5,%sp@- <== NOT EXECUTED
567d0: 4e90 jsr %a0@ <== NOT EXECUTED
567d2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
567d6: 4a80 tstl %d0 <== NOT EXECUTED
567d8: 6600 ff16 bnew 566f0 <msdos_find_node_by_cluster_num_in_fat_file+0x4c><== NOT EXECUTED
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
567dc: 243c 0000 7d01 movel #32001,%d2 <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
567e2: 2002 movel %d2,%d0 <== NOT EXECUTED
567e4: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5 <== NOT EXECUTED
567ea: 4e5e unlk %fp <== NOT EXECUTED
0004c632 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c632: 4e56 fd30 linkw %fp,#-720
4c636: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
4c63a: 4879 0006 88de pea 688de <_CPU_m68k_BFFFO_table+0x13a>
4c640: 47fa fe2a lea %pc@(4c46c <msdos_format_printf>),%a3
4c644: 4878 0002 pea 2 <DOUBLE_FLOAT>
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c648: 246e 000c moveal %fp@(12),%a2
4c64c: 262e 0008 movel %fp@(8),%d3
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
4c650: 2f0a movel %a2,%sp@-
4c652: 4e93 jsr %a3@
fd = open(devname, O_RDWR);
4c654: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c658: 2f03 movel %d3,%sp@-
4c65a: 4eb9 0004 62b0 jsr 462b0 <open>
if (fd == -1) {
4c660: 4fef 0014 lea %sp@(20),%sp
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
4c664: 2400 movel %d0,%d2
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
rtems_disk_device *dd = NULL;
struct stat stat_buf;
int ret_val = 0;
4c666: 70ff moveq #-1,%d0
4c668: b082 cmpl %d2,%d0
4c66a: 57c6 seq %d6
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c66c: 2f03 movel %d3,%sp@-
4c66e: 4879 0006 88eb pea 688eb <_CPU_m68k_BFFFO_table+0x147>
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
rtems_disk_device *dd = NULL;
struct stat stat_buf;
int ret_val = 0;
4c674: 49c6 extbl %d6
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c676: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c67a: 2f0a movel %a2,%sp@-
4c67c: 4e93 jsr %a3@
"stat check: %s\n", devname);
if (ret_val == 0) {
4c67e: 4fef 0010 lea %sp@(16),%sp
4c682: 4a86 tstl %d6
4c684: 6612 bnes 4c698 <msdos_format+0x66> <== NEVER TAKEN
rc = fstat(fd, &stat_buf);
4c686: 486e ffb0 pea %fp@(-80)
4c68a: 2f02 movel %d2,%sp@-
4c68c: 4eb9 0005 23c0 jsr 523c0 <fstat>
4c692: 508f addql #8,%sp
ret_val = rc;
4c694: 2840 moveal %d0,%a4
4c696: 6004 bras 4c69c <msdos_format+0x6a>
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"stat check: %s\n", devname);
if (ret_val == 0) {
4c698: 387c ffff moveaw #-1,%a4 <== NOT EXECUTED
rc = fstat(fd, &stat_buf);
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4c69c: 2f03 movel %d3,%sp@-
4c69e: 4879 0006 88fb pea 688fb <_CPU_m68k_BFFFO_table+0x157>
4c6a4: 4bfa fdc6 lea %pc@(4c46c <msdos_format_printf>),%a5
4c6a8: 4878 0001 pea 1 <ADD>
4c6ac: 2f0a movel %a2,%sp@-
4c6ae: 4e95 jsr %a5@
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
4c6b0: 4fef 0010 lea %sp@(16),%sp
4c6b4: 4a8c tstl %a4
4c6b6: 6632 bnes 4c6ea <msdos_format+0xb8> <== NEVER TAKEN
4c6b8: 202e ffbc movel %fp@(-68),%d0
4c6bc: 0280 0000 f000 andil #61440,%d0
4c6c2: 0c80 0000 6000 cmpil #24576,%d0
4c6c8: 6700 08fe beqw 4cfc8 <msdos_format+0x996>
errno = ENOTTY;
4c6cc: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4c6d2: 7e19 moveq #25,%d7 <== NOT EXECUTED
4c6d4: 2040 moveal %d0,%a0 <== NOT EXECUTED
4c6d6: 2087 movel %d7,%a0@ <== NOT EXECUTED
4c6d8: 600c bras 4c6e6 <msdos_format+0xb4> <== NOT EXECUTED
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
if (dd == NULL) {
errno = ENOTTY;
4c6da: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4c6e0: 7c19 moveq #25,%d6 <== NOT EXECUTED
4c6e2: 2840 moveal %d0,%a4 <== NOT EXECUTED
4c6e4: 2886 movel %d6,%a4@ <== NOT EXECUTED
ret_val = -1;
4c6e6: 387c ffff moveaw #-1,%a4 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
4c6ea: 97cb subal %a3,%a3 <== NOT EXECUTED
4c6ec: 6000 08b0 braw 4cf9e <msdos_format+0x96c> <== NOT EXECUTED
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
4c6f0: 202a 000c movel %a2@(12),%d0
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4c6f4: 6604 bnes 4c6fa <msdos_format+0xc8> <== NEVER TAKEN
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
4c6f6: 7002 moveq #2,%d0
4c6f8: 6008 bras 4c702 <msdos_format+0xd0>
}
else if (rqdata->fat_num <= 6) {
4c6fa: 7206 moveq #6,%d1 <== NOT EXECUTED
4c6fc: b280 cmpl %d0,%d1 <== NOT EXECUTED
4c6fe: 6500 01d6 bcsw 4c8d6 <msdos_format+0x2a4> <== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
4c702: 7c01 moveq #1,%d6
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
4c704: 1d40 ff92 moveb %d0,%fp@(-110)
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c708: 4280 clrl %d0
4c70a: 102e ff92 moveb %fp@(-110),%d0
4c70e: 2f00 movel %d0,%sp@-
4c710: 4879 0006 890a pea 6890a <_CPU_m68k_BFFFO_table+0x166>
4c716: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c71a: 2f0a movel %a2,%sp@-
4c71c: 4eba fd4e jsr %pc@(4c46c <msdos_format_printf>)
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
4c720: 4fef 0010 lea %sp@(16),%sp
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
4c724: 2d46 ff6e movel %d6,%fp@(-146)
if ((rqdata != NULL) &&
4c728: 4a8a tstl %a2
4c72a: 673e beqs 4c76a <msdos_format+0x138> <== NEVER TAKEN
4c72c: 4280 clrl %d0
(rqdata->fattype == MSDOS_FMT_FAT12)) {
4c72e: 122a 0014 moveb %a2@(20),%d1
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
4c732: 1001 moveb %d1,%d0
4c734: bc80 cmpl %d0,%d6
4c736: 6604 bnes 4c73c <msdos_format+0x10a> <== ALWAYS TAKEN
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
4c738: 7e01 moveq #1,%d7 <== NOT EXECUTED
4c73a: 6012 bras 4c74e <msdos_format+0x11c> <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
4c73c: 7c02 moveq #2,%d6
4c73e: bc80 cmpl %d0,%d6
4c740: 6604 bnes 4c746 <msdos_format+0x114> <== ALWAYS TAKEN
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
4c742: 7e02 moveq #2,%d7 <== NOT EXECUTED
4c744: 6008 bras 4c74e <msdos_format+0x11c> <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
4c746: 7c03 moveq #3,%d6
4c748: bc80 cmpl %d0,%d6
4c74a: 660a bnes 4c756 <msdos_format+0x124> <== ALWAYS TAKEN
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
4c74c: 7e04 moveq #4,%d7 <== NOT EXECUTED
4c74e: 4283 clrl %d3 <== NOT EXECUTED
4c750: 1d47 ff94 moveb %d7,%fp@(-108) <== NOT EXECUTED
4c754: 6076 bras 4c7cc <msdos_format+0x19a> <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
4c756: 4a01 tstb %d1
4c758: 6710 beqs 4c76a <msdos_format+0x138> <== ALWAYS TAKEN
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
4c75a: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4c760: 7a16 moveq #22,%d5 <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
}
else if ((rqdata != NULL) &&
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
4c762: 76ff moveq #-1,%d3 <== NOT EXECUTED
errno = EINVAL;
4c764: 2040 moveal %d0,%a0 <== NOT EXECUTED
4c766: 2085 movel %d5,%a0@ <== NOT EXECUTED
4c768: 6062 bras 4c7cc <msdos_format+0x19a> <== NOT EXECUTED
/*
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
if (fmt_params->totl_sector_cnt
4c76a: 0c83 0000 7fa7 cmpil #32679,%d3
4c770: 620a bhis 4c77c <msdos_format+0x14a> <== NEVER TAKEN
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4c772: 7202 moveq #2,%d1
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
if (fmt_params->totl_sector_cnt
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
4c774: 7001 moveq #1,%d0
4c776: 1d40 ff94 moveb %d0,%fp@(-108)
4c77a: 6046 bras 4c7c2 <msdos_format+0x190>
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
4c77c: 0c83 001f fe9f cmpil #2096799,%d3 <== NOT EXECUTED
4c782: 620e bhis 4c792 <msdos_format+0x160> <== NOT EXECUTED
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4c784: 7802 moveq #2,%d4 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
4c786: 7602 moveq #2,%d3 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4c788: 2d44 ff6e movel %d4,%fp@(-146) <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
4c78c: 1d43 ff94 moveb %d3,%fp@(-108) <== NOT EXECUTED
4c790: 6034 bras 4c7c6 <msdos_format+0x194> <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
4c792: 7e1e moveq #30,%d7 <== NOT EXECUTED
4c794: 4286 clrl %d6 <== NOT EXECUTED
4c796: 0685 4000 0000 addil #1073741824,%d5 <== NOT EXECUTED
4c79c: d986 addxl %d6,%d4 <== NOT EXECUTED
4c79e: 2204 movel %d4,%d1 <== NOT EXECUTED
4c7a0: 2005 movel %d5,%d0 <== NOT EXECUTED
4c7a2: eea8 lsrl %d7,%d0 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
4c7a4: 7801 moveq #1,%d4 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
4c7a6: e589 lsll #2,%d1 <== NOT EXECUTED
4c7a8: 8280 orl %d0,%d1 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
4c7aa: 7004 moveq #4,%d0 <== NOT EXECUTED
4c7ac: 1d40 ff94 moveb %d0,%fp@(-108) <== NOT EXECUTED
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4c7b0: 701f moveq #31,%d0 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4c7b2: 2604 movel %d4,%d3 <== NOT EXECUTED
4c7b4: e1ab lsll %d0,%d3 <== NOT EXECUTED
4c7b6: c681 andl %d1,%d3 <== NOT EXECUTED
4c7b8: 6604 bnes 4c7be <msdos_format+0x18c> <== NOT EXECUTED
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4c7ba: 5380 subql #1,%d0 <== NOT EXECUTED
4c7bc: 66f4 bnes 4c7b2 <msdos_format+0x180> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
4c7be: 7201 moveq #1,%d1 <== NOT EXECUTED
4c7c0: e1a9 lsll %d0,%d1 <== NOT EXECUTED
4c7c2: 2d41 ff6e movel %d1,%fp@(-146)
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
4c7c6: 4283 clrl %d3
4c7c8: 4a8a tstl %a2
4c7ca: 670a beqs 4c7d6 <msdos_format+0x1a4> <== NEVER TAKEN
(rqdata->sectors_per_cluster > 0)) {
4c7cc: 202a 0008 movel %a2@(8),%d0
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
4c7d0: 6704 beqs 4c7d6 <msdos_format+0x1a4> <== ALWAYS TAKEN
(rqdata->sectors_per_cluster > 0)) {
fmt_params->sectors_per_cluster =
4c7d2: 2d40 ff6e movel %d0,%fp@(-146) <== NOT EXECUTED
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
4c7d6: 282e ff62 movel %fp@(-158),%d4
4c7da: 203c 0000 0080 movel #128,%d0
4c7e0: 222e ff6e movel %fp@(-146),%d1
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
4c7e4: b081 cmpl %d1,%d0
4c7e6: 6216 bhis 4c7fe <msdos_format+0x1cc>
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
4c7e8: 223c 0000 8000 movel #32768,%d1
4c7ee: 4c44 1001 remul %d4,%d1,%d1
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
4c7f2: b280 cmpl %d0,%d1
4c7f4: 6404 bccs 4c7fa <msdos_format+0x1c8> <== ALWAYS TAKEN
4c7f6: 2200 movel %d0,%d1 <== NOT EXECUTED
4c7f8: 6004 bras 4c7fe <msdos_format+0x1cc> <== NOT EXECUTED
4c7fa: 2200 movel %d0,%d1
<= 32768L/fmt_params->bytes_per_sector) {
/* value is small enough so this value is ok */
onebit = 1;
4c7fc: 7001 moveq #1,%d0
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
4c7fe: e288 lsrl #1,%d0
4c800: 66e2 bnes 4c7e4 <msdos_format+0x1b2>
4c802: 2d41 ff6e movel %d1,%fp@(-146)
}
}
}
}
if (ret_val == 0) {
4c806: 4a83 tstl %d3
4c808: 6600 01de bnew 4c9e8 <msdos_format+0x3b6>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c80c: 2f01 movel %d1,%sp@-
4c80e: 4879 0006 891e pea 6891e <_CPU_m68k_BFFFO_table+0x17a>
4c814: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c818: 2f0a movel %a2,%sp@-
4c81a: 4eba fc50 jsr %pc@(4c46c <msdos_format_printf>)
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
4c81e: 4fef 0010 lea %sp@(16),%sp
4c822: 4280 clrl %d0
4c824: 102e ff94 moveb %fp@(-108),%d0
4c828: 7204 moveq #4,%d1
4c82a: b280 cmpl %d0,%d1
4c82c: 6618 bnes 4c846 <msdos_format+0x214> <== ALWAYS TAKEN
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
4c82e: 7820 moveq #32,%d4 <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4c830: 7a06 moveq #6,%d5 <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4c832: 7c01 moveq #1,%d6 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
4c834: 2d44 ff6a movel %d4,%fp@(-150) <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
4c838: 42ae ff7a clrl %fp@(-134) <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4c83c: 2d45 ff8a movel %d5,%fp@(-118) <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4c840: 2d46 ff8e movel %d6,%fp@(-114) <== NOT EXECUTED
4c844: 604a bras 4c890 <msdos_format+0x25e> <== NOT EXECUTED
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
4c846: 7e01 moveq #1,%d7
4c848: 2d47 ff6a movel %d7,%fp@(-150)
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
4c84c: 4a8a tstl %a2
4c84e: 670c beqs 4c85c <msdos_format+0x22a> <== NEVER TAKEN
(rqdata->files_per_root_dir > 0)) {
4c850: 222a 0010 movel %a2@(16),%d1
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
4c854: 6706 beqs 4c85c <msdos_format+0x22a> <== ALWAYS TAKEN
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
4c856: 2d41 ff7a movel %d1,%fp@(-134) <== NOT EXECUTED
4c85a: 6018 bras 4c874 <msdos_format+0x242> <== NOT EXECUTED
}
else {
if (fmt_params->fattype == FAT_FAT16) {
4c85c: 7202 moveq #2,%d1
4c85e: b280 cmpl %d0,%d1
4c860: 660c bnes 4c86e <msdos_format+0x23c> <== ALWAYS TAKEN
fmt_params->files_per_root_dir = 512;
4c862: 283c 0000 0200 movel #512,%d4 <== NOT EXECUTED
4c868: 2d44 ff7a movel %d4,%fp@(-134) <== NOT EXECUTED
4c86c: 6006 bras 4c874 <msdos_format+0x242> <== NOT EXECUTED
}
else {
fmt_params->files_per_root_dir = 64;
4c86e: 7a40 moveq #64,%d5
4c870: 2d45 ff7a movel %d5,%fp@(-134)
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
4c874: 202e ff62 movel %fp@(-158),%d0
4c878: d080 addl %d0,%d0
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4c87a: 222e ff7a movel %fp@(-134),%d1
(2*fmt_params->bytes_per_sector/
4c87e: ea88 lsrl #5,%d0
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4c880: 5381 subql #1,%d1
4c882: d280 addl %d0,%d1
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
4c884: 2c01 movel %d1,%d6
4c886: 4c40 6004 remul %d0,%d4,%d6
4c88a: 9284 subl %d4,%d1
4c88c: 2d41 ff7a movel %d1,%fp@(-134)
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
4c890: 202e ff7a movel %fp@(-134),%d0
+ fmt_params->bytes_per_sector - 1)
4c894: 222e ff62 movel %fp@(-158),%d1
4c898: 2041 moveal %d1,%a0
4c89a: 5388 subql #1,%a0
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4c89c: 2a3c 0000 8000 movel #32768,%d5
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
4c8a2: eb88 lsll #5,%d0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
4c8a4: 2e2e ff66 movel %fp@(-154),%d7
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
4c8a8: d088 addl %a0,%d0
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
4c8aa: 9eae ff6a subl %fp@(-150),%d7
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
4c8ae: 4c41 0000 remul %d1,%d0,%d0
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
4c8b2: 2d47 fd5c movel %d7,%fp@(-676)
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
4c8b6: 4284 clrl %d4
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
4c8b8: 91ae fd5c subl %d0,%fp@(-676)
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
4c8bc: 182e ff94 moveb %fp@(-108),%d4
fmt_params->bytes_per_sector,
fatdata_sect_cnt,
fmt_params->fat_num,
4c8c0: 1c2e ff92 moveb %fp@(-110),%d6
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
4c8c4: 2d40 ff7e movel %d0,%fp@(-130)
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
4c8c8: 202e ff6e movel %fp@(-146),%d0
4c8cc: 2d44 fd58 movel %d4,%fp@(-680)
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4c8d0: 4c41 5005 remul %d1,%d5,%d5
4c8d4: 6008 bras 4c8de <msdos_format+0x2ac>
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
ret_val = EINVAL;
4c8d6: 7616 moveq #22,%d3 <== NOT EXECUTED
4c8d8: 6000 0110 braw 4c9ea <msdos_format+0x3b8> <== NOT EXECUTED
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
sectors_per_cluster /= 2;
4c8dc: e288 lsrl #1,%d0 <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4c8de: b085 cmpl %d5,%d0
4c8e0: 62fa bhis 4c8dc <msdos_format+0x2aa> <== NEVER TAKEN
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
4c8e2: 0286 0000 00ff andil #255,%d6
4c8e8: 2246 moveal %d6,%a1
* compute number of data clusters for current data:
* - compute cluster count for data AND fat
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
4c8ea: 2a2e fd5c movel %fp@(-676),%d5
4c8ee: 4c40 5005 remul %d0,%d5,%d5
if (fattype == FAT_FAT12) {
4c8f2: 7801 moveq #1,%d4
4c8f4: b8ae fd58 cmpl %fp@(-680),%d4
4c8f8: 660c bnes 4c906 <msdos_format+0x2d4> <== NEVER TAKEN
fat_capacity = fatdata_cluster_cnt * 3 / 2;
4c8fa: 2845 moveal %d5,%a4
4c8fc: 49f4 5a00 lea %a4@(00000000,%d5:l:2),%a4
4c900: 280c movel %a4,%d4
4c902: e28c lsrl #1,%d4
4c904: 6012 bras 4c918 <msdos_format+0x2e6>
}
else if (fattype == FAT_FAT16) {
4c906: 7802 moveq #2,%d4 <== NOT EXECUTED
4c908: b8ae fd58 cmpl %fp@(-680),%d4 <== NOT EXECUTED
4c90c: 6606 bnes 4c914 <msdos_format+0x2e2> <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
4c90e: 2805 movel %d5,%d4 <== NOT EXECUTED
4c910: d884 addl %d4,%d4 <== NOT EXECUTED
4c912: 6004 bras 4c918 <msdos_format+0x2e6> <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
4c914: 2805 movel %d5,%d4 <== NOT EXECUTED
4c916: e58c lsll #2,%d4 <== NOT EXECUTED
}
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
4c918: d888 addl %a0,%d4
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
4c91a: 2e09 movel %a1,%d7
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
4c91c: 4c41 4004 remul %d1,%d4,%d4
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
4c920: 4c04 7800 mulsl %d4,%d7
4c924: 2847 moveal %d7,%a4
+ (sectors_per_cluster - 1))
4c926: 49f4 08ff lea %a4@(ffffffff,%d0:l),%a4
/ sectors_per_cluster));
4c92a: 2c0c movel %a4,%d6
4c92c: 4c40 6006 remul %d0,%d6,%d6
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
4c930: 9a86 subl %d6,%d5
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
4c932: 7c01 moveq #1,%d6
4c934: bcae fd58 cmpl %fp@(-680),%d6
4c938: 660a bnes 4c944 <msdos_format+0x312> <== NEVER TAKEN
4c93a: 0c85 0000 0ff5 cmpil #4085,%d5
4c940: 6212 bhis 4c954 <msdos_format+0x322> <== NEVER TAKEN
4c942: 6016 bras 4c95a <msdos_format+0x328>
4c944: 7e02 moveq #2,%d7 <== NOT EXECUTED
4c946: beae fd58 cmpl %fp@(-680),%d7 <== NOT EXECUTED
4c94a: 660e bnes 4c95a <msdos_format+0x328> <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
4c94c: 0c85 0000 fff5 cmpil #65525,%d5 <== NOT EXECUTED
4c952: 6306 blss 4c95a <msdos_format+0x328> <== NOT EXECUTED
sectors_per_cluster *= 2;
4c954: d080 addl %d0,%d0 <== NOT EXECUTED
4c956: 4205 clrb %d5 <== NOT EXECUTED
4c958: 6002 bras 4c95c <msdos_format+0x32a> <== NOT EXECUTED
}
else {
finished = true;
4c95a: 7a01 moveq #1,%d5
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
4c95c: 2c00 movel %d0,%d6
4c95e: 4c01 6800 mulsl %d1,%d6
4c962: 0c86 0000 8000 cmpil #32768,%d6
4c968: 620c bhis 4c976 <msdos_format+0x344> <== NEVER TAKEN
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
4c96a: 4a05 tstb %d5
4c96c: 6700 ff7c beqw 4c8ea <msdos_format+0x2b8>
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
}
else {
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = sectors_per_fat;
4c970: 2d44 ff72 movel %d4,%fp@(-142)
4c974: 6010 bras 4c986 <msdos_format+0x354>
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
4c976: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4c97c: 7816 moveq #22,%d4 <== NOT EXECUTED
4c97e: 76ff moveq #-1,%d3 <== NOT EXECUTED
4c980: 2040 moveal %d0,%a0 <== NOT EXECUTED
\*=========================================================================*/
{
int ret_val = 0;
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
4c982: 4280 clrl %d0 <== NOT EXECUTED
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
4c984: 2084 movel %d4,%a0@ <== NOT EXECUTED
fatdata_sect_cnt,
fmt_params->fat_num,
fmt_params->sectors_per_cluster,
§ors_per_cluster_adj,
&(fmt_params->sectors_per_fat));
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
4c986: 2d40 ff6e movel %d0,%fp@(-146)
}
/*
* determine media code
*/
if (ret_val == 0) {
4c98a: 4a83 tstl %d3
4c98c: 665a bnes 4c9e8 <msdos_format+0x3b6> <== NEVER TAKEN
if ((rqdata != NULL) &&
4c98e: 4a8a tstl %a2
4c990: 674e beqs 4c9e0 <msdos_format+0x3ae> <== NEVER TAKEN
(rqdata->media != 0)) {
4c992: 182a 0015 moveb %a2@(21),%d4
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4c996: 6748 beqs 4c9e0 <msdos_format+0x3ae> <== ALWAYS TAKEN
(rqdata->media != 0)) {
const char valid_media_codes[] =
4c998: 4878 0009 pea 9 <DIVIDE_BY_ZERO+0x1> <== NOT EXECUTED
4c99c: 2a0e movel %fp,%d5 <== NOT EXECUTED
4c99e: 4879 0006 89c1 pea 689c1 <_CPU_m68k_BFFFO_table+0x21d> <== NOT EXECUTED
4c9a4: 0685 ffff fff6 addil #-10,%d5 <== NOT EXECUTED
4c9aa: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4c9ac: 4eb9 0005 950c jsr 5950c <memcpy> <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
4c9b2: 4878 0009 pea 9 <DIVIDE_BY_ZERO+0x1> <== NOT EXECUTED
4c9b6: 4280 clrl %d0 <== NOT EXECUTED
4c9b8: 1004 moveb %d4,%d0 <== NOT EXECUTED
4c9ba: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c9bc: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4c9be: 4eb9 0005 93b8 jsr 593b8 <memchr> <== NOT EXECUTED
4c9c4: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4c9c8: 4a80 tstl %d0 <== NOT EXECUTED
4c9ca: 660e bnes 4c9da <msdos_format+0x3a8> <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
4c9cc: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4c9d2: 7616 moveq #22,%d3 <== NOT EXECUTED
4c9d4: 2840 moveal %d0,%a4 <== NOT EXECUTED
4c9d6: 2883 movel %d3,%a4@ <== NOT EXECUTED
4c9d8: 600e bras 4c9e8 <msdos_format+0x3b6> <== NOT EXECUTED
}
else {
fmt_params->media_code = rqdata->media;
4c9da: 1d44 ff93 moveb %d4,%fp@(-109) <== NOT EXECUTED
4c9de: 600a bras 4c9ea <msdos_format+0x3b8> <== NOT EXECUTED
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4c9e0: 70f8 moveq #-8,%d0
4c9e2: 1d40 ff93 moveb %d0,%fp@(-109)
4c9e6: 6002 bras 4c9ea <msdos_format+0x3b8>
}
/*
* determine media code
*/
if (ret_val == 0) {
4c9e8: 76ff moveq #-1,%d3 <== NOT EXECUTED
4c9ea: 4280 clrl %d0
4c9ec: 102e ff92 moveb %fp@(-110),%d0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4c9f0: 222e ff7e movel %fp@(-130),%d1
4c9f4: 6716 beqs 4ca0c <msdos_format+0x3da> <== NEVER TAKEN
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4c9f6: 41ee ff72 lea %fp@(-142),%a0
4c9fa: 4c10 0800 mulsl %a0@,%d0
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
4c9fe: 2d41 ff86 movel %d1,%fp@(-122)
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4ca02: d0ae ff6a addl %fp@(-150),%d0
4ca06: 2d40 ff82 movel %d0,%fp@(-126)
4ca0a: 6016 bras 4ca22 <msdos_format+0x3f0>
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4ca0c: 49ee ff72 lea %fp@(-142),%a4 <== NOT EXECUTED
4ca10: 4c14 0800 mulsl %a4@,%d0 <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4ca14: 2d6e ff6e ff86 movel %fp@(-146),%fp@(-122) <== NOT EXECUTED
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4ca1a: d0ae ff6a addl %fp@(-150),%d0 <== NOT EXECUTED
4ca1e: 2d40 ff82 movel %d0,%fp@(-126) <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
4ca22: 4a83 tstl %d3
4ca24: 6600 00d4 bnew 4cafa <msdos_format+0x4c8>
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
4ca28: 41f9 0006 79e4 lea 679e4 <__func__.6070+0x2cc>,%a0
if ((rqdata != NULL) &&
4ca2e: 4a8a tstl %a2
4ca30: 670c beqs 4ca3e <msdos_format+0x40c> <== NEVER TAKEN
(rqdata->OEMName != NULL)) {
4ca32: 2052 moveal %a2@,%a0
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
4ca34: 4a88 tstl %a0
4ca36: 6606 bnes 4ca3e <msdos_format+0x40c> <== ALWAYS TAKEN
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
4ca38: 41f9 0006 79e4 lea 679e4 <__func__.6070+0x2cc>,%a0 <== NOT EXECUTED
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4ca3e: 2a79 0006 9d68 moveal 69d68 <__ctype_ptr__>,%a5
4ca44: 7009 moveq #9,%d0
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
4ca46: 43ee ff95 lea %fp@(-107),%a1
4ca4a: 6028 bras 4ca74 <msdos_format+0x442>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4ca4c: 4281 clrl %d1
4ca4e: 49e9 0001 lea %a1@(1),%a4
4ca52: 1610 moveb %a0@,%d3
4ca54: 1203 moveb %d3,%d1
4ca56: 1235 1801 moveb %a5@(00000001,%d1:l),%d1
4ca5a: 49c1 extbl %d1
4ca5c: 0281 0000 0097 andil #151,%d1
4ca62: 6708 beqs 4ca6c <msdos_format+0x43a>
*to++ = *from++;
4ca64: 5288 addql #1,%a0
4ca66: 1283 moveb %d3,%a1@
4ca68: 224c moveal %a4,%a1
4ca6a: 6006 bras 4ca72 <msdos_format+0x440>
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4ca6c: 12bc 0020 moveb #32,%a1@
4ca70: 224c moveal %a4,%a1
}
*to = '\0';
4ca72: 4214 clrb %a4@
4ca74: 5380 subql #1,%d0
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
4ca76: 66d4 bnes 4ca4c <msdos_format+0x41a>
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
4ca78: 41f9 0006 8701 lea 68701 <rtems_filesystem_default_pathconf+0xab>,%a0
if ((rqdata != NULL) &&
4ca7e: 4a8a tstl %a2
4ca80: 6716 beqs 4ca98 <msdos_format+0x466> <== NEVER TAKEN
(rqdata->VolLabel != NULL)) {
4ca82: 206a 0004 moveal %a2@(4),%a0
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
4ca86: 4a88 tstl %a0
4ca88: 6708 beqs 4ca92 <msdos_format+0x460> <== NEVER TAKEN
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
4ca8a: 7001 moveq #1,%d0
4ca8c: 1d40 ffaa moveb %d0,%fp@(-86)
4ca90: 6006 bras 4ca98 <msdos_format+0x466>
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
4ca92: 41f9 0006 8701 lea 68701 <rtems_filesystem_default_pathconf+0xab>,%a0<== NOT EXECUTED
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4ca98: 2a79 0006 9d68 moveal 69d68 <__ctype_ptr__>,%a5
4ca9e: 700c moveq #12,%d0
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
4caa0: 43ee ff9e lea %fp@(-98),%a1
4caa4: 6028 bras 4cace <msdos_format+0x49c>
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4caa6: 4281 clrl %d1
4caa8: 49e9 0001 lea %a1@(1),%a4
4caac: 1610 moveb %a0@,%d3
4caae: 1203 moveb %d3,%d1
4cab0: 1235 1801 moveb %a5@(00000001,%d1:l),%d1
4cab4: 49c1 extbl %d1
4cab6: 0281 0000 0097 andil #151,%d1
4cabc: 6708 beqs 4cac6 <msdos_format+0x494>
*to++ = *from++;
4cabe: 5288 addql #1,%a0
4cac0: 1283 moveb %d3,%a1@
4cac2: 224c moveal %a4,%a1
4cac4: 6006 bras 4cacc <msdos_format+0x49a>
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4cac6: 12bc 0020 moveb #32,%a1@
4caca: 224c moveal %a4,%a1
}
*to = '\0';
4cacc: 4214 clrb %a4@
4cace: 5380 subql #1,%d0
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
4cad0: 66d4 bnes 4caa6 <msdos_format+0x474>
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
4cad2: 486e fff6 pea %fp@(-10)
4cad6: 4eb9 0005 2f3c jsr 52f3c <rtems_clock_get_tod_timeval>
if (rc == RTEMS_SUCCESSFUL) {
4cadc: 588f addql #4,%sp
4cade: 4a80 tstl %d0
4cae0: 6608 bnes 4caea <msdos_format+0x4b8> <== ALWAYS TAKEN
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
4cae2: 202e fff6 movel %fp@(-10),%d0 <== NOT EXECUTED
4cae6: d080 addl %d0,%d0 <== NOT EXECUTED
4cae8: 6006 bras 4caf0 <msdos_format+0x4be> <== NOT EXECUTED
}
else {
*volid_ptr = rand();
4caea: 4eb9 0005 9640 jsr 59640 <rand>
4caf0: 2d40 ffac movel %d0,%fp@(-84)
ret_val = msdos_format_determine_fmt_params(dd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
4caf4: 4a8a tstl %a2
4caf6: 660e bnes 4cb06 <msdos_format+0x4d4> <== ALWAYS TAKEN
4caf8: 6034 bras 4cb2e <msdos_format+0x4fc> <== NOT EXECUTED
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
4cafa: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4cb00: 2040 moveal %d0,%a0 <== NOT EXECUTED
4cb02: 2083 movel %d3,%a0@ <== NOT EXECUTED
4cb04: 606c bras 4cb72 <msdos_format+0x540> <== NOT EXECUTED
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
4cb06: 4a2a 0016 tstb %a2@(22)
4cb0a: 6622 bnes 4cb2e <msdos_format+0x4fc> <== NEVER TAKEN
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
4cb0c: 4878 ffe5 pea ffffffe5 <DBL_MIN_EXP+0x3e2>
4cb10: 2f2e ff62 movel %fp@(-158),%sp@-
4cb14: 2f2e ff66 movel %fp@(-154),%sp@-
4cb18: 42a7 clrl %sp@-
4cb1a: 2f02 movel %d2,%sp@-
4cb1c: 2f0a movel %a2,%sp@-
4cb1e: 4eba f9f8 jsr %pc@(4c518 <msdos_format_fill_sectors>)
}
/*
* create master boot record
*/
if (ret_val == 0) {
4cb22: 4fef 0018 lea %sp@(24),%sp
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
4cb26: 2840 moveal %d0,%a4
}
/*
* create master boot record
*/
if (ret_val == 0) {
4cb28: 4a80 tstl %d0
4cb2a: 6600 0472 bnew 4cf9e <msdos_format+0x96c>
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cb2e: 4879 0006 8937 pea 68937 <_CPU_m68k_BFFFO_table+0x193>
4cb34: 49fa f936 lea %pc@(4c46c <msdos_format_printf>),%a4
4cb38: 4878 0002 pea 2 <DOUBLE_FLOAT>
4cb3c: 2f0a movel %a2,%sp@-
4cb3e: 4e94 jsr %a4@
"read MRB sector\n");
ret_val = msdos_format_read_sec(fd,
4cb40: 262e ff62 movel %fp@(-158),%d3
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4cb44: 42a7 clrl %sp@-
4cb46: 42a7 clrl %sp@-
4cb48: 42a7 clrl %sp@-
4cb4a: 2f02 movel %d2,%sp@-
4cb4c: 4eb9 0004 58b0 jsr 458b0 <lseek>
4cb52: 4fef 001c lea %sp@(28),%sp
4cb56: 4a80 tstl %d0
4cb58: 6b18 bmis 4cb72 <msdos_format+0x540> <== NEVER TAKEN
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
4cb5a: 2f03 movel %d3,%sp@-
4cb5c: 486e fd62 pea %fp@(-670)
4cb60: 2f02 movel %d2,%sp@-
4cb62: 4eb9 0004 6690 jsr 46690 <read>
4cb68: 4fef 000c lea %sp@(12),%sp
4cb6c: 4a80 tstl %d0
4cb6e: 6c00 04be bgew 4d02e <msdos_format+0x9fc>
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
4cb72: 387c ffff moveaw #-1,%a4 <== NOT EXECUTED
4cb76: 6000 0426 braw 4cf9e <msdos_format+0x96c> <== NOT EXECUTED
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
4cb7a: 2a04 movel %d4,%d5 <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
4cb7c: 4284 clrl %d4 <== NOT EXECUTED
4cb7e: 6002 bras 4cb82 <msdos_format+0x550> <== NOT EXECUTED
uint32_t total_sectors_num32 = 0;
4cb80: 4285 clrl %d5
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4cb82: 4878 01be pea 1be <DBL_MANT_DIG+0x189>
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"generate MRB sector\n");
ret_val = msdos_format_gen_mbr(tmp_sec,&fmt_params);
4cb86: 49ee fd62 lea %fp@(-670),%a4
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4cb8a: 4bf9 0005 957c lea 5957c <memset>,%a5
4cb90: 42a7 clrl %sp@-
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
4cb92: 7c06 moveq #6,%d6
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4cb94: 2f0c movel %a4,%sp@-
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4cb96: 7e01 moveq #1,%d7
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4cb98: 4e95 jsr %a5@
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4cb9a: 296e ff99 0007 movel %fp@(-103),%a4@(7)
4cba0: 41ec 0003 lea %a4@(3),%a0
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
4cba4: 4fef 000c lea %sp@(12),%sp
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
4cba8: 4240 clrw %d0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4cbaa: 20ae ff95 movel %fp@(-107),%a0@
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
4cbae: 3d40 ff60 movew %d0,%fp@(-160)
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
4cbb2: 2003 movel %d3,%d0
4cbb4: e088 lsrl #8,%d0
4cbb6: 1d40 fd6e moveb %d0,%fp@(-658)
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
4cbba: 202e ff6a movel %fp@(-150),%d0
4cbbe: 1d40 fd70 moveb %d0,%fp@(-656)
4cbc2: e088 lsrl #8,%d0
4cbc4: 1d40 fd71 moveb %d0,%fp@(-655)
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4cbc8: 202e ff7a movel %fp@(-134),%d0
4cbcc: 1d40 fd73 moveb %d0,%fp@(-653)
4cbd0: e088 lsrl #8,%d0
4cbd2: 1d40 fd74 moveb %d0,%fp@(-652)
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cbd6: 2005 movel %d5,%d0
4cbd8: e088 lsrl #8,%d0
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4cbda: 1d44 fd75 moveb %d4,%fp@(-651)
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cbde: 1d40 fd83 moveb %d0,%fp@(-637)
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4cbe2: e08c lsrl #8,%d4
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cbe4: 2005 movel %d5,%d0
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4cbe6: 1d44 fd76 moveb %d4,%fp@(-650)
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cbea: 4240 clrw %d0
4cbec: 4840 swap %d0
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4cbee: 50c4 st %d4
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
4cbf0: 7202 moveq #2,%d1
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cbf2: 1d40 fd84 moveb %d0,%fp@(-636)
4cbf6: 7018 moveq #24,%d0
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4cbf8: 1d44 fd7a moveb %d4,%fp@(-646)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cbfc: 1d45 fd82 moveb %d5,%fp@(-638)
4cc00: e0ad lsrl %d0,%d5
if (fmt_params->fattype != FAT_FAT32) {
4cc02: 4284 clrl %d4
4cc04: 182e ff94 moveb %fp@(-108),%d4
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
4cc08: 1d41 fd72 moveb %d1,%fp@(-654)
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
4cc0c: 1d43 fd6d moveb %d3,%fp@(-659)
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4cc10: 1d6e ff71 fd6f moveb %fp@(-143),%fp@(-657)
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
4cc16: 1d6e ff93 fd77 moveb %fp@(-109),%fp@(-649)
4cc1c: 202e ff72 movel %fp@(-142),%d0
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
4cc20: 7204 moveq #4,%d1
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
4cc22: 1d46 fd7c moveb %d6,%fp@(-644)
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4cc26: 1d47 fd7e moveb %d7,%fp@(-642)
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cc2a: 1d45 fd85 moveb %d5,%fp@(-635)
if (fmt_params->fattype != FAT_FAT32) {
4cc2e: b284 cmpl %d4,%d1
4cc30: 6766 beqs 4cc98 <msdos_format+0x666> <== NEVER TAKEN
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4cc32: 4878 000b pea b <LASTO+0x1>
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4cc36: 7c18 moveq #24,%d6
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4cc38: 486e ff9e pea %fp@(-98)
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4cc3c: 7e01 moveq #1,%d7
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4cc3e: 486c 002b pea %a4@(43)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
4cc42: 1d40 fd78 moveb %d0,%fp@(-648)
4cc46: e088 lsrl #8,%d0
4cc48: 1d40 fd79 moveb %d0,%fp@(-647)
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4cc4c: 202e ffac movel %fp@(-84),%d0
4cc50: 2200 movel %d0,%d1
4cc52: e089 lsrl #8,%d1
4cc54: 1d41 fd8a moveb %d1,%fp@(-630)
4cc58: 2200 movel %d0,%d1
4cc5a: 1d40 fd89 moveb %d0,%fp@(-631)
4cc5e: 4241 clrw %d1
4cc60: 4841 swap %d1
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
4cc62: 7a29 moveq #41,%d5
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4cc64: eca8 lsrl %d6,%d0
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
4cc66: 1d45 fd88 moveb %d5,%fp@(-632)
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4cc6a: 1d41 fd8b moveb %d1,%fp@(-629)
4cc6e: 1d40 fd8c moveb %d0,%fp@(-628)
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4cc72: 4eb9 0005 950c jsr 5950c <memcpy>
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4cc78: 4fef 000c lea %sp@(12),%sp
4cc7c: 41f9 0006 88d5 lea 688d5 <_CPU_m68k_BFFFO_table+0x131>,%a0
4cc82: be84 cmpl %d4,%d7
4cc84: 6606 bnes 4cc8c <msdos_format+0x65a> <== NEVER TAKEN
4cc86: 41f9 0006 88cc lea 688cc <_CPU_m68k_BFFFO_table+0x128>,%a0
4cc8c: 2d50 fd98 movel %a0@,%fp@(-616)
4cc90: 2d68 0004 fd9c movel %a0@(4),%fp@(-612)
4cc96: 606e bras 4cd06 <msdos_format+0x6d4>
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4cc98: 2200 movel %d0,%d1 <== NOT EXECUTED
4cc9a: e089 lsrl #8,%d1 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4cc9c: 4878 000c pea c <OPER1> <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4cca0: 2e3c 3220 2020 movel #840966176,%d7 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4cca6: 1d41 fd87 moveb %d1,%fp@(-633) <== NOT EXECUTED
4ccaa: 2200 movel %d0,%d1 <== NOT EXECUTED
4ccac: 4241 clrw %d1 <== NOT EXECUTED
4ccae: 4841 swap %d1 <== NOT EXECUTED
4ccb0: 1d40 fd86 moveb %d0,%fp@(-634) <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4ccb4: 42a7 clrl %sp@- <== NOT EXECUTED
4ccb6: 486c 0034 pea %a4@(52) <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4ccba: 1d41 fd88 moveb %d1,%fp@(-632) <== NOT EXECUTED
4ccbe: 7218 moveq #24,%d1 <== NOT EXECUTED
4ccc0: e2a8 lsrl %d1,%d0 <== NOT EXECUTED
4ccc2: 1d40 fd89 moveb %d0,%fp@(-631) <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4ccc6: 202e ff8a movel %fp@(-118),%d0 <== NOT EXECUTED
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
4ccca: 7802 moveq #2,%d4 <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4cccc: 1d40 fd94 moveb %d0,%fp@(-620) <== NOT EXECUTED
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
4ccd0: 7a01 moveq #1,%d5 <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4ccd2: e088 lsrl #8,%d0 <== NOT EXECUTED
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
4ccd4: 1d44 fd8e moveb %d4,%fp@(-626) <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
4ccd8: 1d45 fd92 moveb %d5,%fp@(-622) <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4ccdc: 1d40 fd95 moveb %d0,%fp@(-619) <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
4cce0: 7c29 moveq #41,%d6 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4cce2: 4e95 jsr %a5@ <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
4cce4: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
4cce8: 42a7 clrl %sp@- <== NOT EXECUTED
4ccea: 486c 0047 pea %a4@(71) <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4ccee: 49ec 0052 lea %a4@(82),%a4 <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
4ccf2: 1d46 fda4 moveb %d6,%fp@(-604) <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
4ccf6: 4e95 jsr %a5@ <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4ccf8: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4ccfc: 28bc 4641 5433 movel #1178686515,%a4@ <== NOT EXECUTED
4cd02: 2947 0004 movel %d7,%a4@(4) <== NOT EXECUTED
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cd06: 4879 0006 8948 pea 68948 <_CPU_m68k_BFFFO_table+0x1a4>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cd0c: 4bfa f7a4 lea %pc@(4c4b2 <msdos_format_write_sec>),%a5
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cd10: 4878 0002 pea 2 <DOUBLE_FLOAT>
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
4cd14: 7a3c moveq #60,%d5
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
4cd16: 7055 moveq #85,%d0
4cd18: 72aa moveq #-86,%d1
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
4cd1a: 78eb moveq #-21,%d4
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cd1c: 2f0a movel %a2,%sp@-
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
FAT_SET_VAL8(mbr,2,0x90);
4cd1e: 7c90 moveq #-112,%d6
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
4cd20: 1d45 fd63 moveb %d5,%fp@(-669)
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
4cd24: 1d40 ff60 moveb %d0,%fp@(-160)
4cd28: 1d41 ff61 moveb %d1,%fp@(-159)
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
4cd2c: 1d44 fd62 moveb %d4,%fp@(-670)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
4cd30: 280e movel %fp,%d4
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cd32: 2a3c 0004 c46c movel #312428,%d5
4cd38: 2045 moveal %d5,%a0
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
4cd3a: 0684 ffff fd62 addil #-670,%d4
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
FAT_SET_VAL8(mbr,2,0x90);
4cd40: 1d46 fd64 moveb %d6,%fp@(-668)
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cd44: 4e90 jsr %a0@
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cd46: 2f04 movel %d4,%sp@-
4cd48: 2f03 movel %d3,%sp@-
4cd4a: 42a7 clrl %sp@-
4cd4c: 2f02 movel %d2,%sp@-
4cd4e: 4e95 jsr %a5@
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4cd50: 4fef 001c lea %sp@(28),%sp
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cd54: 2840 moveal %d0,%a4
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4cd56: 4a80 tstl %d0
4cd58: 6600 0244 bnew 4cf9e <msdos_format+0x96c>
(fmt_params.mbr_copy_sec != 0)) {
4cd5c: 2c2e ff8a movel %fp@(-118),%d6
ret_val = msdos_format_write_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4cd60: 6726 beqs 4cd88 <msdos_format+0x756> <== ALWAYS TAKEN
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cd62: 4879 0006 895a pea 6895a <_CPU_m68k_BFFFO_table+0x1b6> <== NOT EXECUTED
4cd68: 2845 moveal %d5,%a4 <== NOT EXECUTED
4cd6a: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
4cd6e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4cd70: 4e94 jsr %a4@ <== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cd72: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cd74: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4cd76: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cd78: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cd7a: 4e95 jsr %a5@ <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4cd7c: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cd80: 2840 moveal %d0,%a4 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4cd82: 4a80 tstl %d0 <== NOT EXECUTED
4cd84: 6600 0218 bnew 4cf9e <msdos_format+0x96c> <== NOT EXECUTED
(fmt_params.fsinfo_sec != 0)) {
4cd88: 282e ff8e movel %fp@(-114),%d4
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4cd8c: 6700 0086 beqw 4ce14 <msdos_format+0x7e2>
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4cd90: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb> <== NOT EXECUTED
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_gen_fsinfo(tmp_sec);
4cd94: 2a0e movel %fp,%d5 <== NOT EXECUTED
4cd96: 0685 ffff fd62 addil #-670,%d5 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4cd9c: 42a7 clrl %sp@- <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4cd9e: 7c41 moveq #65,%d6 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4cda0: 2f05 movel %d5,%sp@- <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4cda2: 7e72 moveq #114,%d7 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4cda4: 4eb9 0005 957c jsr 5957c <memset> <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4cdaa: 7052 moveq #82,%d0 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4cdac: 2f05 movel %d5,%sp@- <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4cdae: 7261 moveq #97,%d1 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4cdb0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4cdb2: 1d40 fd62 moveb %d0,%fp@(-670) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4cdb6: 2f04 movel %d4,%sp@- <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4cdb8: 1d40 fd63 moveb %d0,%fp@(-669) <== NOT EXECUTED
4cdbc: 1d41 fd64 moveb %d1,%fp@(-668) <== NOT EXECUTED
4cdc0: 1d46 fd65 moveb %d6,%fp@(-667) <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4cdc4: 1d46 ff48 moveb %d6,%fp@(-184) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4cdc8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4cdca: 1d41 ff49 moveb %d1,%fp@(-183) <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
4cdce: 50c6 st %d6 <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4cdd0: 7055 moveq #85,%d0 <== NOT EXECUTED
4cdd2: 72aa moveq #-86,%d1 <== NOT EXECUTED
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4cdd4: 1d47 ff46 moveb %d7,%fp@(-186) <== NOT EXECUTED
4cdd8: 1d47 ff47 moveb %d7,%fp@(-185) <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4cddc: 1d40 ff60 moveb %d0,%fp@(-160) <== NOT EXECUTED
4cde0: 1d41 ff61 moveb %d1,%fp@(-159) <== NOT EXECUTED
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
4cde4: 1d46 ff4a moveb %d6,%fp@(-182) <== NOT EXECUTED
4cde8: 1d46 ff4b moveb %d6,%fp@(-181) <== NOT EXECUTED
4cdec: 1d46 ff4c moveb %d6,%fp@(-180) <== NOT EXECUTED
4cdf0: 1d46 ff4d moveb %d6,%fp@(-179) <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
4cdf4: 1d46 ff4e moveb %d6,%fp@(-178) <== NOT EXECUTED
4cdf8: 1d46 ff4f moveb %d6,%fp@(-177) <== NOT EXECUTED
4cdfc: 1d46 ff50 moveb %d6,%fp@(-176) <== NOT EXECUTED
4ce00: 1d46 ff51 moveb %d6,%fp@(-175) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4ce04: 4eba f6ac jsr %pc@(4c4b2 <msdos_format_write_sec>) <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
4ce08: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4ce0c: 2840 moveal %d0,%a4 <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
4ce0e: 4a80 tstl %d0 <== NOT EXECUTED
4ce10: 6600 018c bnew 4cf9e <msdos_format+0x96c> <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
4ce14: 42a7 clrl %sp@-
4ce16: 2e2e ff72 movel %fp@(-142),%d7
(rqdata,
4ce1a: 4280 clrl %d0
fd,
fmt_params.rsvd_sector_cnt, /* start sector */
fmt_params.fat_num*fmt_params.sectors_per_fat,/* sector count */
4ce1c: 1a2e ff92 moveb %fp@(-110),%d5
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4ce20: 2f03 movel %d3,%sp@-
4ce22: 283c 0004 c518 movel #312600,%d4
(rqdata,
4ce28: 1005 moveb %d5,%d0
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4ce2a: 4c00 7800 mulsl %d0,%d7
4ce2e: 2044 moveal %d4,%a0
4ce30: 2f07 movel %d7,%sp@-
4ce32: 2f2e ff6a movel %fp@(-150),%sp@-
4ce36: 2f02 movel %d2,%sp@-
4ce38: 2f0a movel %a2,%sp@-
4ce3a: 4e90 jsr %a0@
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
4ce3c: 4fef 0018 lea %sp@(24),%sp
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4ce40: 2840 moveal %d0,%a4
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
4ce42: 4a80 tstl %d0
4ce44: 6600 0158 bnew 4cf9e <msdos_format+0x96c>
ret_val = msdos_format_fill_sectors
4ce48: 42a7 clrl %sp@-
(rqdata,
4ce4a: 2a6e ff82 moveal %fp@(-126),%a5
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4ce4e: 2844 moveal %d4,%a4
4ce50: 2f03 movel %d3,%sp@-
4ce52: 2f2e ff86 movel %fp@(-122),%sp@-
4ce56: 2f0d movel %a5,%sp@-
4ce58: 2f02 movel %d2,%sp@-
4ce5a: 2f0a movel %a2,%sp@-
4ce5c: 4e94 jsr %a4@
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
4ce5e: 4fef 0018 lea %sp@(24),%sp
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4ce62: 2840 moveal %d0,%a4
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
4ce64: 4a80 tstl %d0
4ce66: 6600 0136 bnew 4cf9e <msdos_format+0x96c>
4ce6a: 4a2e ffaa tstb %fp@(-86)
4ce6e: 6700 012e beqw 4cf9e <msdos_format+0x96c>
memset(tmp_sec,0,sizeof(tmp_sec));
4ce72: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
4ce76: 280e movel %fp,%d4
4ce78: 0684 ffff fd62 addil #-670,%d4
4ce7e: 45f9 0005 957c lea 5957c <memset>,%a2
4ce84: 42a7 clrl %sp@-
4ce86: 2f04 movel %d4,%sp@-
4ce88: 4e92 jsr %a2@
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
4ce8a: 4878 000b pea b <LASTO+0x1>
4ce8e: 486e ff9e pea %fp@(-98)
4ce92: 2f04 movel %d4,%sp@-
4ce94: 4eb9 0005 950c jsr 5950c <memcpy>
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
4ce9a: 7008 moveq #8,%d0
ret_val = msdos_format_write_sec
4ce9c: 2f04 movel %d4,%sp@-
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
4ce9e: 1d40 fd6d moveb %d0,%fp@(-659)
ret_val = msdos_format_write_sec
4cea2: 2f03 movel %d3,%sp@-
4cea4: 2f0d movel %a5,%sp@-
4cea6: 2f02 movel %d2,%sp@-
4cea8: 4eba f608 jsr %pc@(4c4b2 <msdos_format_write_sec>)
/*
* write FAT entry 0 as (0xffffff00|Media_type)EOC,
* write FAT entry 1 as EOC
* allocate directory in a FAT32 FS
*/
if ((ret_val == 0) && fmt_params.VolLabel_present){
4ceac: 4fef 0028 lea %sp@(40),%sp
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
4ceb0: 2840 moveal %d0,%a4
/*
* write FAT entry 0 as (0xffffff00|Media_type)EOC,
* write FAT entry 1 as EOC
* allocate directory in a FAT32 FS
*/
if ((ret_val == 0) && fmt_params.VolLabel_present){
4ceb2: 4a80 tstl %d0
4ceb4: 6600 00e8 bnew 4cf9e <msdos_format+0x96c>
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
4ceb8: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
switch(fmt_params.fattype) {
4cebc: 4283 clrl %d3
*/
if ((ret_val == 0) && fmt_params.VolLabel_present){
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
4cebe: 42a7 clrl %sp@-
4cec0: 2f04 movel %d4,%sp@-
4cec2: 4e92 jsr %a2@
switch(fmt_params.fattype) {
4cec4: 4fef 000c lea %sp@(12),%sp
4cec8: 162e ff94 moveb %fp@(-108),%d3
4cecc: 7202 moveq #2,%d1
4cece: b283 cmpl %d3,%d1
4ced0: 6720 beqs 4cef2 <msdos_format+0x8c0> <== NEVER TAKEN
4ced2: 7804 moveq #4,%d4
4ced4: b883 cmpl %d3,%d4
4ced6: 6732 beqs 4cf0a <msdos_format+0x8d8> <== NEVER TAKEN
4ced8: 7c01 moveq #1,%d6
4ceda: bc83 cmpl %d3,%d6
4cedc: 6656 bnes 4cf34 <msdos_format+0x902> <== NEVER TAKEN
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
/* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
4cede: 7e8f moveq #-113,%d7
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
4cee0: 50c0 st %d0
memset(tmp_sec,0,sizeof(tmp_sec));
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
4cee2: 1d6e ff93 fd62 moveb %fp@(-109),%fp@(-670)
/* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
4cee8: 1d47 fd63 moveb %d7,%fp@(-669)
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
4ceec: 1d40 fd64 moveb %d0,%fp@(-668)
break;
4cef0: 606e bras 4cf60 <msdos_format+0x92e>
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
FAT_SET_VAL8(tmp_sec,1,0xff);
4cef2: 50c1 st %d1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
4cef4: 76f8 moveq #-8,%d3 <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
4cef6: 1d6e ff93 fd62 moveb %fp@(-109),%fp@(-670) <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
4cefc: 1d41 fd63 moveb %d1,%fp@(-669) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
4cf00: 1d43 fd64 moveb %d3,%fp@(-668) <== NOT EXECUTED
4cf04: 1d41 fd65 moveb %d1,%fp@(-667) <== NOT EXECUTED
break;
4cf08: 6056 bras 4cf60 <msdos_format+0x92e> <== NOT EXECUTED
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
4cf0a: 50c4 st %d4 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4cf0c: 7cf8 moveq #-8,%d6 <== NOT EXECUTED
4cf0e: 7e0f moveq #15,%d7 <== NOT EXECUTED
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
4cf10: 1d6e ff93 fd62 moveb %fp@(-109),%fp@(-670) <== NOT EXECUTED
4cf16: 1d44 fd63 moveb %d4,%fp@(-669) <== NOT EXECUTED
4cf1a: 1d44 fd64 moveb %d4,%fp@(-668) <== NOT EXECUTED
4cf1e: 1d44 fd65 moveb %d4,%fp@(-667) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4cf22: 1d46 fd66 moveb %d6,%fp@(-666) <== NOT EXECUTED
4cf26: 1d44 fd67 moveb %d4,%fp@(-665) <== NOT EXECUTED
4cf2a: 1d44 fd68 moveb %d4,%fp@(-664) <== NOT EXECUTED
4cf2e: 1d47 fd69 moveb %d7,%fp@(-663) <== NOT EXECUTED
4cf32: 6016 bras 4cf4a <msdos_format+0x918> <== NOT EXECUTED
break;
default:
ret_val = -1;
errno = EINVAL;
4cf34: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
4cf3a: 387c ffff moveaw #-1,%a4 <== NOT EXECUTED
errno = EINVAL;
4cf3e: 2040 moveal %d0,%a0 <== NOT EXECUTED
4cf40: 7216 moveq #22,%d1 <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
4cf42: 7004 moveq #4,%d0 <== NOT EXECUTED
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
errno = EINVAL;
4cf44: 2081 movel %d1,%a0@ <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
4cf46: b083 cmpl %d3,%d0 <== NOT EXECUTED
4cf48: 6616 bnes 4cf60 <msdos_format+0x92e> <== NOT EXECUTED
/*
* only first valid cluster (cluster number 2) belongs
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
4cf4a: 50c3 st %d3 <== NOT EXECUTED
4cf4c: 72f8 moveq #-8,%d1 <== NOT EXECUTED
4cf4e: 780f moveq #15,%d4 <== NOT EXECUTED
4cf50: 1d41 fd6a moveb %d1,%fp@(-662) <== NOT EXECUTED
4cf54: 1d43 fd6b moveb %d3,%fp@(-661) <== NOT EXECUTED
4cf58: 1d43 fd6c moveb %d3,%fp@(-660) <== NOT EXECUTED
4cf5c: 1d44 fd6d moveb %d4,%fp@(-659) <== NOT EXECUTED
ret_val = msdos_format_write_sec
(fd,
fmt_params.rsvd_sector_cnt
+ (i * fmt_params.sectors_per_fat),
fmt_params.bytes_per_sector,
tmp_sec);
4cf60: 280e movel %fp,%d4
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
4cf62: 4283 clrl %d3
ret_val = msdos_format_write_sec
(fd,
fmt_params.rsvd_sector_cnt
+ (i * fmt_params.sectors_per_fat),
fmt_params.bytes_per_sector,
tmp_sec);
4cf64: 0684 ffff fd62 addil #-670,%d4
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
4cf6a: 45fa f546 lea %pc@(4c4b2 <msdos_format_write_sec>),%a2
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
4cf6e: 0285 0000 00ff andil #255,%d5
4cf74: 6020 bras 4cf96 <msdos_format+0x964>
i++) {
ret_val = msdos_format_write_sec
(fd,
fmt_params.rsvd_sector_cnt
+ (i * fmt_params.sectors_per_fat),
4cf76: 202e ff72 movel %fp@(-142),%d0
4cf7a: 4c03 0800 mulsl %d3,%d0
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
4cf7e: 5283 addql #1,%d3
ret_val = msdos_format_write_sec
4cf80: 2f04 movel %d4,%sp@-
4cf82: 2f2e ff62 movel %fp@(-158),%sp@-
4cf86: d0ae ff6a addl %fp@(-150),%d0
4cf8a: 2f00 movel %d0,%sp@-
4cf8c: 2f02 movel %d2,%sp@-
4cf8e: 4e92 jsr %a2@
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
4cf90: 4fef 0010 lea %sp@(16),%sp
ret_val = msdos_format_write_sec
4cf94: 2840 moveal %d0,%a4
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
4cf96: ba83 cmpl %d3,%d5
4cf98: 6f04 bles 4cf9e <msdos_format+0x96c>
(i < fmt_params.fat_num) && (ret_val == 0);
4cf9a: 4a8c tstl %a4
4cf9c: 67d8 beqs 4cf76 <msdos_format+0x944> <== ALWAYS TAKEN
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
4cf9e: 7aff moveq #-1,%d5
4cfa0: ba82 cmpl %d2,%d5
4cfa2: 670a beqs 4cfae <msdos_format+0x97c> <== NEVER TAKEN
close(fd);
4cfa4: 2f02 movel %d2,%sp@-
4cfa6: 4eb9 0004 4ffc jsr 44ffc <close>
4cfac: 588f addql #4,%sp
}
if (dd != NULL) {
4cfae: 4a8b tstl %a3
4cfb0: 670a beqs 4cfbc <msdos_format+0x98a> <== NEVER TAKEN
rtems_disk_release(dd);
4cfb2: 2f0b movel %a3,%sp@-
4cfb4: 4eb9 0004 4522 jsr 44522 <rtems_disk_release>
4cfba: 588f addql #4,%sp
}
return ret_val;
}
4cfbc: 200c movel %a4,%d0
4cfbe: 4cee 3cfc fd30 moveml %fp@(-720),%d2-%d7/%a2-%a5
4cfc4: 4e5e unlk %fp
4cfc6: 4e75 rts
ret_val = -1;
}
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
4cfc8: 2f2e ffca movel %fp@(-54),%sp@-
4cfcc: 2f2e ffc6 movel %fp@(-58),%sp@-
4cfd0: 4eb9 0004 44ba jsr 444ba <rtems_disk_obtain>
if (dd == NULL) {
4cfd6: 508f addql #8,%sp
ret_val = -1;
}
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
4cfd8: 2640 moveal %d0,%a3
if (dd == NULL) {
4cfda: 4a80 tstl %d0
4cfdc: 6700 f6fc beqw 4c6da <msdos_format+0xa8>
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
uint64_t total_size = 0;
memset(fmt_params,0,sizeof(*fmt_params));
4cfe0: 4878 004e pea 4e <DBL_MANT_DIG+0x19>
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
4cfe4: 4284 clrl %d4
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
uint64_t total_size = 0;
memset(fmt_params,0,sizeof(*fmt_params));
4cfe6: 42a7 clrl %sp@-
4cfe8: 486e ff62 pea %fp@(-158)
4cfec: 4eb9 0005 957c jsr 5957c <memset>
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
4cff2: 262b 001c movel %a3@(28),%d3
total_size = dd->block_size * dd->size;
4cff6: 2203 movel %d3,%d1
/*
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
4cff8: 202b 0020 movel %a3@(32),%d0
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
4cffc: 4c00 1800 mulsl %d0,%d1
/*
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
4d000: 2d40 ff62 movel %d0,%fp@(-158)
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
4d004: 2a01 movel %d1,%d5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4d006: 2f01 movel %d1,%sp@-
4d008: 2f04 movel %d4,%sp@-
4d00a: 2f03 movel %d3,%sp@-
4d00c: 2f00 movel %d0,%sp@-
4d00e: 4879 0006 8974 pea 68974 <_CPU_m68k_BFFFO_table+0x1d0>
4d014: 4878 0002 pea 2 <DOUBLE_FLOAT>
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
4d018: 2d43 ff66 movel %d3,%fp@(-154)
total_size = dd->block_size * dd->size;
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4d01c: 2f0a movel %a2,%sp@-
4d01e: 4e95 jsr %a5@
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4d020: 4fef 0028 lea %sp@(40),%sp
4d024: 4a8a tstl %a2
4d026: 6600 f6c8 bnew 4c6f0 <msdos_format+0xbe>
4d02a: 6000 f6ca braw 4c6f6 <msdos_format+0xc4> <== NOT EXECUTED
ret_val = msdos_format_read_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4d02e: 4879 0006 89ac pea 689ac <_CPU_m68k_BFFFO_table+0x208>
4d034: 4878 0002 pea 2 <DOUBLE_FLOAT>
4d038: 2f0a movel %a2,%sp@-
4d03a: 4e94 jsr %a4@
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
4d03c: 282e ff66 movel %fp@(-154),%d4
4d040: 4fef 000c lea %sp@(12),%sp
4d044: 0c84 0000 ffff cmpil #65535,%d4
4d04a: 6300 fb34 blsw 4cb80 <msdos_format+0x54e>
4d04e: 6000 fb2a braw 4cb7a <msdos_format+0x548> <== NOT EXECUTED
...
0004c518 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c518: 4e56 ffd0 linkw %fp,#-48
4c51c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4c520: 266e 0018 moveal %fp@(24),%a3
4c524: 262e 0008 movel %fp@(8),%d3
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4c528: 2f0b movel %a3,%sp@-
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c52a: 282e 0010 movel %fp@(16),%d4
4c52e: 2a2e 0014 movel %fp@(20),%d5
4c532: 1c2e 001f moveb %fp@(31),%d6
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4c536: 4eb9 0004 5af0 jsr 45af0 <malloc>
if (fill_buffer == NULL) {
4c53c: 588f addql #4,%sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4c53e: 2400 movel %d0,%d2
if (fill_buffer == NULL) {
4c540: 6614 bnes 4c556 <msdos_format_fill_sectors+0x3e> <== ALWAYS TAKEN
errno = ENOMEM;
4c542: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4c548: 2040 moveal %d0,%a0 <== NOT EXECUTED
4c54a: 700c moveq #12,%d0 <== NOT EXECUTED
4c54c: 2080 movel %d0,%a0@ <== NOT EXECUTED
ret_val = -1;
4c54e: 70ff moveq #-1,%d0 <== NOT EXECUTED
4c550: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
4c554: 6016 bras 4c56c <msdos_format_fill_sectors+0x54> <== NOT EXECUTED
}
else {
memset(fill_buffer,fill_byte,sector_size);
4c556: 2f0b movel %a3,%sp@-
4c558: 49c6 extbl %d6
4c55a: 2f06 movel %d6,%sp@-
4c55c: 2f00 movel %d0,%sp@-
4c55e: 4eb9 0005 957c jsr 5957c <memset>
4c564: 4fef 000c lea %sp@(12),%sp
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
4c568: 42ae fffc clrl %fp@(-4)
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c56c: 4879 0006 88a4 pea 688a4 <_CPU_m68k_BFFFO_table+0x100>
4c572: 4bfa fef8 lea %pc@(4c46c <msdos_format_printf>),%a5
4c576: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c57a: 7c64 moveq #100,%d6
4c57c: 4c05 6800 mulsl %d5,%d6
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4c580: 2445 moveal %d5,%a2
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
4c582: 7eff moveq #-1,%d7
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c584: 49fa ff2c lea %pc@(4c4b2 <msdos_format_write_sec>),%a4
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c588: 2f03 movel %d3,%sp@-
4c58a: 4e95 jsr %a5@
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4c58c: 4fef 000c lea %sp@(12),%sp
4c590: 604a bras 4c5dc <msdos_format_fill_sectors+0xc4>
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
4c592: 2006 movel %d6,%d0
4c594: 4c45 0000 remul %d5,%d0,%d0
if (percent != last_percent) {
4c598: be80 cmpl %d0,%d7
4c59a: 6722 beqs 4c5be <msdos_format_fill_sectors+0xa6>
if ((percent & 1) == 0)
4c59c: 0800 0000 btst #0,%d0
4c5a0: 661a bnes 4c5bc <msdos_format_fill_sectors+0xa4>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4c5a2: 4879 0006 74a7 pea 674a7 <_rodata_start+0x1b7>
4c5a8: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c5ac: 2d40 fff8 movel %d0,%fp@(-8)
4c5b0: 2f03 movel %d3,%sp@-
4c5b2: 4e95 jsr %a5@
4c5b4: 202e fff8 movel %fp@(-8),%d0
4c5b8: 4fef 000c lea %sp@(12),%sp
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
4c5bc: 2e00 movel %d0,%d7
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c5be: 2f02 movel %d2,%sp@-
start_sector++;
sector_cnt--;
4c5c0: 538a subql #1,%a2
4c5c2: 0686 ffff ff9c addil #-100,%d6
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c5c8: 2f0b movel %a3,%sp@-
4c5ca: 2f04 movel %d4,%sp@-
4c5cc: 2f2e 000c movel %fp@(12),%sp@-
start_sector++;
4c5d0: 5284 addql #1,%d4
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c5d2: 4e94 jsr %a4@
start_sector++;
sector_cnt--;
4c5d4: 4fef 0010 lea %sp@(16),%sp
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c5d8: 2d40 fffc movel %d0,%fp@(-4)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4c5dc: 4aae fffc tstl %fp@(-4)
4c5e0: 6604 bnes 4c5e6 <msdos_format_fill_sectors+0xce> <== NEVER TAKEN
4c5e2: 4a8a tstl %a2
4c5e4: 66ac bnes 4c592 <msdos_format_fill_sectors+0x7a>
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
4c5e6: 4879 0006 7d44 pea 67d44 <rtems_filesystem_table+0x314>
4c5ec: 45fa fe7e lea %pc@(4c46c <msdos_format_printf>),%a2
4c5f0: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c5f4: 2f03 movel %d3,%sp@-
4c5f6: 4e92 jsr %a2@
if (ret_val)
4c5f8: 4fef 000c lea %sp@(12),%sp
4c5fc: 4aae fffc tstl %fp@(-4)
4c600: 6714 beqs 4c616 <msdos_format_fill_sectors+0xfe> <== ALWAYS TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4c602: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4c604: 4879 0006 88af pea 688af <_CPU_m68k_BFFFO_table+0x10b> <== NOT EXECUTED
4c60a: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4c60e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4c610: 4e92 jsr %a2@ <== NOT EXECUTED
4c612: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
4c616: 4a82 tstl %d2
4c618: 670a beqs 4c624 <msdos_format_fill_sectors+0x10c><== NEVER TAKEN
free(fill_buffer);
4c61a: 2f02 movel %d2,%sp@-
4c61c: 4eb9 0004 54d0 jsr 454d0 <free>
4c622: 588f addql #4,%sp
fill_buffer = NULL;
}
return ret_val;
}
4c624: 202e fffc movel %fp@(-4),%d0
4c628: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
4c62e: 4e5e unlk %fp <== NOT EXECUTED
0004c46c <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
4c46c: 4e56 0000 linkw %fp,#0
4c470: 206e 0008 moveal %fp@(8),%a0
va_list args;
va_start (args, format);
if (rqdata != NULL && rqdata->info_level >= info_level)
4c474: 4a88 tstl %a0
4c476: 6736 beqs 4c4ae <msdos_format_printf+0x42> <== NEVER TAKEN
4c478: 202e 000c movel %fp@(12),%d0
4c47c: b0a8 001c cmpl %a0@(28),%d0
4c480: 6e2c bgts 4c4ae <msdos_format_printf+0x42> <== ALWAYS TAKEN
{
vfprintf (stdout, format, args);
4c482: 486e 0014 pea %fp@(20) <== NOT EXECUTED
4c486: 2079 0006 9d6c moveal 69d6c <_impure_ptr>,%a0 <== NOT EXECUTED
4c48c: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
4c490: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
4c494: 4eb9 0006 00b8 jsr 600b8 <vfprintf> <== NOT EXECUTED
fflush (stdout);
4c49a: 2079 0006 9d6c moveal 69d6c <_impure_ptr>,%a0 <== NOT EXECUTED
4c4a0: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
4c4a4: 4eb9 0005 8f24 jsr 58f24 <fflush> <== NOT EXECUTED
4c4aa: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
va_end (args);
}
4c4ae: 4e5e unlk %fp <== NOT EXECUTED
0004c4b2 <msdos_format_write_sec>:
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4c4b2: 4280 clrl %d0
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c4b4: 4e56 0000 linkw %fp,#0
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4c4b8: 222e 000c movel %fp@(12),%d1
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c4bc: 2f03 movel %d3,%sp@-
4c4be: 262e 0010 movel %fp@(16),%d3
4c4c2: 2f02 movel %d2,%sp@-
4c4c4: 242e 0008 movel %fp@(8),%d2
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4c4c8: 42a7 clrl %sp@-
4c4ca: 2f03 movel %d3,%sp@-
4c4cc: 42a7 clrl %sp@-
4c4ce: 2f01 movel %d1,%sp@-
4c4d0: 2f00 movel %d0,%sp@-
4c4d2: 4eb9 0006 5478 jsr 65478 <__muldi3>
4c4d8: 4fef 000c lea %sp@(12),%sp
4c4dc: 2e81 movel %d1,%sp@
4c4de: 2f00 movel %d0,%sp@-
4c4e0: 2f02 movel %d2,%sp@-
4c4e2: 4eb9 0004 58b0 jsr 458b0 <lseek>
4c4e8: 4fef 0010 lea %sp@(16),%sp
4c4ec: 4a80 tstl %d0
4c4ee: 6b1a bmis 4c50a <msdos_format_write_sec+0x58> <== NEVER TAKEN
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
4c4f0: 2f03 movel %d3,%sp@-
4c4f2: 2f2e 0014 movel %fp@(20),%sp@-
4c4f6: 2f02 movel %d2,%sp@-
4c4f8: 4eb9 0004 8830 jsr 48830 <write>
4c4fe: 4fef 000c lea %sp@(12),%sp
4c502: 4a80 tstl %d0
4c504: 5dc0 slt %d0
4c506: 49c0 extbl %d0
4c508: 6002 bras 4c50c <msdos_format_write_sec+0x5a>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4c50a: 70ff moveq #-1,%d0 <== NOT EXECUTED
ret_val = -1;
}
}
return ret_val;
}
4c50c: 242e fff8 movel %fp@(-8),%d2
4c510: 262e fffc movel %fp@(-4),%d3
4c514: 4e5e unlk %fp <== NOT EXECUTED
0005571c <msdos_free_node_info>:
* RC_OK on success, or -1 code if error occured
*
*/
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
5571c: 4e56 0000 linkw %fp,#0
55720: 2f0b movel %a3,%sp@-
55722: 2f0a movel %a2,%sp@-
55724: 246e 0008 moveal %fp@(8),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
55728: 206a 0010 moveal %a2@(16),%a0
5572c: 2668 0034 moveal %a0@(52),%a3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
55730: 42a7 clrl %sp@-
55732: 42a7 clrl %sp@-
55734: 2f2b 0088 movel %a3@(136),%sp@-
55738: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
5573e: 4fef 000c lea %sp@(12),%sp
55742: 4a80 tstl %d0
55744: 6712 beqs 55758 <msdos_free_node_info+0x3c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
55746: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
5574c: 347c ffff moveaw #-1,%a2 <== NOT EXECUTED
55750: 2040 moveal %d0,%a0 <== NOT EXECUTED
55752: 7005 moveq #5,%d0 <== NOT EXECUTED
55754: 2080 movel %d0,%a0@ <== NOT EXECUTED
55756: 601c bras 55774 <msdos_free_node_info+0x58> <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
55758: 2f12 movel %a2@,%sp@-
5575a: 2f2a 0010 movel %a2@(16),%sp@-
5575e: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close>
rtems_semaphore_release(fs_info->vol_sema);
55764: 2f2b 0088 movel %a3@(136),%sp@-
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
55768: 2440 moveal %d0,%a2
rtems_semaphore_release(fs_info->vol_sema);
5576a: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
55770: 4fef 000c lea %sp@(12),%sp
}
55774: 200a movel %a2,%d0
55776: 246e fff8 moveal %fp@(-8),%a2
5577a: 266e fffc moveal %fp@(-4),%a3
5577e: 4e5e unlk %fp
...
000567ee <msdos_get_dotdot_dir_info_cluster_num_and_offset>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
567ee: 4e56 ff98 linkw %fp,#-104 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
567f2: 204e moveal %fp,%a0 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
567f4: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@ <== NOT EXECUTED
567f8: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
567fc: 42a0 clrl %a0@- <== NOT EXECUTED
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
567fe: 2c2a 0034 movel %a2@(52),%d6 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
56802: 266e 0010 moveal %fp@(16),%a3 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
56806: 2f08 movel %a0,%sp@- <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
56808: 262e 000c movel %fp@(12),%d3 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
5680c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5680e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56810: 4eb9 0004 fb18 jsr 4fb18 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
56816: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
5681a: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
5681c: 6600 0224 bnew 56a42 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x254><== NOT EXECUTED
return rc;
fat_fd->cln = cln;
56820: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
56824: 7001 moveq #1,%d0 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
56826: 227c 0020 0000 moveal #2097152,%a1 <== NOT EXECUTED
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
5682c: 2143 001c movel %d3,%a0@(28) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
56830: 2140 0010 movel %d0,%a0@(16) <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
56834: 2149 0014 movel %a1,%a0@(20) <== NOT EXECUTED
fat_fd->map.file_cln = 0;
56838: 42a8 0032 clrl %a0@(50) <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
5683c: 2143 0036 movel %d3,%a0@(54) <== NOT EXECUTED
rc = fat_file_size(mt_entry, fat_fd);
56840: 2f08 movel %a0,%sp@- <== NOT EXECUTED
56842: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56844: 4eb9 0005 04a6 jsr 504a6 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
5684a: 508f addql #8,%sp <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
5684c: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
5684e: 6600 0184 bnew 569d4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e6><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56852: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
56856: 4bee ffbc lea %fp@(-68),%a5 <== NOT EXECUTED
5685a: 2a3c 0005 957c movel #365948,%d5 <== NOT EXECUTED
56860: 2045 moveal %d5,%a0 <== NOT EXECUTED
56862: 42a7 clrl %sp@- <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
56864: 283c 0005 58bc movel #350396,%d4 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
5686a: 2f0d movel %a5,%sp@- <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
5686c: 263c 0005 5f0a movel #352010,%d3 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56872: 4e90 jsr %a0@ <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
56874: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
56878: 2244 moveal %d4,%a1 <== NOT EXECUTED
5687a: 2f0d movel %a5,%sp@- <== NOT EXECUTED
5687c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
56880: 4879 0006 74a7 pea 674a7 <_rodata_start+0x1b7> <== NOT EXECUTED
56886: 4e91 jsr %a1@ <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
56888: 2043 moveal %d3,%a0 <== NOT EXECUTED
5688a: 2f0d movel %a5,%sp@- <== NOT EXECUTED
5688c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5688e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
56892: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
56896: 4879 0006 74a7 pea 674a7 <_rodata_start+0x1b7> <== NOT EXECUTED
5689c: 42a7 clrl %sp@- <== NOT EXECUTED
5689e: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
568a2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
568a4: 4e90 jsr %a0@ <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
568a6: 4fef 003c lea %sp@(60),%sp <== NOT EXECUTED
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
568aa: 2400 movel %d0,%d2 <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
568ac: 6600 0126 bnew 569d4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e6><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
568b0: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
568b4: 49ee ffdc lea %fp@(-36),%a4 <== NOT EXECUTED
568b8: 2245 moveal %d5,%a1 <== NOT EXECUTED
568ba: 42a7 clrl %sp@- <== NOT EXECUTED
568bc: 2f0c movel %a4,%sp@- <== NOT EXECUTED
568be: 4e91 jsr %a1@ <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
568c0: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
568c4: 2044 moveal %d4,%a0 <== NOT EXECUTED
568c6: 2f0c movel %a4,%sp@- <== NOT EXECUTED
568c8: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
568cc: 4879 0006 74a6 pea 674a6 <_rodata_start+0x1b6> <== NOT EXECUTED
568d2: 4e90 jsr %a0@ <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
568d4: 2243 moveal %d3,%a1 <== NOT EXECUTED
568d6: 2f0c movel %a4,%sp@- <== NOT EXECUTED
568d8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
568da: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
568de: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
568e2: 4879 0006 74a6 pea 674a6 <_rodata_start+0x1b6> <== NOT EXECUTED
568e8: 42a7 clrl %sp@- <== NOT EXECUTED
568ea: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
568ee: 2f0a movel %a2,%sp@- <== NOT EXECUTED
568f0: 4e91 jsr %a1@ <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
568f2: 4fef 003c lea %sp@(60),%sp <== NOT EXECUTED
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
568f6: 2400 movel %d0,%d2 <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
568f8: 6600 00da bnew 569d4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e6><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
568fc: 362d 001a movew %a5@(26),%d3 <== NOT EXECUTED
56900: 382d 0014 movew %a5@(20),%d4 <== NOT EXECUTED
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
56904: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56908: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5690a: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
if ( rc != RC_OK )
56910: 508f addql #8,%sp <== NOT EXECUTED
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
56912: 2400 movel %d0,%d2 <== NOT EXECUTED
if ( rc != RC_OK )
56914: 6600 012c bnew 56a42 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x254><== NOT EXECUTED
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
56918: 4281 clrl %d1 <== NOT EXECUTED
5691a: 4282 clrl %d2 <== NOT EXECUTED
5691c: 322c 0014 movew %a4@(20),%d1 <== NOT EXECUTED
56920: 342c 001a movew %a4@(26),%d2 <== NOT EXECUTED
56924: 2001 movel %d1,%d0 <== NOT EXECUTED
56926: e089 lsrl #8,%d1 <== NOT EXECUTED
56928: e188 lsll #8,%d0 <== NOT EXECUTED
5692a: 8081 orl %d1,%d0 <== NOT EXECUTED
5692c: 2202 movel %d2,%d1 <== NOT EXECUTED
5692e: e08a lsrl #8,%d2 <== NOT EXECUTED
56930: e189 lsll #8,%d1 <== NOT EXECUTED
56932: 4840 swap %d0 <== NOT EXECUTED
56934: 4240 clrw %d0 <== NOT EXECUTED
56936: 8282 orl %d2,%d1 <== NOT EXECUTED
56938: 0281 0000 ffff andil #65535,%d1 <== NOT EXECUTED
5693e: 8081 orl %d1,%d0 <== NOT EXECUTED
56940: 6612 bnes 56954 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x166><== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
56942: 70ff moveq #-1,%d0 <== NOT EXECUTED
/*
* we handle root dir for all FAT types in the same way with the
* ordinary directories ( through fat_file_* calls )
*/
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
56944: 7a01 moveq #1,%d5 <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
56946: 42ab 0004 clrl %a3@(4) <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
5694a: 2740 0008 movel %d0,%a3@(8) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
5694e: 2740 000c movel %d0,%a3@(12) <== NOT EXECUTED
56952: 2685 movel %d5,%a3@ <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
56954: 486e fffc pea %fp@(-4) <== NOT EXECUTED
56958: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5695a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5695c: 4eb9 0004 fb18 jsr 4fb18 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
56962: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
56966: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
56968: 6600 00d8 bnew 56a42 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x254><== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
5696c: 4281 clrl %d1 <== NOT EXECUTED
5696e: 4282 clrl %d2 <== NOT EXECUTED
56970: 322e fff0 movew %fp@(-16),%d1 <== NOT EXECUTED
56974: 342e fff6 movew %fp@(-10),%d2 <== NOT EXECUTED
56978: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
5697c: 2001 movel %d1,%d0 <== NOT EXECUTED
5697e: e089 lsrl #8,%d1 <== NOT EXECUTED
56980: e188 lsll #8,%d0 <== NOT EXECUTED
56982: 8081 orl %d1,%d0 <== NOT EXECUTED
56984: 2202 movel %d2,%d1 <== NOT EXECUTED
56986: e08a lsrl #8,%d2 <== NOT EXECUTED
56988: e189 lsll #8,%d1 <== NOT EXECUTED
5698a: 4840 swap %d0 <== NOT EXECUTED
5698c: 4240 clrw %d0 <== NOT EXECUTED
5698e: 8282 orl %d2,%d1 <== NOT EXECUTED
56990: 0281 0000 ffff andil #65535,%d1 <== NOT EXECUTED
56996: 8081 orl %d1,%d0 <== NOT EXECUTED
56998: 660c bnes 569a6 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1b8><== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
5699a: 2246 moveal %d6,%a1 <== NOT EXECUTED
5699c: 43e9 0034 lea %a1@(52),%a1 <== NOT EXECUTED
569a0: 2151 001c movel %a1@,%a0@(28) <== NOT EXECUTED
569a4: 6004 bras 569aa <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1bc><== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
569a6: 2140 001c movel %d0,%a0@(28) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
569aa: 7001 moveq #1,%d0 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
569ac: 227c 0020 0000 moveal #2097152,%a1 <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
569b2: 2168 001c 0036 movel %a0@(28),%a0@(54) <== NOT EXECUTED
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
569b8: 2140 0010 movel %d0,%a0@(16) <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
569bc: 2149 0014 movel %a1,%a0@(20) <== NOT EXECUTED
fat_fd->map.file_cln = 0;
569c0: 42a8 0032 clrl %a0@(50) <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
569c4: 2f08 movel %a0,%sp@- <== NOT EXECUTED
569c6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
569c8: 4eb9 0005 04a6 jsr 504a6 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
569ce: 508f addql #8,%sp <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
569d0: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
569d2: 670e beqs 569e2 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1f4><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
569d4: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
569d8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
569da: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
569e0: 605e bras 56a40 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x252><== NOT EXECUTED
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
569e2: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
569e6: 0284 0000 ffff andil #65535,%d4 <== NOT EXECUTED
569ec: 0283 0000 ffff andil #65535,%d3 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
569f2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
569f4: 2004 movel %d4,%d0 <== NOT EXECUTED
569f6: 2203 movel %d3,%d1 <== NOT EXECUTED
569f8: e08c lsrl #8,%d4 <== NOT EXECUTED
569fa: e08b lsrl #8,%d3 <== NOT EXECUTED
569fc: e188 lsll #8,%d0 <== NOT EXECUTED
569fe: e189 lsll #8,%d1 <== NOT EXECUTED
56a00: 8084 orl %d4,%d0 <== NOT EXECUTED
56a02: 8283 orl %d3,%d1 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
56a04: 4840 swap %d0 <== NOT EXECUTED
56a06: 4240 clrw %d0 <== NOT EXECUTED
56a08: 0281 0000 ffff andil #65535,%d1 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
56a0e: 8081 orl %d1,%d0 <== NOT EXECUTED
56a10: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56a12: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56a16: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56a18: 4eb9 0005 66a4 jsr 566a4 <msdos_find_node_by_cluster_num_in_fat_file><== NOT EXECUTED
dir_pos, dir_entry);
if (rc != RC_OK)
56a1e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
56a22: 41f9 0004 feb6 lea 4feb6 <fat_file_close>,%a0 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
56a28: 2400 movel %d0,%d2 <== NOT EXECUTED
dir_pos, dir_entry);
if (rc != RC_OK)
56a2a: 670a beqs 56a36 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x248><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
56a2c: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56a30: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56a32: 4e90 jsr %a0@ <== NOT EXECUTED
56a34: 600a bras 56a40 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x252><== NOT EXECUTED
return rc;
}
rc = fat_file_close(mt_entry, fat_fd);
56a36: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56a3a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56a3c: 4e90 jsr %a0@ <== NOT EXECUTED
56a3e: 2400 movel %d0,%d2 <== NOT EXECUTED
return rc;
56a40: 508f addql #8,%sp <== NOT EXECUTED
}
56a42: 2002 movel %d2,%d0 <== NOT EXECUTED
56a44: 4cee 3c7c ff98 moveml %fp@(-104),%d2-%d6/%a2-%a5 <== NOT EXECUTED
56a4a: 4e5e unlk %fp <== NOT EXECUTED
00056a4e <msdos_get_name_node>:
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
56a4e: 4280 clrl %d0
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
56a50: 4e56 ffe8 linkw %fp,#-24
56a54: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
56a58: 266e 0020 moveal %fp@(32),%a3
56a5c: 246e 001c moveal %fp@(28),%a2
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
56a60: 2f0b movel %a3,%sp@-
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
56a62: 262e 0010 movel %fp@(16),%d3
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
56a66: 2f0a movel %a2,%sp@-
56a68: 2f2e 0018 movel %fp@(24),%sp@-
56a6c: 2f2e 0014 movel %fp@(20),%sp@-
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
56a70: 286e 0008 moveal %fp@(8),%a4
56a74: 182e 000f moveb %fp@(15),%d4
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
56a78: 2f03 movel %d3,%sp@-
56a7a: 1004 moveb %d4,%d0
56a7c: 2f00 movel %d0,%sp@-
56a7e: 2f14 movel %a4@,%sp@-
56a80: 2f2c 0010 movel %a4@(16),%sp@-
56a84: 4eb9 0005 5f0a jsr 55f0a <msdos_find_name_in_fat_file>
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
56a8a: 4fef 0020 lea %sp@(32),%sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
56a8e: 2400 movel %d0,%d2
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
56a90: 670a beqs 56a9c <msdos_get_name_node+0x4e>
56a92: 0c80 0000 7d01 cmpil #32001,%d0
56a98: 6600 008c bnew 56b26 <msdos_get_name_node+0xd8>
return rc;
if (!create_node)
56a9c: 4a04 tstb %d4
56a9e: 6600 0086 bnew 56b26 <msdos_get_name_node+0xd8>
{
/* if we search for valid name and name not found -> return */
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
56aa2: 0c82 0000 7d01 cmpil #32001,%d2
56aa8: 677c beqs 56b26 <msdos_get_name_node+0xd8>
* if we have deal with ".." - it is a special case :(((
*
* Really, we should return cluster num and offset not of ".." slot, but
* slot which correspondes to real directory name.
*/
if (rc == RC_OK)
56aaa: 4a82 tstl %d2
56aac: 6678 bnes 56b26 <msdos_get_name_node+0xd8> <== NEVER TAKEN
{
if (strncmp(name, "..", 2) == 0)
56aae: 4878 0002 pea 2 <DOUBLE_FLOAT>
56ab2: 4879 0006 74a6 pea 674a6 <_rodata_start+0x1b6>
56ab8: 2f03 movel %d3,%sp@-
56aba: 4eb9 0005 a30c jsr 5a30c <strncmp>
56ac0: 4fef 000c lea %sp@(12),%sp
56ac4: 4a80 tstl %d0
56ac6: 665e bnes 56b26 <msdos_get_name_node+0xd8>
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
56ac8: 4281 clrl %d1
56aca: 4283 clrl %d3
56acc: 322b 0014 movew %a3@(20),%d1
56ad0: 362b 001a movew %a3@(26),%d3
56ad4: 2001 movel %d1,%d0
56ad6: e089 lsrl #8,%d1
56ad8: e188 lsll #8,%d0
56ada: 8081 orl %d1,%d0
56adc: 2203 movel %d3,%d1
56ade: e08b lsrl #8,%d3
56ae0: e189 lsll #8,%d1
56ae2: 4840 swap %d0
56ae4: 4240 clrw %d0
56ae6: 8283 orl %d3,%d1
56ae8: 0281 0000 ffff andil #65535,%d1
56aee: 8081 orl %d1,%d0
/* are we right under root dir ? */
if (dotdot_cln == 0)
56af0: 6614 bnes 56b06 <msdos_get_name_node+0xb8> <== NEVER TAKEN
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
56af2: 70ff moveq #-1,%d0
56af4: 2540 0008 movel %d0,%a2@(8)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
56af8: 2540 000c movel %d0,%a2@(12)
/*
* we can relax about first_char field - it never should be
* used for root dir
*/
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
56afc: 7001 moveq #1,%d0
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
56afe: 42aa 0004 clrl %a2@(4)
56b02: 2480 movel %d0,%a2@
56b04: 6020 bras 56b26 <msdos_get_name_node+0xd8>
}
else
{
rc =
56b06: 2d4b 0014 movel %a3,%fp@(20) <== NOT EXECUTED
56b0a: 2d4a 0010 movel %a2,%fp@(16) <== NOT EXECUTED
56b0e: 2d40 000c movel %d0,%fp@(12) <== NOT EXECUTED
56b12: 2d6c 0010 0008 movel %a4@(16),%fp@(8) <== NOT EXECUTED
}
}
}
}
return rc;
}
56b18: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 <== NOT EXECUTED
56b1e: 4e5e unlk %fp <== NOT EXECUTED
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
56b20: 4ef9 0005 67ee jmp 567ee <msdos_get_dotdot_dir_info_cluster_num_and_offset><== NOT EXECUTED
}
}
}
}
return rc;
}
56b26: 2002 movel %d2,%d0
56b28: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
56b2e: 4e5e unlk %fp <== NOT EXECUTED
00055a20 <msdos_get_token>:
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
55a20: 4e56 ffdc linkw %fp,#-36
55a24: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
55a28: 2a6e 0010 moveal %fp@(16),%a5
55a2c: 286e 0014 moveal %fp@(20),%a4
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
55a30: 4295 clrl %a5@
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
55a32: 246e 0008 moveal %fp@(8),%a2
55a36: 262e 000c movel %fp@(12),%d3
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
*ret_token_len = 0;
55a3a: 4294 clrl %a4@
if (pathlen == 0)
55a3c: 4a83 tstl %d3
55a3e: 6700 0096 beqw 55ad6 <msdos_get_token+0xb6>
55a42: 264a moveal %a2,%a3
55a44: 4282 clrl %d2
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
55a46: 2a3c 0004 6a68 movel #289384,%d5
{
if ( !msdos_is_valid_name_char(path[i]) )
55a4c: 283c 0005 5850 movel #350288,%d4
55a52: 601e bras 55a72 <msdos_get_token+0x52>
55a54: 2046 moveal %d6,%a0
int i = 0;
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
55a56: 528b addql #1,%a3
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
{
if ( !msdos_is_valid_name_char(path[i]) )
55a58: 1c10 moveb %a0@,%d6
55a5a: 2044 moveal %d4,%a0
55a5c: 49c6 extbl %d6
55a5e: 2f06 movel %d6,%sp@-
55a60: 4e90 jsr %a0@
55a62: 588f addql #4,%sp
55a64: 4a80 tstl %d0
55a66: 6772 beqs 55ada <msdos_get_token+0xba> <== NEVER TAKEN
return MSDOS_INVALID_TOKEN;
++i;
55a68: 5282 addql #1,%d2
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
55a6a: 0c82 0000 0104 cmpil #260,%d2
55a70: 6768 beqs 55ada <msdos_get_token+0xba> <== NEVER TAKEN
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
55a72: 2045 moveal %d5,%a0
* RETURNS:
* token type, token and token length
*
*/
msdos_token_types_t
msdos_get_token(const char *path,
55a74: 2c0b movel %a3,%d6
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
55a76: 1013 moveb %a3@,%d0
55a78: 49c0 extbl %d0
55a7a: 2f00 movel %d0,%sp@-
55a7c: 4e90 jsr %a0@
55a7e: 588f addql #4,%sp
55a80: 4a80 tstl %d0
55a82: 6604 bnes 55a88 <msdos_get_token+0x68>
55a84: b682 cmpl %d2,%d3
55a86: 6ecc bgts 55a54 <msdos_get_token+0x34>
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
}
*ret_token = path;
55a88: 2a8a movel %a2,%a5@
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
55a8a: 4a82 tstl %d2
55a8c: 6608 bnes 55a96 <msdos_get_token+0x76>
{
if ( (*path != '\0') && pathlen )
55a8e: 4a12 tstb %a2@
55a90: 6608 bnes 55a9a <msdos_get_token+0x7a>
{
i++;
type = MSDOS_CURRENT_DIR;
}
else
type = MSDOS_NO_MORE_PATH;
55a92: 4280 clrl %d0
55a94: 6008 bras 55a9e <msdos_get_token+0x7e>
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
msdos_token_types_t type = MSDOS_NAME;
55a96: 7003 moveq #3,%d0
55a98: 6004 bras 55a9e <msdos_get_token+0x7e>
*/
if ( i == 0 )
{
if ( (*path != '\0') && pathlen )
{
i++;
55a9a: 7401 moveq #1,%d2
type = MSDOS_CURRENT_DIR;
55a9c: 7001 moveq #1,%d0
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
55a9e: 2882 movel %d2,%a4@
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
55aa0: 7203 moveq #3,%d1
55aa2: b280 cmpl %d0,%d1
55aa4: 663e bnes 55ae4 <msdos_get_token+0xc4>
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
55aa6: 123c 0002 moveb #2,%d1
55aaa: b282 cmpl %d2,%d1
55aac: 6616 bnes 55ac4 <msdos_get_token+0xa4>
55aae: 742e moveq #46,%d2
55ab0: 1212 moveb %a2@,%d1
55ab2: 49c1 extbl %d1
55ab4: b481 cmpl %d1,%d2
55ab6: 662c bnes 55ae4 <msdos_get_token+0xc4> <== NEVER TAKEN
55ab8: 122a 0001 moveb %a2@(1),%d1
55abc: 49c1 extbl %d1
55abe: b481 cmpl %d1,%d2
55ac0: 6622 bnes 55ae4 <msdos_get_token+0xc4> <== NEVER TAKEN
55ac2: 601a bras 55ade <msdos_get_token+0xbe>
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
55ac4: 7201 moveq #1,%d1
55ac6: b282 cmpl %d2,%d1
55ac8: 661a bnes 55ae4 <msdos_get_token+0xc4>
55aca: 742e moveq #46,%d2
55acc: 1212 moveb %a2@,%d1
55ace: 49c1 extbl %d1
55ad0: b481 cmpl %d1,%d2
55ad2: 6610 bnes 55ae4 <msdos_get_token+0xc4> <== NEVER TAKEN
55ad4: 600c bras 55ae2 <msdos_get_token+0xc2>
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
return MSDOS_NO_MORE_PATH;
55ad6: 4280 clrl %d0
55ad8: 600a bras 55ae4 <msdos_get_token+0xc4>
{
if ( !msdos_is_valid_name_char(path[i]) )
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
55ada: 7004 moveq #4,%d0 <== NOT EXECUTED
55adc: 6006 bras 55ae4 <msdos_get_token+0xc4> <== NOT EXECUTED
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
{
type = MSDOS_UP_DIR;
return type;
55ade: 7002 moveq #2,%d0
55ae0: 6002 bras 55ae4 <msdos_get_token+0xc4>
}
if ((i == 1) && ((*ret_token)[0] == '.'))
{
type = MSDOS_CURRENT_DIR;
return type;
55ae2: 7001 moveq #1,%d0
}
}
return type;
}
55ae4: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
55aea: 4e5e unlk %fp <== NOT EXECUTED
0004d078 <msdos_initialize_support>:
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
4d078: 4e56 ffd8 linkw %fp,#-40
4d07c: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
4d080: 4878 0090 pea 90 <DBL_MANT_DIG+0x5b>
4d084: 4878 0001 pea 1 <ADD>
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
4d088: 266e 0008 moveal %fp@(8),%a3
4d08c: 262e 0014 movel %fp@(20),%d3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
4d090: 42ae fffc clrl %fp@(-4)
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
4d094: 4eb9 0004 4e3c jsr 44e3c <calloc>
if (!fs_info)
4d09a: 508f addql #8,%sp
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
4d09c: 2440 moveal %d0,%a2
if (!fs_info)
4d09e: 4a80 tstl %d0
4d0a0: 6610 bnes 4d0b2 <msdos_initialize_support+0x3a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
4d0a2: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4d0a8: 740c moveq #12,%d2 <== NOT EXECUTED
4d0aa: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d0ac: 2082 movel %d2,%a0@ <== NOT EXECUTED
4d0ae: 6000 0124 braw 4d1d4 <msdos_initialize_support+0x15c> <== NOT EXECUTED
temp_mt_entry->fs_info = fs_info;
4d0b2: 2740 0034 movel %d0,%a3@(52)
rc = fat_init_volume_info(temp_mt_entry);
4d0b6: 2f0b movel %a3,%sp@-
4d0b8: 4eb9 0005 0d9c jsr 50d9c <fat_init_volume_info>
if (rc != RC_OK)
4d0be: 588f addql #4,%sp
if (!fs_info)
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
rc = fat_init_volume_info(temp_mt_entry);
4d0c0: 2400 movel %d0,%d2
if (rc != RC_OK)
4d0c2: 670e beqs 4d0d2 <msdos_initialize_support+0x5a> <== ALWAYS TAKEN
{
free(fs_info);
4d0c4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d0c6: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rc;
4d0cc: 588f addql #4,%sp <== NOT EXECUTED
4d0ce: 6000 016e braw 4d23e <msdos_initialize_support+0x1c6> <== NOT EXECUTED
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
4d0d2: 486e fffc pea %fp@(-4)
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4d0d6: 70ff moveq #-1,%d0
4d0d8: 486e ffec pea %fp@(-20)
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
4d0dc: 256e 0010 0084 movel %fp@(16),%a2@(132)
4d0e2: 2d40 fff4 movel %d0,%fp@(-12)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4d0e6: 2d40 fff8 movel %d0,%fp@(-8)
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
4d0ea: 7001 moveq #1,%d0
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
4d0ec: 2f0b movel %a3,%sp@-
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
fs_info->directory_handlers = directory_handlers;
4d0ee: 2543 0080 movel %d3,%a2@(128)
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
4d0f2: 42ae fff0 clrl %fp@(-16)
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
4d0f6: 2d40 ffec movel %d0,%fp@(-20)
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
4d0fa: 4eb9 0004 fb18 jsr 4fb18 <fat_file_open>
if (rc != RC_OK)
4d100: 4fef 000c lea %sp@(12),%sp
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
4d104: 2400 movel %d0,%d2
if (rc != RC_OK)
4d106: 6716 beqs 4d11e <msdos_initialize_support+0xa6> <== ALWAYS TAKEN
{
fat_shutdown_drive(temp_mt_entry);
4d108: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d10a: 4eb9 0005 0c94 jsr 50c94 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
4d110: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d112: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rc;
4d118: 508f addql #8,%sp <== NOT EXECUTED
4d11a: 6000 0122 braw 4d23e <msdos_initialize_support+0x1c6> <== NOT EXECUTED
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
4d11e: 206e fffc moveal %fp@(-4),%a0
4d122: 7001 moveq #1,%d0
4d124: 2140 0010 movel %d0,%a0@(16)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4d128: 7020 moveq #32,%d0
4d12a: 4840 swap %d0
4d12c: 2140 0014 movel %d0,%a0@(20)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4d130: 202a 0034 movel %a2@(52),%d0
fat_fd->map.file_cln = 0;
4d134: 42a8 0032 clrl %a0@(50)
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4d138: 2140 001c movel %d0,%a0@(28)
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
4d13c: 2140 0036 movel %d0,%a0@(54)
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
4d140: 6616 bnes 4d158 <msdos_initialize_support+0xe0> <== NEVER TAKEN
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
4d142: 4280 clrl %d0
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
4d144: 222a 0024 movel %a2@(36),%d1
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
4d148: 302a 0006 movew %a2@(6),%d0
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
4d14c: 2141 0018 movel %d1,%a0@(24)
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
4d150: b280 cmpl %d0,%d1
4d152: 6340 blss 4d194 <msdos_initialize_support+0x11c> <== NEVER TAKEN
4d154: 2001 movel %d1,%d0
4d156: 603c bras 4d194 <msdos_initialize_support+0x11c>
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
4d158: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4d15a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d15c: 4eb9 0005 04a6 jsr 504a6 <fat_file_size> <== NOT EXECUTED
if ( rc != RC_OK )
4d162: 508f addql #8,%sp <== NOT EXECUTED
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
4d164: 2800 movel %d0,%d4 <== NOT EXECUTED
if ( rc != RC_OK )
4d166: 6726 beqs 4d18e <msdos_initialize_support+0x116> <== NOT EXECUTED
{
fat_file_close(temp_mt_entry, fat_fd);
4d168: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
free(fs_info);
return rc;
4d16c: 2404 movel %d4,%d2 <== NOT EXECUTED
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
if ( rc != RC_OK )
{
fat_file_close(temp_mt_entry, fat_fd);
4d16e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d170: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
4d176: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d178: 4eb9 0005 0c94 jsr 50c94 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
4d17e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d180: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rc;
4d186: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d18a: 6000 00b2 braw 4d23e <msdos_initialize_support+0x1c6> <== NOT EXECUTED
}
cl_buf_size = fs_info->fat.vol.bpc;
4d18e: 4280 clrl %d0 <== NOT EXECUTED
4d190: 302a 0006 movew %a2@(6),%d0 <== NOT EXECUTED
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
4d194: 4878 0001 pea 1 <ADD>
4d198: 2f00 movel %d0,%sp@-
4d19a: 4eb9 0004 4e3c jsr 44e3c <calloc>
if (fs_info->cl_buf == NULL)
4d1a0: 508f addql #8,%sp
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
4d1a2: 2540 008c movel %d0,%a2@(140)
if (fs_info->cl_buf == NULL)
4d1a6: 6630 bnes 4d1d8 <msdos_initialize_support+0x160> <== ALWAYS TAKEN
{
fat_file_close(temp_mt_entry, fat_fd);
4d1a8: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4d1ac: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d1ae: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
4d1b4: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d1b6: 4eb9 0005 0c94 jsr 50c94 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
4d1bc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d1be: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4d1c4: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4d1ca: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d1ce: 720c moveq #12,%d1 <== NOT EXECUTED
4d1d0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d1d2: 2081 movel %d1,%a0@ <== NOT EXECUTED
4d1d4: 74ff moveq #-1,%d2 <== NOT EXECUTED
4d1d6: 6066 bras 4d23e <msdos_initialize_support+0x1c6> <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
4d1d8: 486a 0088 pea %a2@(136)
4d1dc: 42a7 clrl %sp@-
4d1de: 4878 0010 pea 10 <INVALID_OPERATION>
4d1e2: 4878 0001 pea 1 <ADD>
4d1e6: 4878 0003 pea 3 <DIVIDE>
4d1ea: 4eb9 0004 8cd4 jsr 48cd4 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
4d1f0: 4fef 0014 lea %sp@(20),%sp
4d1f4: 4a80 tstl %d0
4d1f6: 6736 beqs 4d22e <msdos_initialize_support+0x1b6> <== ALWAYS TAKEN
{
fat_file_close(temp_mt_entry, fat_fd);
4d1f8: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4d1fc: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d1fe: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
4d204: 2f0b movel %a3,%sp@- <== NOT EXECUTED
free(fs_info->cl_buf);
4d206: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
{
fat_file_close(temp_mt_entry, fat_fd);
fat_shutdown_drive(temp_mt_entry);
4d20c: 4eb9 0005 0c94 jsr 50c94 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info->cl_buf);
4d212: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED
4d216: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info);
4d218: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d21a: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4d21c: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4d222: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4d226: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d228: 7005 moveq #5,%d0 <== NOT EXECUTED
4d22a: 2080 movel %d0,%a0@ <== NOT EXECUTED
4d22c: 60a6 bras 4d1d4 <msdos_initialize_support+0x15c> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
4d22e: 2743 0024 movel %d3,%a3@(36)
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
4d232: 276e fffc 001c movel %fp@(-4),%a3@(28)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
4d238: 276e 000c 0028 movel %fp@(12),%a3@(40)
return rc;
}
4d23e: 2002 movel %d2,%d0
4d240: 4cee 0c1c ffd8 moveml %fp@(-40),%d2-%d4/%a2-%a3
4d246: 4e5e unlk %fp
...
00055850 <msdos_is_valid_name_char>:
* MSDOS_NAME_LONG - Valid in a long name only.
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
55850: 4e56 fff4 linkw %fp,#-12
55854: 48d7 040c moveml %d2-%d3/%a2,%sp@
55858: 162e 000b moveb %fp@(11),%d3
if (strchr(" +,;=[]", ch) != NULL)
5585c: 45f9 0005 9bc0 lea 59bc0 <strchr>,%a2
55862: 1403 moveb %d3,%d2
55864: 49c2 extbl %d2
55866: 2f02 movel %d2,%sp@-
55868: 4879 0006 8e62 pea 68e62 <msdos_file_handlers+0x38>
5586e: 4e92 jsr %a2@
55870: 508f addql #8,%sp
55872: 4a80 tstl %d0
55874: 6636 bnes 558ac <msdos_is_valid_name_char+0x5c> <== NEVER TAKEN
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
55876: 103c 002e moveb #46,%d0
5587a: b082 cmpl %d2,%d0
5587c: 6732 beqs 558b0 <msdos_is_valid_name_char+0x60>
5587e: 2079 0006 9d68 moveal 69d68 <__ctype_ptr__>,%a0
55884: 7207 moveq #7,%d1
55886: 0283 0000 00ff andil #255,%d3
5588c: 1030 3801 moveb %a0@(00000001,%d3:l),%d0
55890: 49c0 extbl %d0
55892: c081 andl %d1,%d0
55894: 661a bnes 558b0 <msdos_is_valid_name_char+0x60>
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
55896: 2f02 movel %d2,%sp@-
55898: 4879 0006 8e6a pea 68e6a <msdos_file_handlers+0x40>
5589e: 4e92 jsr %a2@
558a0: 508f addql #8,%sp
return MSDOS_NAME_SHORT;
558a2: 4a80 tstl %d0
558a4: 56c0 sne %d0
558a6: 49c0 extbl %d0
558a8: 4480 negl %d0
558aa: 6006 bras 558b2 <msdos_is_valid_name_char+0x62>
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
558ac: 7002 moveq #2,%d0 <== NOT EXECUTED
558ae: 6002 bras 558b2 <msdos_is_valid_name_char+0x62> <== NOT EXECUTED
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
558b0: 7001 moveq #1,%d0
return MSDOS_NAME_INVALID;
}
558b2: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
558b8: 4e5e unlk %fp <== NOT EXECUTED
000558bc <msdos_long_to_short>:
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
558bc: 4e56 ffd4 linkw %fp,#-44
558c0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
558c4: 2f2e 0014 movel %fp@(20),%sp@-
558c8: 4878 0020 pea 20 <OPER2+0xc>
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
558cc: 266e 0010 moveal %fp@(16),%a3
558d0: 246e 0008 moveal %fp@(8),%a2
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
558d4: 2f0b movel %a3,%sp@-
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
558d6: 282e 000c movel %fp@(12),%d4
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
558da: 4eb9 0005 957c jsr 5957c <memset>
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
558e0: 4fef 000c lea %sp@(12),%sp
558e4: 722e moveq #46,%d1
558e6: 1012 moveb %a2@,%d0
558e8: 49c0 extbl %d0
558ea: b280 cmpl %d0,%d1
558ec: 6620 bnes 5590e <msdos_long_to_short+0x52>
558ee: 7401 moveq #1,%d2
558f0: b484 cmpl %d4,%d2
558f2: 6608 bnes 558fc <msdos_long_to_short+0x40> <== ALWAYS TAKEN
{
sfn[0] = '.';
558f4: 16bc 002e moveb #46,%a3@ <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
558f8: 6000 0102 braw 559fc <msdos_long_to_short+0x140> <== NOT EXECUTED
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
558fc: 722e moveq #46,%d1
558fe: 102a 0001 moveb %a2@(1),%d0
55902: 49c0 extbl %d0
55904: b280 cmpl %d0,%d1
55906: 6606 bnes 5590e <msdos_long_to_short+0x52> <== NEVER TAKEN
55908: 7402 moveq #2,%d2
5590a: b484 cmpl %d4,%d2
5590c: 6708 beqs 55916 <msdos_long_to_short+0x5a> <== ALWAYS TAKEN
5590e: 284a moveal %a2,%a4
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
55910: 204a moveal %a2,%a0
55912: 4280 clrl %d0
55914: 6026 bras 5593c <msdos_long_to_short+0x80>
{
sfn[0] = sfn[1] = '.';
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
55916: 7401 moveq #1,%d2
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
55918: 702e moveq #46,%d0
5591a: 16bc 002e moveb #46,%a3@
5591e: 1740 0001 moveb %d0,%a3@(1)
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
55922: 6000 00d8 braw 559fc <msdos_long_to_short+0x140>
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
55926: 7420 moveq #32,%d2
55928: 1218 moveb %a0@+,%d1
5592a: 49c1 extbl %d1
5592c: b481 cmpl %d1,%d2
5592e: 670a beqs 5593a <msdos_long_to_short+0x7e> <== NEVER TAKEN
55930: 143c 002e moveb #46,%d2
55934: b481 cmpl %d1,%d2
55936: 6600 009a bnew 559d2 <msdos_long_to_short+0x116>
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
5593a: 5280 addql #1,%d0 <== NOT EXECUTED
5593c: b880 cmpl %d0,%d4
5593e: 6ee6 bgts 55926 <msdos_long_to_short+0x6a> <== ALWAYS TAKEN
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
55940: 6600 0090 bnew 559d2 <msdos_long_to_short+0x116> <== NOT EXECUTED
55944: 6000 00b4 braw 559fa <msdos_long_to_short+0x13e> <== NOT EXECUTED
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
55948: 2d41 fffc movel %d1,%fp@(-4)
5594c: 1006 moveb %d6,%d0
5594e: 49c0 extbl %d0
55950: 2f00 movel %d0,%sp@-
55952: 4e95 jsr %a5@
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
55954: 222e fffc movel %fp@(-4),%d1
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
55958: 588f addql #4,%sp
5595a: 2400 movel %d0,%d2
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
5595c: 6700 009e beqw 559fc <msdos_long_to_short+0x140>
55960: 7002 moveq #2,%d0
55962: b082 cmpl %d2,%d0
55964: 6700 00a8 beqw 55a0e <msdos_long_to_short+0x152>
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
55968: 103c 002e moveb #46,%d0
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
5596c: 74ff moveq #-1,%d2
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
5596e: bd80 eorl %d6,%d0
55970: 4a00 tstb %d0
55972: 57c0 seq %d0
55974: 4480 negl %d0
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
55976: b485 cmpl %d5,%d2
55978: 6712 beqs 5598c <msdos_long_to_short+0xd0> <== ALWAYS TAKEN
{
if (is_dot || ((count - dot_at) > 3))
5597a: 4a00 tstb %d0 <== NOT EXECUTED
5597c: 6600 008a bnew 55a08 <msdos_long_to_short+0x14c> <== NOT EXECUTED
55980: 2003 movel %d3,%d0 <== NOT EXECUTED
55982: 9085 subl %d5,%d0 <== NOT EXECUTED
55984: 7403 moveq #3,%d2 <== NOT EXECUTED
55986: b480 cmpl %d0,%d2 <== NOT EXECUTED
55988: 6c14 bges 5599e <msdos_long_to_short+0xe2> <== NOT EXECUTED
5598a: 607c bras 55a08 <msdos_long_to_short+0x14c> <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
5598c: 7408 moveq #8,%d2
5598e: b483 cmpl %d3,%d2
55990: 6608 bnes 5599a <msdos_long_to_short+0xde>
55992: 4a00 tstb %d0
55994: 6772 beqs 55a08 <msdos_long_to_short+0x14c> <== ALWAYS TAKEN
55996: 7a08 moveq #8,%d5 <== NOT EXECUTED
55998: 6034 bras 559ce <msdos_long_to_short+0x112> <== NOT EXECUTED
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
5599a: 4a00 tstb %d0
5599c: 6626 bnes 559c4 <msdos_long_to_short+0x108> <== NEVER TAKEN
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
5599e: 2006 movel %d6,%d0
559a0: 0680 ffff ffbf addil #-65,%d0
559a6: 7419 moveq #25,%d2
559a8: 0280 0000 00ff andil #255,%d0
559ae: b480 cmpl %d0,%d2
559b0: 6416 bccs 559c8 <msdos_long_to_short+0x10c> <== NEVER TAKEN
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
559b2: 0686 ffff ff9f addil #-97,%d6
559b8: 0286 0000 00ff andil #255,%d6
559be: b486 cmpl %d6,%d2
559c0: 640a bccs 559cc <msdos_long_to_short+0x110>
559c2: 600a bras 559ce <msdos_long_to_short+0x112>
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
559c4: 2a03 movel %d3,%d5 <== NOT EXECUTED
559c6: 6006 bras 559ce <msdos_long_to_short+0x112> <== NOT EXECUTED
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
559c8: 7e01 moveq #1,%d7 <== NOT EXECUTED
559ca: 6002 bras 559ce <msdos_long_to_short+0x112> <== NOT EXECUTED
else if ((*name >= 'a') && (*name <= 'z'))
lowercase = true;
559cc: 7201 moveq #1,%d1
count++;
559ce: 5283 addql #1,%d3
559d0: 600c bras 559de <msdos_long_to_short+0x122>
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
559d2: 4283 clrl %d3
559d4: 7aff moveq #-1,%d5
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
559d6: 4bfa fe78 lea %pc@(55850 <msdos_is_valid_name_char>),%a5
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
559da: 4207 clrb %d7
559dc: 4201 clrb %d1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
559de: 1c1c moveb %a4@+,%d6
559e0: 6706 beqs 559e8 <msdos_long_to_short+0x12c>
559e2: b883 cmpl %d3,%d4
559e4: 6e00 ff62 bgtw 55948 <msdos_long_to_short+0x8c>
count++;
name++;
}
if (lowercase && uppercase)
559e8: 4a01 tstb %d1
559ea: 6720 beqs 55a0c <msdos_long_to_short+0x150> <== NEVER TAKEN
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
559ec: 4a07 tstb %d7
559ee: 56c2 sne %d2
559f0: 7001 moveq #1,%d0
559f2: 49c2 extbl %d2
559f4: 9082 subl %d2,%d0
559f6: 2400 movel %d0,%d2
559f8: 6014 bras 55a0e <msdos_long_to_short+0x152>
if (i == lfn_len)
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
559fa: 4282 clrl %d2 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
559fc: 2002 movel %d2,%d0
559fe: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
55a04: 4e5e unlk %fp
55a06: 4e75 rts
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
55a08: 7402 moveq #2,%d2
55a0a: 6002 bras 55a0e <msdos_long_to_short+0x152>
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
55a0c: 7401 moveq #1,%d2 <== NOT EXECUTED
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
55a0e: 2f0b movel %a3,%sp@-
55a10: 2f04 movel %d4,%sp@-
55a12: 2f0a movel %a2,%sp@-
55a14: 4eb9 0005 81d2 jsr 581d2 <msdos_filename_unix2dos>
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
55a1a: 4fef 000c lea %sp@(12),%sp
55a1e: 60dc bras 559fc <msdos_long_to_short+0x140>
0004d24c <msdos_mknod>:
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
4d24c: 4e56 ffec linkw %fp,#-20
4d250: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
4d254: 266e 0018 moveal %fp@(24),%a3
4d258: 282e 000c movel %fp@(12),%d4
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4d25c: 2004 movel %d4,%d0
rtems_filesystem_location_info_t *pathloc
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
4d25e: 206b 0010 moveal %a3@(16),%a0
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4d262: 0280 0000 f000 andil #61440,%d0
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
4d268: 262e 0008 movel %fp@(8),%d3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
4d26c: 2468 0034 moveal %a0@(52),%a2
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4d270: 0c80 0000 4000 cmpil #16384,%d0
4d276: 6716 beqs 4d28e <msdos_mknod+0x42>
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
4d278: 0c80 0000 8000 cmpil #32768,%d0
4d27e: 6712 beqs 4d292 <msdos_mknod+0x46> <== ALWAYS TAKEN
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
4d280: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4d286: 7216 moveq #22,%d1 <== NOT EXECUTED
4d288: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d28a: 2081 movel %d1,%a0@ <== NOT EXECUTED
4d28c: 6028 bras 4d2b6 <msdos_mknod+0x6a> <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
4d28e: 7401 moveq #1,%d2
4d290: 6002 bras 4d294 <msdos_mknod+0x48>
}
else if (S_ISREG(mode))
{
type = MSDOS_REGULAR_FILE;
4d292: 7405 moveq #5,%d2
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4d294: 42a7 clrl %sp@-
4d296: 42a7 clrl %sp@-
4d298: 2f2a 0088 movel %a2@(136),%sp@-
4d29c: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4d2a2: 4fef 000c lea %sp@(12),%sp
4d2a6: 4a80 tstl %d0
4d2a8: 6710 beqs 4d2ba <msdos_mknod+0x6e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
4d2aa: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4d2b0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d2b2: 7005 moveq #5,%d0 <== NOT EXECUTED
4d2b4: 2080 movel %d0,%a0@ <== NOT EXECUTED
4d2b6: 74ff moveq #-1,%d2 <== NOT EXECUTED
4d2b8: 602a bras 4d2e4 <msdos_mknod+0x98> <== NOT EXECUTED
/* Create an MSDOS node */
rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
4d2ba: 2f03 movel %d3,%sp@-
4d2bc: 4eb9 0005 a2f0 jsr 5a2f0 <strlen>
4d2c2: 4297 clrl %sp@
4d2c4: 2f04 movel %d4,%sp@-
4d2c6: 2f00 movel %d0,%sp@-
4d2c8: 2f03 movel %d3,%sp@-
4d2ca: 2f02 movel %d2,%sp@-
4d2cc: 2f0b movel %a3,%sp@-
4d2ce: 4eb9 0005 4958 jsr 54958 <msdos_creat_node>
rtems_semaphore_release(fs_info->vol_sema);
4d2d4: 2f2a 0088 movel %a2@(136),%sp@-
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
/* Create an MSDOS node */
rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
4d2d8: 2400 movel %d0,%d2
rtems_semaphore_release(fs_info->vol_sema);
4d2da: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
4d2e0: 4fef 001c lea %sp@(28),%sp
}
4d2e4: 2002 movel %d2,%d0
4d2e6: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
4d2ec: 4e5e unlk %fp <== NOT EXECUTED
0004d304 <msdos_rename>:
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
4d304: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
4d308: 48d7 3c04 moveml %d2/%a2-%a5,%sp@ <== NOT EXECUTED
4d30c: 2a6e 0010 moveal %fp@(16),%a5 <== NOT EXECUTED
4d310: 266e 000c moveal %fp@(12),%a3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
4d314: 206d 0010 moveal %a5@(16),%a0 <== NOT EXECUTED
fat_file_fd_t *old_fat_fd = old_loc->node_access;
4d318: 2853 moveal %a3@,%a4 <== NOT EXECUTED
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
4d31a: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
4d31e: 242e 0014 movel %fp@(20),%d2 <== NOT EXECUTED
int len;
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
4d322: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d324: 4eb9 0005 a2f0 jsr 5a2f0 <strlen> <== NOT EXECUTED
4d32a: 588f addql #4,%sp <== NOT EXECUTED
4d32c: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4d330: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
4d334: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d336: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d338: 4eb9 0005 5a20 jsr 55a20 <msdos_get_token> <== NOT EXECUTED
4d33e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d342: 7203 moveq #3,%d1 <== NOT EXECUTED
4d344: b280 cmpl %d0,%d1 <== NOT EXECUTED
4d346: 670e beqs 4d356 <msdos_rename+0x52> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
4d348: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4d34e: 725b moveq #91,%d1 <== NOT EXECUTED
4d350: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d352: 2081 movel %d1,%a0@ <== NOT EXECUTED
4d354: 6022 bras 4d378 <msdos_rename+0x74> <== NOT EXECUTED
}
/*
* lock volume
*/
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4d356: 42a7 clrl %sp@- <== NOT EXECUTED
4d358: 42a7 clrl %sp@- <== NOT EXECUTED
4d35a: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
4d35e: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4d364: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4d368: 4a80 tstl %d0 <== NOT EXECUTED
4d36a: 6710 beqs 4d37c <msdos_rename+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4d36c: 4eb9 0005 8b98 jsr 58b98 <__errno> <== NOT EXECUTED
4d372: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d374: 7005 moveq #5,%d0 <== NOT EXECUTED
4d376: 2080 movel %d0,%a0@ <== NOT EXECUTED
4d378: 74ff moveq #-1,%d2 <== NOT EXECUTED
4d37a: 6052 bras 4d3ce <msdos_rename+0xca> <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
4d37c: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4d37e: 2f3c 0000 8000 movel #32768,%sp@- <== NOT EXECUTED
4d384: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4d388: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d38a: 4878 0003 pea 3 <DIVIDE> <== NOT EXECUTED
4d38e: 2f0d movel %a5,%sp@- <== NOT EXECUTED
4d390: 4eb9 0005 4958 jsr 54958 <msdos_creat_node> <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,len,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
4d396: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
4d39a: 2400 movel %d0,%d2 <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,len,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
4d39c: 670e beqs 4d3ac <msdos_rename+0xa8> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
4d39e: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
4d3a2: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
4d3a8: 588f addql #4,%sp <== NOT EXECUTED
4d3aa: 6022 bras 4d3ce <msdos_rename+0xca> <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
4d3ac: 4878 00e5 pea e5 <DBL_MANT_DIG+0xb0> <== NOT EXECUTED
4d3b0: 486c 0020 pea %a4@(32) <== NOT EXECUTED
4d3b4: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
4d3b8: 4eb9 0005 5cea jsr 55cea <msdos_set_first_char4file_name> <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
rtems_semaphore_release(fs_info->vol_sema);
4d3be: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
4d3c2: 2400 movel %d0,%d2 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
rtems_semaphore_release(fs_info->vol_sema);
4d3c4: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
4d3ca: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
4d3ce: 2002 movel %d2,%d0 <== NOT EXECUTED
4d3d0: 4cee 3c04 ffe4 moveml %fp@(-28),%d2/%a2-%a5 <== NOT EXECUTED
4d3d6: 4e5e unlk %fp <== NOT EXECUTED
...
00055aee <msdos_set_dir_wrt_time_and_date>:
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
55aee: 4e56 ffe0 linkw %fp,#-32
55af2: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
55af6: 246e 0008 moveal %fp@(8),%a2
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
55afa: 49ee fffc lea %fp@(-4),%a4
55afe: 260e movel %fp,%d3
55b00: 5583 subql #2,%d3
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55b02: 4282 clrl %d2
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0, ret3 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55b04: 2a6a 0034 moveal %a2@(52),%a5
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
55b08: 2f0c movel %a4,%sp@-
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
55b0a: 266e 000c moveal %fp@(12),%a3
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
55b0e: 2f03 movel %d3,%sp@-
55b10: 2f2b 003e movel %a3@(62),%sp@-
55b14: 4eb9 0005 7ff4 jsr 57ff4 <msdos_date_unix2dos>
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55b1a: 2f2b 0020 movel %a3@(32),%sp@-
55b1e: 2f2a 0034 movel %a2@(52),%sp@-
55b22: 4eba fcf4 jsr %pc@(55818 <fat_cluster_num_to_sector_num.isra.0>)
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55b26: 222b 0024 movel %a3@(36),%d1
55b2a: 142d 0002 moveb %a5@(2),%d2
55b2e: 2801 movel %d1,%d4
55b30: e4ac lsrl %d2,%d4
55b32: 2404 movel %d4,%d2
55b34: d480 addl %d0,%d2
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55b36: 4280 clrl %d0
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55b38: 508f addql #8,%sp
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55b3a: 3015 movew %a5@,%d0
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55b3c: 2f0c movel %a4,%sp@-
55b3e: 4878 0002 pea 2 <DOUBLE_FLOAT>
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55b42: 2640 moveal %d0,%a3
55b44: 538b subql #1,%a3
55b46: 200b movel %a3,%d0
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55b48: 49f9 0005 093a lea 5093a <_fat_block_write>,%a4
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55b4e: c081 andl %d1,%d0
time_val = CT_LE_W(time_val);
55b50: 4281 clrl %d1
55b52: 322e fffc movew %fp@(-4),%d1
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55b56: 2640 moveal %d0,%a3
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55b58: 486b 0016 pea %a3@(22)
static inline uint16_t m68k_swap_u16(
uint16_t value
)
{
return (((value & 0xff) << 8) | ((value >> 8) & 0xff));
55b5c: 2001 movel %d1,%d0
55b5e: e089 lsrl #8,%d1
55b60: e188 lsll #8,%d0
55b62: 2f02 movel %d2,%sp@-
55b64: 8081 orl %d1,%d0
55b66: 2f0a movel %a2,%sp@-
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
55b68: 3d40 fffc movew %d0,%fp@(-4)
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55b6c: 4e94 jsr %a4@
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
55b6e: 4fef 001c lea %sp@(28),%sp
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
55b72: 4281 clrl %d1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55b74: 2800 movel %d0,%d4
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
55b76: 2e83 movel %d3,%sp@
55b78: 4878 0002 pea 2 <DOUBLE_FLOAT>
55b7c: 486b 0018 pea %a3@(24)
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
55b80: 322e fffe movew %fp@(-2),%d1
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
55b84: 2f02 movel %d2,%sp@-
55b86: 2001 movel %d1,%d0
55b88: e089 lsrl #8,%d1
55b8a: e188 lsll #8,%d0
55b8c: 2f0a movel %a2,%sp@-
55b8e: 8081 orl %d1,%d0
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
55b90: 3d40 fffe movew %d0,%fp@(-2)
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
55b94: 4e94 jsr %a4@
55b96: 2a40 moveal %d0,%a5
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
55b98: 2f03 movel %d3,%sp@-
55b9a: 4878 0002 pea 2 <DOUBLE_FLOAT>
55b9e: 486b 0012 pea %a3@(18)
55ba2: 2f02 movel %d2,%sp@-
55ba4: 2f0a movel %a2,%sp@-
55ba6: 4e94 jsr %a4@
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
55ba8: 4fef 0028 lea %sp@(40),%sp
55bac: 4a84 tstl %d4
55bae: 6d0c blts 55bbc <msdos_set_dir_wrt_time_and_date+0xce><== NEVER TAKEN
55bb0: 4a8d tstl %a5
55bb2: 6d08 blts 55bbc <msdos_set_dir_wrt_time_and_date+0xce><== NEVER TAKEN
return -1;
55bb4: 4a80 tstl %d0
55bb6: 5dc0 slt %d0
55bb8: 49c0 extbl %d0
55bba: 6002 bras 55bbe <msdos_set_dir_wrt_time_and_date+0xd0>
55bbc: 70ff moveq #-1,%d0 <== NOT EXECUTED
return RC_OK;
}
55bbe: 4cee 3c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a5
55bc4: 4e5e unlk %fp <== NOT EXECUTED
00055cea <msdos_set_first_char4file_name>:
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
55cea: 4e56 ffcc linkw %fp,#-52 <== NOT EXECUTED
55cee: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
55cf2: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
55cf6: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
55cfa: 2028 0008 movel %a0@(8),%d0 <== NOT EXECUTED
55cfe: 2228 000c movel %a0@(12),%d1 <== NOT EXECUTED
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55d02: 246b 0034 moveal %a3@(52),%a2 <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
55d06: 2410 movel %a0@,%d2 <== NOT EXECUTED
55d08: 2e28 0004 movel %a0@(4),%d7 <== NOT EXECUTED
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
55d0c: 1d6e 0013 fff6 moveb %fp@(19),%fp@(-10) <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
55d12: 2d40 fff8 movel %d0,%fp@(-8) <== NOT EXECUTED
55d16: 2d41 fffc movel %d1,%fp@(-4) <== NOT EXECUTED
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
55d1a: b4aa 0034 cmpl %a2@(52),%d2 <== NOT EXECUTED
55d1e: 6612 bnes 55d32 <msdos_set_first_char4file_name+0x48><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
55d20: 4280 clrl %d0 <== NOT EXECUTED
55d22: 102a 000a moveb %a2@(10),%d0 <== NOT EXECUTED
55d26: 7203 moveq #3,%d1 <== NOT EXECUTED
55d28: c081 andl %d1,%d0 <== NOT EXECUTED
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
55d2a: 6706 beqs 55d32 <msdos_set_first_char4file_name+0x48><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
55d2c: 262a 0024 movel %a2@(36),%d3 <== NOT EXECUTED
55d30: 6006 bras 55d38 <msdos_set_first_char4file_name+0x4e><== NOT EXECUTED
else
dir_block_size = fs_info->fat.vol.bpc;
55d32: 4283 clrl %d3 <== NOT EXECUTED
55d34: 362a 0006 movew %a2@(6),%d3 <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
55d38: 78ff moveq #-1,%d4 <== NOT EXECUTED
55d3a: b8a8 0008 cmpl %a0@(8),%d4 <== NOT EXECUTED
55d3e: 660e bnes 55d4e <msdos_set_first_char4file_name+0x64><== NOT EXECUTED
start = dir_pos->sname;
55d40: 2010 movel %a0@,%d0 <== NOT EXECUTED
55d42: 2228 0004 movel %a0@(4),%d1 <== NOT EXECUTED
55d46: 2d40 fff8 movel %d0,%fp@(-8) <== NOT EXECUTED
55d4a: 2d41 fffc movel %d1,%fp@(-4) <== NOT EXECUTED
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
&fchar);
55d4e: 2a0e movel %fp,%d5 <== NOT EXECUTED
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
55d50: 2c3c 0005 5818 movel #350232,%d6 <== NOT EXECUTED
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
&fchar);
55d56: 0685 ffff fff6 addil #-10,%d5 <== NOT EXECUTED
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
55d5c: 4bf9 0005 093a lea 5093a <_fat_block_write>,%a5 <== NOT EXECUTED
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
55d62: 49f9 0005 708c lea 5708c <fat_get_fat_cluster>,%a4 <== NOT EXECUTED
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
55d68: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
55d6c: 2046 moveal %d6,%a0 <== NOT EXECUTED
55d6e: 2f2b 0034 movel %a3@(52),%sp@- <== NOT EXECUTED
55d72: 4e90 jsr %a0@ <== NOT EXECUTED
55d74: 508f addql #8,%sp <== NOT EXECUTED
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
55d76: 4281 clrl %d1 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
55d78: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55d7a: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
55d7e: 282e fffc movel %fp@(-4),%d4 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
55d82: 3212 movew %a2@,%d1 <== NOT EXECUTED
55d84: 2041 moveal %d1,%a0 <== NOT EXECUTED
55d86: 5388 subql #1,%a0 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
55d88: 2208 movel %a0,%d1 <== NOT EXECUTED
55d8a: 2040 moveal %d0,%a0 <== NOT EXECUTED
55d8c: c284 andl %d4,%d1 <== NOT EXECUTED
55d8e: 2f01 movel %d1,%sp@- <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
55d90: 4281 clrl %d1 <== NOT EXECUTED
55d92: 122a 0002 moveb %a2@(2),%d1 <== NOT EXECUTED
55d96: e2ac lsrl %d1,%d4 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
55d98: 4870 4800 pea %a0@(00000000,%d4:l) <== NOT EXECUTED
55d9c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55d9e: 4e95 jsr %a5@ <== NOT EXECUTED
&fchar);
if (ret < 0)
55da0: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
55da4: 4a80 tstl %d0 <== NOT EXECUTED
55da6: 6d4c blts 55df4 <msdos_set_first_char4file_name+0x10a><== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
55da8: 222e fff8 movel %fp@(-8),%d1 <== NOT EXECUTED
55dac: b481 cmpl %d1,%d2 <== NOT EXECUTED
55dae: 6606 bnes 55db6 <msdos_set_first_char4file_name+0xcc><== NOT EXECUTED
55db0: beae fffc cmpl %fp@(-4),%d7 <== NOT EXECUTED
55db4: 6742 beqs 55df8 <msdos_set_first_char4file_name+0x10e><== NOT EXECUTED
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
55db6: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
55dba: 0680 0000 0020 addil #32,%d0 <== NOT EXECUTED
55dc0: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
if (start.ofs >= dir_block_size)
55dc4: b680 cmpl %d0,%d3 <== NOT EXECUTED
55dc6: 62a0 bhis 55d68 <msdos_set_first_char4file_name+0x7e><== NOT EXECUTED
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
55dc8: b4aa 0034 cmpl %a2@(52),%d2 <== NOT EXECUTED
55dcc: 660c bnes 55dda <msdos_set_first_char4file_name+0xf0><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
55dce: 4280 clrl %d0 <== NOT EXECUTED
55dd0: 102a 000a moveb %a2@(10),%d0 <== NOT EXECUTED
55dd4: 7803 moveq #3,%d4 <== NOT EXECUTED
55dd6: c084 andl %d4,%d0 <== NOT EXECUTED
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
55dd8: 661e bnes 55df8 <msdos_set_first_char4file_name+0x10e><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
55dda: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
55dde: 2f01 movel %d1,%sp@- <== NOT EXECUTED
55de0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55de2: 4e94 jsr %a4@ <== NOT EXECUTED
if ( rc != RC_OK )
55de4: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55de8: 4a80 tstl %d0 <== NOT EXECUTED
55dea: 660e bnes 55dfa <msdos_set_first_char4file_name+0x110><== NOT EXECUTED
return rc;
start.ofs = 0;
55dec: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
55df0: 6000 ff76 braw 55d68 <msdos_set_first_char4file_name+0x7e><== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
&fchar);
if (ret < 0)
return -1;
55df4: 70ff moveq #-1,%d0 <== NOT EXECUTED
55df6: 6002 bras 55dfa <msdos_set_first_char4file_name+0x110><== NOT EXECUTED
return rc;
start.ofs = 0;
}
}
return RC_OK;
55df8: 4280 clrl %d0 <== NOT EXECUTED
}
55dfa: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5 <== NOT EXECUTED
55e00: 4e5e unlk %fp <== NOT EXECUTED
00055bc8 <msdos_set_first_cluster_num>:
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
55bc8: 4e56 ffe4 linkw %fp,#-28
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
55bcc: 4240 clrw %d0
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
55bce: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
55bd2: 286e 000c moveal %fp@(12),%a4
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55bd6: 4282 clrl %d2
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
55bd8: 246e 0008 moveal %fp@(8),%a2
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
55bdc: 262c 001c movel %a4@(28),%d3
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55be0: 266a 0034 moveal %a2@(52),%a3
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55be4: 2f2c 0020 movel %a4@(32),%sp@-
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
55be8: 3d40 fffc movew %d0,%fp@(-4)
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55bec: 2f0b movel %a3,%sp@-
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
uint16_t le_cl_hi = 0;
55bee: 3d40 fffe movew %d0,%fp@(-2)
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55bf2: 4eba fc24 jsr %pc@(55818 <fat_cluster_num_to_sector_num.isra.0>)
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55bf6: 222c 0024 movel %a4@(36),%d1
55bfa: 142b 0002 moveb %a3@(2),%d2
55bfe: 2801 movel %d1,%d4
55c00: e4ac lsrl %d2,%d4
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55c02: 4282 clrl %d2
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55c04: 508f addql #8,%sp
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55c06: 2840 moveal %d0,%a4
55c08: d9c4 addal %d4,%a4
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55c0a: 3413 movew %a3@,%d2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
55c0c: 486e fffc pea %fp@(-4)
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55c10: 5382 subql #1,%d2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
55c12: 4878 0002 pea 2 <DOUBLE_FLOAT>
55c16: 47f9 0005 093a lea 5093a <_fat_block_write>,%a3
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55c1c: c481 andl %d1,%d2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
55c1e: 4281 clrl %d1
55c20: 3203 movew %d3,%d1
ret1 = _fat_block_write(mt_entry, sec,
55c22: 2042 moveal %d2,%a0
55c24: 4868 001a pea %a0@(26)
55c28: 2001 movel %d1,%d0
55c2a: e089 lsrl #8,%d1
55c2c: e188 lsll #8,%d0
55c2e: 2f0c movel %a4,%sp@-
55c30: 8081 orl %d1,%d0
55c32: 2f0a movel %a2,%sp@-
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
55c34: 3d40 fffc movew %d0,%fp@(-4)
ret1 = _fat_block_write(mt_entry, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
55c38: 4243 clrw %d3
55c3a: 4843 swap %d3
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
55c3c: 4e93 jsr %a3@
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
55c3e: 204e moveal %fp,%a0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
55c40: 2800 movel %d0,%d4
55c42: 2003 movel %d3,%d0
55c44: e08b lsrl #8,%d3
55c46: e188 lsll #8,%d0
55c48: 8083 orl %d3,%d0
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
55c4a: 3100 movew %d0,%a0@-
ret2 = _fat_block_write(mt_entry, sec,
55c4c: 2f08 movel %a0,%sp@-
55c4e: 4878 0002 pea 2 <DOUBLE_FLOAT>
55c52: 2042 moveal %d2,%a0
55c54: 4868 0014 pea %a0@(20)
55c58: 2f0c movel %a4,%sp@-
55c5a: 2f0a movel %a2,%sp@-
55c5c: 4e93 jsr %a3@
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
55c5e: 4fef 0028 lea %sp@(40),%sp
55c62: 4a84 tstl %d4
55c64: 6d08 blts 55c6e <msdos_set_first_cluster_num+0xa6><== NEVER TAKEN
return -1;
55c66: 4a80 tstl %d0
55c68: 5dc0 slt %d0
55c6a: 49c0 extbl %d0
55c6c: 6002 bras 55c70 <msdos_set_first_cluster_num+0xa8>
55c6e: 70ff moveq #-1,%d0 <== NOT EXECUTED
return RC_OK;
}
55c70: 4cee 1c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a4
55c76: 4e5e unlk %fp <== NOT EXECUTED
00055784 <msdos_shut_down>:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
55784: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
55788: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
5578c: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
55790: 266a 0034 moveal %a2@(52),%a3 <== NOT EXECUTED
fat_file_fd_t *fat_fd = temp_mt_entry->mt_fs_root.node_access;
/* close fat-file which correspondes to root directory */
if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)
55794: 2f2a 001c movel %a2@(28),%sp@- <== NOT EXECUTED
55798: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5579a: 4eb9 0004 feb6 jsr 4feb6 <fat_file_close> <== NOT EXECUTED
557a0: 508f addql #8,%sp <== NOT EXECUTED
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
int rc = RC_OK;
557a2: 4a80 tstl %d0 <== NOT EXECUTED
557a4: 56c2 sne %d2 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
557a6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
int rc = RC_OK;
557a8: 49c2 extbl %d2 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
557aa: 4eb9 0005 0c94 jsr 50c94 <fat_shutdown_drive> <== NOT EXECUTED
557b0: 588f addql #4,%sp <== NOT EXECUTED
557b2: 4a80 tstl %d0 <== NOT EXECUTED
557b4: 6702 beqs 557b8 <msdos_shut_down+0x34> <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
557b6: 74ff moveq #-1,%d2 <== NOT EXECUTED
}
rtems_semaphore_delete(fs_info->vol_sema);
557b8: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
557bc: 4eb9 0004 8e74 jsr 48e74 <rtems_semaphore_delete> <== NOT EXECUTED
free(fs_info->cl_buf);
557c2: 2f2b 008c movel %a3@(140),%sp@- <== NOT EXECUTED
557c6: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
557cc: 4e93 jsr %a3@ <== NOT EXECUTED
free(temp_mt_entry->fs_info);
557ce: 2f2a 0034 movel %a2@(52),%sp@- <== NOT EXECUTED
557d2: 4e93 jsr %a3@ <== NOT EXECUTED
return rc;
}
557d4: 2002 movel %d2,%d0 <== NOT EXECUTED
557d6: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
557dc: 4e5e unlk %fp <== NOT EXECUTED
00043546 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
43546: 4e56 fff4 linkw %fp,#-12
4354a: 48d7 040c moveml %d2-%d3/%a2,%sp@
4354e: 262e 0008 movel %fp@(8),%d3
43552: 246e 000c moveal %fp@(12),%a2
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
43556: b5c3 cmpal %d3,%a2
43558: 6608 bnes 43562 <newlib_delete_hook+0x1c>
ptr = _REENT;
4355a: 2439 0005 d4e8 movel 5d4e8 <_impure_ptr>,%d2
43560: 6004 bras 43566 <newlib_delete_hook+0x20>
} else {
ptr = deleted_task->libc_reent;
43562: 242a 00fa movel %a2@(250),%d2
}
if (ptr && ptr != _global_impure_ptr) {
43566: 4a82 tstl %d2
43568: 6722 beqs 4358c <newlib_delete_hook+0x46> <== NEVER TAKEN
4356a: b4b9 0005 c9ee cmpl 5c9ee <_global_impure_ptr>,%d2
43570: 671a beqs 4358c <newlib_delete_hook+0x46>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
43572: 4879 0004 3358 pea 43358 <newlib_free_buffers>
43578: 2f02 movel %d2,%sp@-
4357a: 4eb9 0004 d4b8 jsr 4d4b8 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
43580: 2f02 movel %d2,%sp@-
43582: 4eb9 0004 8c2c jsr 48c2c <_Workspace_Free>
43588: 4fef 000c lea %sp@(12),%sp
#endif
}
deleted_task->libc_reent = NULL;
4358c: 42aa 00fa clrl %a2@(250)
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
43590: b5c3 cmpal %d3,%a2
43592: 6606 bnes 4359a <newlib_delete_hook+0x54>
_REENT = 0;
43594: 42b9 0005 d4e8 clrl 5d4e8 <_impure_ptr>
}
}
4359a: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
435a0: 4e5e unlk %fp <== NOT EXECUTED
00043358 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
43358: 4e56 0000 linkw %fp,#0
4335c: 2f0a movel %a2,%sp@-
4335e: 246e 0008 moveal %fp@(8),%a2
switch ( fileno(fp) ) {
43362: 2f0a movel %a2,%sp@-
43364: 4eb9 0004 d12c jsr 4d12c <fileno>
4336a: 588f addql #4,%sp
4336c: 7202 moveq #2,%d1
4336e: b280 cmpl %d0,%d1
43370: 6528 bcss 4339a <newlib_free_buffers+0x42> <== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
43372: 302a 000c movew %a2@(12),%d0
43376: 48c0 extl %d0
43378: 4a00 tstb %d0
4337a: 6c28 bges 433a4 <newlib_free_buffers+0x4c> <== ALWAYS TAKEN
free( fp->_bf._base );
4337c: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
43380: 4eb9 0004 2b68 jsr 42b68 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
43386: 302a 000c movew %a2@(12),%d0 <== NOT EXECUTED
4338a: 0880 0007 bclr #7,%d0 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
4338e: 4292 clrl %a2@ <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
43390: 3540 000c movew %d0,%a2@(12) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
43394: 42aa 0010 clrl %a2@(16) <== NOT EXECUTED
43398: 6008 bras 433a2 <newlib_free_buffers+0x4a> <== NOT EXECUTED
}
break;
default:
fclose(fp);
4339a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4339c: 4eb9 0004 ce9c jsr 4ce9c <fclose> <== NOT EXECUTED
433a2: 588f addql #4,%sp <== NOT EXECUTED
}
return 0;
}
433a4: 246e fffc moveal %fp@(-4),%a2
433a8: 4280 clrl %d0
433aa: 4e5e unlk %fp <== NOT EXECUTED
000413c2 <notify>:
void
notify (s)
char *s;
{
413c2: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
413c6: 2f2e 0008 movel %fp@(8),%sp@- <== NOT EXECUTED
413ca: 4879 0006 9586 pea 69586 <rtems_filesystem_table+0x30e> <== NOT EXECUTED
413d0: 4eb9 0005 c138 jsr 5c138 <printf> <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
413d6: 508f addql #8,%sp <== NOT EXECUTED
413d8: 203c 0006 95ad movel #431533,%d0 <== NOT EXECUTED
413de: 2d40 0008 movel %d0,%fp@(8) <== NOT EXECUTED
}
413e2: 4e5e unlk %fp <== NOT EXECUTED
void
notify (s)
char *s;
{
printf ("%s test appears to be inconsistent...\n", s);
printf (" PLEASE NOTIFY KARPINKSI!\n");
413e4: 4ef9 0005 c232 jmp 5c232 <puts> <== NOT EXECUTED
00043614 <open>:
int open(
const char *pathname,
int flags,
...
)
{
43614: 4e56 ffc8 linkw %fp,#-56
43618: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4361c: 242e 000c movel %fp@(12),%d2
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
43620: 2002 movel %d2,%d0
43622: 5280 addql #1,%d0
int open(
const char *pathname,
int flags,
...
)
{
43624: 262e 0008 movel %fp@(8),%d3
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
43628: 0800 0000 btst #0,%d0
4362c: 6704 beqs 43632 <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_READ;
4362e: 7804 moveq #4,%d4
43630: 6002 bras 43634 <open+0x20>
int eval_flags;
/*
* Set the Evaluation flags
*/
eval_flags = 0;
43632: 4284 clrl %d4
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
43634: 0800 0001 btst #1,%d0
43638: 6704 beqs 4363e <open+0x2a>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
4363a: 7002 moveq #2,%d0
4363c: 8880 orl %d0,%d4
va_start(ap, flags);
mode = va_arg( ap, int );
4363e: 2c2e 0010 movel %fp@(16),%d6
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
43642: 4eb9 0004 9ef4 jsr 49ef4 <rtems_libio_allocate>
43648: 2440 moveal %d0,%a2
if ( iop == 0 ) {
4364a: 4a80 tstl %d0
4364c: 6700 0158 beqw 437a6 <open+0x192>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
43650: 2f03 movel %d3,%sp@-
43652: 4bf9 0004 e0d4 lea 4e0d4 <strlen>,%a5
43658: 7a01 moveq #1,%d5
4365a: 49f9 0004 2a88 lea 42a88 <rtems_filesystem_evaluate_path>,%a4
43660: 4e95 jsr %a5@
43662: 2e85 movel %d5,%sp@
43664: 2a0e movel %fp,%d5
43666: 0685 ffff ffec addil #-20,%d5
4366c: 2f05 movel %d5,%sp@-
4366e: 2f04 movel %d4,%sp@-
43670: 2f00 movel %d0,%sp@-
43672: 2f03 movel %d3,%sp@-
43674: 4e94 jsr %a4@
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
43676: 4fef 0014 lea %sp@(20),%sp
4367a: 72ff moveq #-1,%d1
4367c: b280 cmpl %d0,%d1
4367e: 665e bnes 436de <open+0xca>
if ( errno != ENOENT ) {
43680: 47f9 0004 cd68 lea 4cd68 <__errno>,%a3
43686: 4e93 jsr %a3@
43688: 7202 moveq #2,%d1
4368a: 2040 moveal %d0,%a0
4368c: b290 cmpl %a0@,%d1
4368e: 6624 bnes 436b4 <open+0xa0>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
43690: 0802 0009 btst #9,%d2
43694: 6700 0114 beqw 437aa <open+0x196>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
43698: 42a7 clrl %sp@-
4369a: 2006 movel %d6,%d0
4369c: 42a7 clrl %sp@-
4369e: 08c0 000f bset #15,%d0
436a2: 2f00 movel %d0,%sp@-
436a4: 2f03 movel %d3,%sp@-
436a6: 4eb9 0004 2f20 jsr 42f20 <mknod>
if ( rc ) {
436ac: 4fef 0010 lea %sp@(16),%sp
436b0: 4a80 tstl %d0
436b2: 670c beqs 436c0 <open+0xac> <== ALWAYS TAKEN
rc = errno;
436b4: 4e93 jsr %a3@
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
436b6: 4285 clrl %d5
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
436b8: 2040 moveal %d0,%a0
436ba: 2410 movel %a0@,%d2
goto done;
436bc: 6000 00fc braw 437ba <open+0x1a6>
/*
* After we do the mknod(), we have to evaluate the path to get the
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
436c0: 2f03 movel %d3,%sp@-
436c2: 4e95 jsr %a5@
436c4: 7201 moveq #1,%d1
436c6: 2e81 movel %d1,%sp@
436c8: 2f05 movel %d5,%sp@-
436ca: 42a7 clrl %sp@-
436cc: 2f00 movel %d0,%sp@-
436ce: 2f03 movel %d3,%sp@-
436d0: 4e94 jsr %a4@
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
436d2: 4fef 0014 lea %sp@(20),%sp
436d6: 4a80 tstl %d0
436d8: 6600 00d6 bnew 437b0 <open+0x19c>
436dc: 6012 bras 436f0 <open+0xdc>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
436de: 2002 movel %d2,%d0
436e0: 0280 0000 0a00 andil #2560,%d0
436e6: 0c80 0000 0a00 cmpil #2560,%d0
436ec: 6700 00c8 beqw 437b6 <open+0x1a2>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
436f0: 282a 0014 movel %a2@(20),%d4
iop->pathinfo = loc;
436f4: 2a0e movel %fp,%d5
436f6: 0685 ffff ffec addil #-20,%d5
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
436fc: 2f02 movel %d2,%sp@-
436fe: 4eb9 0004 9e66 jsr 49e66 <rtems_libio_fcntl_flags>
43704: 8084 orl %d4,%d0
43706: 2540 0014 movel %d0,%a2@(20)
iop->pathinfo = loc;
4370a: 4878 0014 pea 14 <OPER2>
4370e: 2f05 movel %d5,%sp@-
43710: 486a 0018 pea %a2@(24)
43714: 4eb9 0004 d588 jsr 4d588 <memcpy>
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
4371a: 206a 0020 moveal %a2@(32),%a0
4371e: 2f06 movel %d6,%sp@-
43720: 2f02 movel %d2,%sp@-
43722: 2f03 movel %d3,%sp@-
43724: 2f0a movel %a2,%sp@-
43726: 2050 moveal %a0@,%a0
43728: 4e90 jsr %a0@
if ( rc ) {
4372a: 4fef 0020 lea %sp@(32),%sp
4372e: 4a80 tstl %d0
43730: 670c beqs 4373e <open+0x12a>
rc = errno;
43732: 4eb9 0004 cd68 jsr 4cd68 <__errno>
43738: 2040 moveal %d0,%a0
4373a: 2410 movel %a0@,%d2
goto done;
4373c: 607c bras 437ba <open+0x1a6>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
4373e: 0802 000a btst #10,%d2
43742: 6700 00a4 beqw 437e8 <open+0x1d4>
rc = ftruncate( iop - rtems_libio_iops, 0 );
43746: 200a movel %a2,%d0
43748: 90b9 0005 ea44 subl 5ea44 <rtems_libio_iops>,%d0
4374e: 223c b6db 6db7 movel #-1227133513,%d1
43754: e680 asrl #3,%d0
43756: 4c00 1800 mulsl %d0,%d1
4375a: 42a7 clrl %sp@-
4375c: 42a7 clrl %sp@-
4375e: 2f01 movel %d1,%sp@-
43760: 4eb9 0004 9d5c jsr 49d5c <ftruncate>
if ( rc ) {
43766: 4fef 000c lea %sp@(12),%sp
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
4376a: 2400 movel %d0,%d2
if ( rc ) {
4376c: 677a beqs 437e8 <open+0x1d4>
if(errno) rc = errno;
4376e: 47f9 0004 cd68 lea 4cd68 <__errno>,%a3
43774: 4e93 jsr %a3@
43776: 2040 moveal %d0,%a0
43778: 4a90 tstl %a0@
4377a: 6706 beqs 43782 <open+0x16e> <== NEVER TAKEN
4377c: 4e93 jsr %a3@
4377e: 2040 moveal %d0,%a0
43780: 2410 movel %a0@,%d2
close( iop - rtems_libio_iops );
43782: 200a movel %a2,%d0
43784: 90b9 0005 ea44 subl 5ea44 <rtems_libio_iops>,%d0
4378a: 223c b6db 6db7 movel #-1227133513,%d1
43790: e680 asrl #3,%d0
43792: 4c00 1800 mulsl %d0,%d1
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
43796: 4285 clrl %d5
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
/* those are released by close(): */
iop = 0;
43798: 95ca subal %a2,%a2
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
4379a: 2f01 movel %d1,%sp@-
4379c: 4eb9 0004 9cd8 jsr 49cd8 <close>
437a2: 588f addql #4,%sp
437a4: 6014 bras 437ba <open+0x1a6>
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
437a6: 7417 moveq #23,%d2
437a8: 6030 bras 437da <open+0x1c6>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
437aa: 4285 clrl %d5
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
437ac: 7402 moveq #2,%d2
437ae: 600e bras 437be <open+0x1aa>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
437b0: 4285 clrl %d5
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
437b2: 740d moveq #13,%d2
437b4: 6008 bras 437be <open+0x1aa>
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
437b6: 7411 moveq #17,%d2
437b8: 6004 bras 437be <open+0x1aa>
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
437ba: 4a82 tstl %d2
437bc: 672a beqs 437e8 <open+0x1d4> <== NEVER TAKEN
if ( iop )
437be: 4a8a tstl %a2
437c0: 670a beqs 437cc <open+0x1b8>
rtems_libio_free( iop );
437c2: 2f0a movel %a2,%sp@-
437c4: 4eb9 0004 9f86 jsr 49f86 <rtems_libio_free>
437ca: 588f addql #4,%sp
if ( loc_to_free )
437cc: 4a85 tstl %d5
437ce: 670a beqs 437da <open+0x1c6>
rtems_filesystem_freenode( loc_to_free );
437d0: 2f05 movel %d5,%sp@-
437d2: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
437d8: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( rc );
437da: 4eb9 0004 cd68 jsr 4cd68 <__errno>
437e0: 2040 moveal %d0,%a0
437e2: 70ff moveq #-1,%d0
437e4: 2082 movel %d2,%a0@
437e6: 6014 bras 437fc <open+0x1e8>
}
return iop - rtems_libio_iops;
437e8: 200a movel %a2,%d0
437ea: 90b9 0005 ea44 subl 5ea44 <rtems_libio_iops>,%d0
437f0: 223c b6db 6db7 movel #-1227133513,%d1
437f6: e680 asrl #3,%d0
437f8: 4c01 0800 mulsl %d1,%d0
}
437fc: 4cee 3c7c ffc8 moveml %fp@(-56),%d2-%d6/%a2-%a5
43802: 4e5e unlk %fp <== NOT EXECUTED
000435a4 <open_dev_console>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void open_dev_console(void)
{
435a4: 4e56 0000 linkw %fp,#0
435a8: 2f0a movel %a2,%sp@-
int stderr_fd;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
435aa: 45f9 0004 3614 lea 43614 <open>,%a2
435b0: 42a7 clrl %sp@-
435b2: 42a7 clrl %sp@-
435b4: 4879 0005 bcc8 pea 5bcc8 <CSWTCH.48+0x100>
435ba: 4e92 jsr %a2@
435bc: 4fef 000c lea %sp@(12),%sp
435c0: 72ff moveq #-1,%d1
435c2: b280 cmpl %d0,%d1
435c4: 6744 beqs 4360a <open_dev_console+0x66>
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
435c6: 42a7 clrl %sp@-
435c8: 4878 0001 pea 1 <ADD>
435cc: 4879 0005 bcc8 pea 5bcc8 <CSWTCH.48+0x100>
435d2: 4e92 jsr %a2@
435d4: 4fef 000c lea %sp@(12),%sp
435d8: 72ff moveq #-1,%d1
435da: b280 cmpl %d0,%d1
435dc: 6608 bnes 435e6 <open_dev_console+0x42>
rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */
435de: 2f3c 5554 4431 movel #1431585841,%sp@-
435e4: 601e bras 43604 <open_dev_console+0x60>
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
435e6: 42a7 clrl %sp@-
435e8: 4878 0001 pea 1 <ADD>
435ec: 4879 0005 bcc8 pea 5bcc8 <CSWTCH.48+0x100>
435f2: 4e92 jsr %a2@
435f4: 4fef 000c lea %sp@(12),%sp
435f8: 72ff moveq #-1,%d1
435fa: b280 cmpl %d0,%d1
435fc: 660c bnes 4360a <open_dev_console+0x66> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 0x55544432 ); /* error STD2 */
435fe: 2f3c 5554 4432 movel #1431585842,%sp@- <== NOT EXECUTED
43604: 4eb9 0004 60a4 jsr 460a4 <rtems_fatal_error_occurred>
}
4360a: 246e fffc moveal %fp@(-4),%a2
4360e: 4e5e unlk %fp
...
0004431e <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4431e: 4e56 fff0 linkw %fp,#-16
44322: 48d7 040c moveml %d2-%d3/%a2,%sp@
44326: 246e 000c moveal %fp@(12),%a2
4432a: 242e 0008 movel %fp@(8),%d2
int i;
if (tty->termios.c_oflag & OPOST) {
4432e: 202a 0034 movel %a2@(52),%d0
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
44332: 1d42 fffe moveb %d2,%fp@(-2)
int i;
if (tty->termios.c_oflag & OPOST) {
44336: 0800 0000 btst #0,%d0
4433a: 6700 0106 beqw 44442 <oproc+0x124>
switch (c) {
4433e: 4281 clrl %d1
44340: 1202 moveb %d2,%d1
44342: 7609 moveq #9,%d3
44344: b681 cmpl %d1,%d3
44346: 6778 beqs 443c0 <oproc+0xa2>
44348: 650e bcss 44358 <oproc+0x3a>
4434a: 163c 0008 moveb #8,%d3
4434e: b681 cmpl %d1,%d3
44350: 6600 00aa bnew 443fc <oproc+0xde>
44354: 6000 0098 braw 443ee <oproc+0xd0> <== NOT EXECUTED
44358: 760a moveq #10,%d3
4435a: b681 cmpl %d1,%d3
4435c: 670c beqs 4436a <oproc+0x4c>
4435e: 163c 000d moveb #13,%d3
44362: b681 cmpl %d1,%d3
44364: 6600 0096 bnew 443fc <oproc+0xde>
44368: 602e bras 44398 <oproc+0x7a> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
4436a: 0800 0005 btst #5,%d0
4436e: 6704 beqs 44374 <oproc+0x56> <== ALWAYS TAKEN
tty->column = 0;
44370: 42aa 0028 clrl %a2@(40) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
44374: 44c0 movew %d0,%ccr
44376: 6600 00ca bnew 44442 <oproc+0x124>
rtems_termios_puts ("\r", 1, tty);
4437a: 2f0a movel %a2,%sp@-
4437c: 4878 0001 pea 1 <ADD>
44380: 4879 0005 c322 pea 5c322 <rtems_filesystem_default_pathconf+0xa6>
44386: 4eb9 0004 4230 jsr 44230 <rtems_termios_puts>
tty->column = 0;
4438c: 4fef 000c lea %sp@(12),%sp
44390: 42aa 0028 clrl %a2@(40)
44394: 6000 00ac braw 44442 <oproc+0x124>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
44398: 0800 0004 btst #4,%d0 <== NOT EXECUTED
4439c: 6708 beqs 443a6 <oproc+0x88> <== NOT EXECUTED
4439e: 4aaa 0028 tstl %a2@(40) <== NOT EXECUTED
443a2: 6700 00b2 beqw 44456 <oproc+0x138> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
443a6: 44c0 movew %d0,%ccr <== NOT EXECUTED
443a8: 6a0e bpls 443b8 <oproc+0x9a> <== NOT EXECUTED
c = '\n';
443aa: 720a moveq #10,%d1 <== NOT EXECUTED
443ac: 1d41 fffe moveb %d1,%fp@(-2) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
443b0: 0800 0005 btst #5,%d0 <== NOT EXECUTED
443b4: 6700 008c beqw 44442 <oproc+0x124> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
443b8: 42aa 0028 clrl %a2@(40) <== NOT EXECUTED
break;
443bc: 6000 0084 braw 44442 <oproc+0x124> <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
443c0: 222a 0028 movel %a2@(40),%d1
443c4: 7407 moveq #7,%d2
443c6: 307c 0008 moveaw #8,%a0
443ca: c481 andl %d1,%d2
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
443cc: 0280 0000 1800 andil #6144,%d0
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
443d2: 91c2 subal %d2,%a0
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
443d4: d288 addl %a0,%d1
443d6: 2541 0028 movel %d1,%a2@(40)
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
443da: 0c80 0000 1800 cmpil #6144,%d0
443e0: 6660 bnes 44442 <oproc+0x124> <== NEVER TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
443e2: 2f0a movel %a2,%sp@-
443e4: 2f08 movel %a0,%sp@-
443e6: 4879 0005 c324 pea 5c324 <rtems_filesystem_default_pathconf+0xa8>
443ec: 605e bras 4444c <oproc+0x12e>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
443ee: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED
443f2: 6f4e bles 44442 <oproc+0x124> <== NOT EXECUTED
tty->column--;
443f4: 5380 subql #1,%d0 <== NOT EXECUTED
443f6: 2540 0028 movel %d0,%a2@(40) <== NOT EXECUTED
443fa: 6046 bras 44442 <oproc+0x124> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
443fc: 0800 0001 btst #1,%d0
44400: 6724 beqs 44426 <oproc+0x108> <== ALWAYS TAKEN
c = toupper(c);
44402: 4280 clrl %d0 <== NOT EXECUTED
44404: 1002 moveb %d2,%d0 <== NOT EXECUTED
44406: 7403 moveq #3,%d2 <== NOT EXECUTED
44408: 7602 moveq #2,%d3 <== NOT EXECUTED
4440a: 2079 0005 d4e4 moveal 5d4e4 <__ctype_ptr__>,%a0 <== NOT EXECUTED
44410: 1230 0801 moveb %a0@(00000001,%d0:l),%d1 <== NOT EXECUTED
44414: 49c1 extbl %d1 <== NOT EXECUTED
44416: c282 andl %d2,%d1 <== NOT EXECUTED
44418: b681 cmpl %d1,%d3 <== NOT EXECUTED
4441a: 6606 bnes 44422 <oproc+0x104> <== NOT EXECUTED
4441c: 0680 ffff ffe0 addil #-32,%d0 <== NOT EXECUTED
44422: 1d40 fffe moveb %d0,%fp@(-2) <== NOT EXECUTED
if (!iscntrl(c))
44426: 4280 clrl %d0
44428: 102e fffe moveb %fp@(-2),%d0
4442c: 2079 0005 d4e4 moveal 5d4e4 <__ctype_ptr__>,%a0
44432: 1030 0801 moveb %a0@(00000001,%d0:l),%d0
44436: 49c0 extbl %d0
44438: 0800 0005 btst #5,%d0
4443c: 6604 bnes 44442 <oproc+0x124> <== NEVER TAKEN
tty->column++;
4443e: 52aa 0028 addql #1,%a2@(40)
break;
}
}
rtems_termios_puts (&c, 1, tty);
44442: 2f0a movel %a2,%sp@-
44444: 4878 0001 pea 1 <ADD>
44448: 486e fffe pea %fp@(-2)
4444c: 4eb9 0004 4230 jsr 44230 <rtems_termios_puts>
44452: 4fef 000c lea %sp@(12),%sp
}
44456: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
4445c: 4e5e unlk %fp <== NOT EXECUTED
0004a9b4 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
4a9b4: 4e56 ffe4 linkw %fp,#-28
4a9b8: 48d7 040c moveml %d2-%d3/%a2,%sp@
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
4a9bc: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
4a9c0: 4879 0005 d980 pea 5d980 <_CPU_m68k_BFFFO_table+0x100>
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
4a9c6: 246e 0008 moveal %fp@(8),%a2
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
4a9ca: 4eb9 0004 bef8 jsr 4bef8 <rtems_mkdir>
4a9d0: 508f addql #8,%sp
4a9d2: 4a80 tstl %d0
4a9d4: 6600 00e8 bnew 4aabe <pipe_create+0x10a>
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
4a9d8: 4878 000a pea a <LASTO>
4a9dc: 260e movel %fp,%d3
4a9de: 4879 0005 d985 pea 5d985 <_CPU_m68k_BFFFO_table+0x105>
4a9e4: 0683 ffff fff1 addil #-15,%d3
4a9ea: 2f03 movel %d3,%sp@-
4a9ec: 4eb9 0004 ec24 jsr 4ec24 <memcpy>
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4a9f2: 3039 0005 f6c8 movew 5f6c8 <rtems_pipe_no>,%d0
4a9f8: 2200 movel %d0,%d1
4a9fa: 5281 addql #1,%d1
4a9fc: 3f00 movew %d0,%sp@-
4a9fe: 33c1 0005 f6c8 movew %d1,5f6c8 <rtems_pipe_no>
4aa04: 4267 clrw %sp@-
4aa06: 4879 0005 d990 pea 5d990 <_CPU_m68k_BFFFO_table+0x110>
4aa0c: 486e fffb pea %fp@(-5)
4aa10: 4eb9 0004 f0a0 jsr 4f0a0 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4aa16: 4878 0180 pea 180 <DBL_MANT_DIG+0x14b>
4aa1a: 2f03 movel %d3,%sp@-
4aa1c: 4eb9 0004 bcb4 jsr 4bcb4 <mkfifo>
4aa22: 4fef 0020 lea %sp@(32),%sp
4aa26: 4a80 tstl %d0
4aa28: 670a beqs 4aa34 <pipe_create+0x80>
if (errno != EEXIST){
4aa2a: 4eb9 0004 e404 jsr 4e404 <__errno>
4aa30: 6000 008c braw 4aabe <pipe_create+0x10a>
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
4aa34: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
4aa38: 2f03 movel %d3,%sp@-
4aa3a: 4eb9 0004 4738 jsr 44738 <open>
if (filsdes[0] < 0) {
4aa40: 508f addql #8,%sp
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
4aa42: 2480 movel %d0,%a2@
if (filsdes[0] < 0) {
4aa44: 6c0e bges 4aa54 <pipe_create+0xa0>
err = errno;
4aa46: 4eb9 0004 e404 jsr 4e404 <__errno>
4aa4c: 2040 moveal %d0,%a0
4aa4e: 2410 movel %a0@,%d2
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
4aa50: 2f03 movel %d3,%sp@-
4aa52: 6054 bras 4aaa8 <pipe_create+0xf4>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
4aa54: b0b9 0005 e632 cmpl 5e632 <rtems_libio_number_iops>,%d0
4aa5a: 6412 bccs 4aa6e <pipe_create+0xba> <== NEVER TAKEN
4aa5c: 2200 movel %d0,%d1
4aa5e: ed88 lsll #6,%d0
4aa60: e789 lsll #3,%d1
4aa62: 2079 0005 fdbc moveal 5fdbc <rtems_libio_iops>,%a0
4aa68: 9081 subl %d1,%d0
4aa6a: d1c0 addal %d0,%a0
4aa6c: 6002 bras 4aa70 <pipe_create+0xbc>
4aa6e: 91c8 subal %a0,%a0 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
4aa70: 70fe moveq #-2,%d0
4aa72: c1a8 0014 andl %d0,%a0@(20)
filsdes[1] = open(fifopath, O_WRONLY);
4aa76: 4878 0001 pea 1 <ADD>
4aa7a: 486e fff1 pea %fp@(-15)
4aa7e: 4eb9 0004 4738 jsr 44738 <open>
if (filsdes[1] < 0) {
4aa84: 508f addql #8,%sp
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
4aa86: 2540 0004 movel %d0,%a2@(4)
if (filsdes[1] < 0) {
4aa8a: 6c16 bges 4aaa2 <pipe_create+0xee>
err = errno;
4aa8c: 4eb9 0004 e404 jsr 4e404 <__errno>
4aa92: 2040 moveal %d0,%a0
4aa94: 2410 movel %a0@,%d2
close(filsdes[0]);
4aa96: 2f12 movel %a2@,%sp@-
4aa98: 4eb9 0004 3638 jsr 43638 <close>
4aa9e: 588f addql #4,%sp
4aaa0: 6002 bras 4aaa4 <pipe_create+0xf0>
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
4aaa2: 4282 clrl %d2
if (filsdes[1] < 0) {
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
4aaa4: 486e fff1 pea %fp@(-15)
4aaa8: 4eb9 0004 62e0 jsr 462e0 <unlink>
4aaae: 588f addql #4,%sp
}
if(err != 0)
4aab0: 4a82 tstl %d2
4aab2: 670e beqs 4aac2 <pipe_create+0x10e>
rtems_set_errno_and_return_minus_one(err);
4aab4: 4eb9 0004 e404 jsr 4e404 <__errno>
4aaba: 2040 moveal %d0,%a0
4aabc: 2082 movel %d2,%a0@
4aabe: 70ff moveq #-1,%d0
4aac0: 6002 bras 4aac4 <pipe_create+0x110>
return 0;
4aac2: 4280 clrl %d0
}
4aac4: 4cee 040c ffe4 moveml %fp@(-28),%d2-%d3/%a2
4aaca: 4e5e unlk %fp
...
0004bdee <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4bdee: 4e56 0000 linkw %fp,#0
if (cmd == FIONREAD) {
4bdf2: 203c 4004 667f movel #1074030207,%d0
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4bdf8: 2f0b movel %a3,%sp@-
4bdfa: 266e 0010 moveal %fp@(16),%a3
4bdfe: 2f0a movel %a2,%sp@-
4be00: 246e 0008 moveal %fp@(8),%a2
if (cmd == FIONREAD) {
4be04: b0ae 000c cmpl %fp@(12),%d0
4be08: 662e bnes 4be38 <pipe_ioctl+0x4a>
if (buffer == NULL)
4be0a: 4a8b tstl %a3
4be0c: 672e beqs 4be3c <pipe_ioctl+0x4e>
return -EFAULT;
if (! PIPE_LOCK(pipe))
4be0e: 42a7 clrl %sp@-
4be10: 42a7 clrl %sp@-
4be12: 2f2a 0028 movel %a2@(40),%sp@-
4be16: 4eb9 0004 766c jsr 4766c <rtems_semaphore_obtain>
4be1c: 4fef 000c lea %sp@(12),%sp
4be20: 4a80 tstl %d0
4be22: 661c bnes 4be40 <pipe_ioctl+0x52> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4be24: 26aa 000c movel %a2@(12),%a3@
PIPE_UNLOCK(pipe);
4be28: 2f2a 0028 movel %a2@(40),%sp@-
4be2c: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
return 0;
4be32: 588f addql #4,%sp
4be34: 4280 clrl %d0
4be36: 600a bras 4be42 <pipe_ioctl+0x54>
}
return -EINVAL;
4be38: 70ea moveq #-22,%d0
4be3a: 6006 bras 4be42 <pipe_ioctl+0x54>
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
4be3c: 70f2 moveq #-14,%d0
4be3e: 6002 bras 4be42 <pipe_ioctl+0x54>
if (! PIPE_LOCK(pipe))
return -EINTR;
4be40: 70fc moveq #-4,%d0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
4be42: 246e fff8 moveal %fp@(-8),%a2
4be46: 266e fffc moveal %fp@(-4),%a3
4be4a: 4e5e unlk %fp <== NOT EXECUTED
0004bb02 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4bb02: 4e56 ffd4 linkw %fp,#-44
4bb06: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4bb0a: 42a7 clrl %sp@-
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4bb0c: 246e 0008 moveal %fp@(8),%a2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4bb10: 2e3c 0004 766c movel #292460,%d7
4bb16: 2047 moveal %d7,%a0
4bb18: 42a7 clrl %sp@-
4bb1a: 2f2a 0028 movel %a2@(40),%sp@-
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4bb1e: 286e 000c moveal %fp@(12),%a4
4bb22: 2a2e 0010 movel %fp@(16),%d5
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4bb26: 4e90 jsr %a0@
4bb28: 4fef 000c lea %sp@(12),%sp
4bb2c: 4a80 tstl %d0
4bb2e: 6600 011a bnew 4bc4a <pipe_read+0x148>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
4bb32: 2c0e movel %fp,%d6
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4bb34: 4282 clrl %d2
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4bb36: 47f9 0004 f918 lea 4f918 <memcpy>,%a3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
4bb3c: 5986 subql #4,%d6
4bb3e: 4bf9 0004 d040 lea 4d040 <rtems_barrier_release>,%a5
4bb44: 6000 00e2 braw 4bc28 <pipe_read+0x126>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4bb48: 4aaa 0014 tstl %a2@(20)
4bb4c: 6700 00e0 beqw 4bc2e <pipe_read+0x12c>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4bb50: 206e 0014 moveal %fp@(20),%a0
4bb54: 7001 moveq #1,%d0
4bb56: c0a8 0014 andl %a0@(20),%d0
4bb5a: 6600 00d6 bnew 4bc32 <pipe_read+0x130>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
4bb5e: 52aa 0018 addql #1,%a2@(24)
PIPE_UNLOCK(pipe);
4bb62: 2f2a 0028 movel %a2@(40),%sp@-
4bb66: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
4bb6c: 42a7 clrl %sp@-
4bb6e: 2f2a 002c movel %a2@(44),%sp@-
4bb72: 4eb9 0004 d0a4 jsr 4d0a4 <rtems_barrier_wait>
4bb78: 4fef 000c lea %sp@(12),%sp
4bb7c: 4a80 tstl %d0
4bb7e: 6604 bnes 4bb84 <pipe_read+0x82> <== NEVER TAKEN
4bb80: 4283 clrl %d3
4bb82: 6002 bras 4bb86 <pipe_read+0x84>
ret = -EINTR;
4bb84: 76fc moveq #-4,%d3 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
4bb86: 42a7 clrl %sp@-
4bb88: 2047 moveal %d7,%a0
4bb8a: 42a7 clrl %sp@-
4bb8c: 2f2a 0028 movel %a2@(40),%sp@-
4bb90: 4e90 jsr %a0@
4bb92: 4fef 000c lea %sp@(12),%sp
4bb96: 4a80 tstl %d0
4bb98: 6600 00a8 bnew 4bc42 <pipe_read+0x140>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
4bb9c: 53aa 0018 subql #1,%a2@(24)
if (ret != 0)
4bba0: 4a83 tstl %d3
4bba2: 6600 0090 bnew 4bc34 <pipe_read+0x132>
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
4bba6: 262a 000c movel %a2@(12),%d3
4bbaa: 679c beqs 4bb48 <pipe_read+0x46>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
4bbac: 2005 movel %d5,%d0
4bbae: 9082 subl %d2,%d0
4bbb0: b083 cmpl %d3,%d0
4bbb2: 6402 bccs 4bbb6 <pipe_read+0xb4>
4bbb4: 2600 movel %d0,%d3
chunk1 = pipe->Size - pipe->Start;
4bbb6: 222a 0008 movel %a2@(8),%d1
4bbba: 200c movel %a4,%d0
4bbbc: d082 addl %d2,%d0
4bbbe: 282a 0004 movel %a2@(4),%d4
4bbc2: 9881 subl %d1,%d4
4bbc4: d292 addl %a2@,%d1
if (chunk > chunk1) {
4bbc6: b883 cmpl %d3,%d4
4bbc8: 6c20 bges 4bbea <pipe_read+0xe8>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4bbca: 2f04 movel %d4,%sp@-
4bbcc: 2f01 movel %d1,%sp@-
4bbce: 2f00 movel %d0,%sp@-
4bbd0: 4e93 jsr %a3@
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4bbd2: 2203 movel %d3,%d1
4bbd4: 9284 subl %d4,%d1
4bbd6: 2002 movel %d2,%d0
4bbd8: d084 addl %d4,%d0
4bbda: 2f01 movel %d1,%sp@-
4bbdc: 2f12 movel %a2@,%sp@-
4bbde: 4874 0800 pea %a4@(00000000,%d0:l)
4bbe2: 4e93 jsr %a3@
4bbe4: 4fef 0018 lea %sp@(24),%sp
4bbe8: 600c bras 4bbf6 <pipe_read+0xf4>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4bbea: 2f03 movel %d3,%sp@-
4bbec: 2f01 movel %d1,%sp@-
4bbee: 2f00 movel %d0,%sp@-
4bbf0: 4e93 jsr %a3@
4bbf2: 4fef 000c lea %sp@(12),%sp
pipe->Start += chunk;
4bbf6: 2003 movel %d3,%d0
4bbf8: d0aa 0008 addl %a2@(8),%d0
pipe->Start %= pipe->Size;
4bbfc: 4c6a 0001 0004 remul %a2@(4),%d1,%d0
pipe->Length -= chunk;
4bc02: 202a 000c movel %a2@(12),%d0
4bc06: 9083 subl %d3,%d0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
4bc08: 2541 0008 movel %d1,%a2@(8)
pipe->Length -= chunk;
4bc0c: 2540 000c movel %d0,%a2@(12)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
4bc10: 6604 bnes 4bc16 <pipe_read+0x114>
pipe->Start = 0;
4bc12: 42aa 0008 clrl %a2@(8)
if (pipe->waitingWriters > 0)
4bc16: 4aaa 001c tstl %a2@(28)
4bc1a: 670a beqs 4bc26 <pipe_read+0x124>
PIPE_WAKEUPWRITERS(pipe);
4bc1c: 2f06 movel %d6,%sp@-
4bc1e: 2f2a 0030 movel %a2@(48),%sp@-
4bc22: 4e95 jsr %a5@
4bc24: 508f addql #8,%sp
read += chunk;
4bc26: d483 addl %d3,%d2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
4bc28: ba82 cmpl %d2,%d5
4bc2a: 6200 ff7a bhiw 4bba6 <pipe_read+0xa4>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4bc2e: 4283 clrl %d3
4bc30: 6002 bras 4bc34 <pipe_read+0x132>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
4bc32: 76f5 moveq #-11,%d3
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
4bc34: 2f2a 0028 movel %a2@(40),%sp@-
4bc38: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
4bc3e: 588f addql #4,%sp
4bc40: 6002 bras 4bc44 <pipe_read+0x142>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
4bc42: 76fc moveq #-4,%d3 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
4bc44: 4a82 tstl %d2
4bc46: 6e08 bgts 4bc50 <pipe_read+0x14e>
4bc48: 6004 bras 4bc4e <pipe_read+0x14c>
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
4bc4a: 74fc moveq #-4,%d2 <== NOT EXECUTED
4bc4c: 6002 bras 4bc50 <pipe_read+0x14e> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
return read;
return ret;
4bc4e: 2403 movel %d3,%d2
}
4bc50: 2002 movel %d2,%d0
4bc52: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4bc58: 4e5e unlk %fp <== NOT EXECUTED
0004b694 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b694: 4e56 fff0 linkw %fp,#-16
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b698: 206e 000c moveal %fp@(12),%a0
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b69c: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4b6a0: 266e 0008 moveal %fp@(8),%a3
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b6a4: 7406 moveq #6,%d2
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
4b6a6: 2453 moveal %a3@,%a2
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b6a8: c4a8 0014 andl %a0@(20),%d2
if (mode & LIBIO_FLAGS_READ)
4b6ac: 0802 0001 btst #1,%d2
4b6b0: 6704 beqs 4b6b6 <pipe_release+0x22>
pipe->Readers --;
4b6b2: 53aa 0010 subql #1,%a2@(16)
if (mode & LIBIO_FLAGS_WRITE)
4b6b6: 44c2 movew %d2,%ccr
4b6b8: 6604 bnes 4b6be <pipe_release+0x2a>
pipe->Writers --;
4b6ba: 53aa 0014 subql #1,%a2@(20)
PIPE_UNLOCK(pipe);
4b6be: 2f2a 0028 movel %a2@(40),%sp@-
4b6c2: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
4b6c8: 588f addql #4,%sp
4b6ca: 4aaa 0010 tstl %a2@(16)
4b6ce: 6622 bnes 4b6f2 <pipe_release+0x5e>
4b6d0: 4aaa 0014 tstl %a2@(20)
4b6d4: 660c bnes 4b6e2 <pipe_release+0x4e>
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
4b6d6: 2f0a movel %a2,%sp@-
4b6d8: 4eba ff72 jsr %pc@(4b64c <pipe_free>)
*pipep = NULL;
4b6dc: 588f addql #4,%sp
4b6de: 4293 clrl %a3@
4b6e0: 602c bras 4b70e <pipe_release+0x7a>
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4b6e2: 7004 moveq #4,%d0
4b6e4: b082 cmpl %d2,%d0
4b6e6: 670a beqs 4b6f2 <pipe_release+0x5e> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
4b6e8: 486e fffc pea %fp@(-4)
4b6ec: 2f2a 0030 movel %a2@(48),%sp@-
4b6f0: 6014 bras 4b706 <pipe_release+0x72>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
4b6f2: 4aaa 0014 tstl %a2@(20)
4b6f6: 6616 bnes 4b70e <pipe_release+0x7a> <== NEVER TAKEN
4b6f8: 7002 moveq #2,%d0
4b6fa: b082 cmpl %d2,%d0
4b6fc: 6710 beqs 4b70e <pipe_release+0x7a> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4b6fe: 486e fffc pea %fp@(-4)
4b702: 2f2a 002c movel %a2@(44),%sp@-
4b706: 4eb9 0004 d040 jsr 4d040 <rtems_barrier_release>
4b70c: 508f addql #8,%sp
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
4b70e: 2f39 0006 04a8 movel 604a8 <pipe_semaphore>,%sp@-
4b714: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
4b71a: 588f addql #4,%sp
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
4b71c: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4b722: 4e5e unlk %fp <== NOT EXECUTED
0004bc5c <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4bc5c: 4e56 ffd4 linkw %fp,#-44
4bc60: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4bc64: 246e 0008 moveal %fp@(8),%a2
4bc68: 286e 000c moveal %fp@(12),%a4
4bc6c: 282e 0010 movel %fp@(16),%d4
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4bc70: 6700 0166 beqw 4bdd8 <pipe_write+0x17c>
return 0;
if (! PIPE_LOCK(pipe))
4bc74: 42a7 clrl %sp@-
4bc76: 42a7 clrl %sp@-
4bc78: 2f2a 0028 movel %a2@(40),%sp@-
4bc7c: 4eb9 0004 766c jsr 4766c <rtems_semaphore_obtain>
4bc82: 4fef 000c lea %sp@(12),%sp
4bc86: 4a80 tstl %d0
4bc88: 6600 0152 bnew 4bddc <pipe_write+0x180>
return -EINTR;
if (pipe->Readers == 0) {
4bc8c: 4aaa 0010 tstl %a2@(16)
4bc90: 6700 010a beqw 4bd9c <pipe_write+0x140>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
4bc94: b8aa 0004 cmpl %a2@(4),%d4
4bc98: 6204 bhis 4bc9e <pipe_write+0x42> <== NEVER TAKEN
4bc9a: 2a04 movel %d4,%d5
4bc9c: 6002 bras 4bca0 <pipe_write+0x44>
4bc9e: 7a01 moveq #1,%d5 <== NOT EXECUTED
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
4bca0: 4282 clrl %d2
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
4bca2: 2e3c 0004 d0a4 movel #315556,%d7
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4bca8: 47f9 0004 f918 lea 4f918 <memcpy>,%a3
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
4bcae: 4bf9 0004 d040 lea 4d040 <rtems_barrier_release>,%a5
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4bcb4: 2c3c 0004 766c movel #292460,%d6
4bcba: 6000 00d8 braw 4bd94 <pipe_write+0x138>
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
4bcbe: 206e 0014 moveal %fp@(20),%a0
4bcc2: 7001 moveq #1,%d0
4bcc4: c0a8 0014 andl %a0@(20),%d0
4bcc8: 6600 00d8 bnew 4bda2 <pipe_write+0x146>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
4bccc: 52aa 001c addql #1,%a2@(28)
PIPE_UNLOCK(pipe);
4bcd0: 2f2a 0028 movel %a2@(40),%sp@-
4bcd4: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
4bcda: 2047 moveal %d7,%a0
4bcdc: 42a7 clrl %sp@-
4bcde: 2f2a 0030 movel %a2@(48),%sp@-
4bce2: 4e90 jsr %a0@
4bce4: 4fef 000c lea %sp@(12),%sp
4bce8: 4a80 tstl %d0
4bcea: 6604 bnes 4bcf0 <pipe_write+0x94> <== NEVER TAKEN
4bcec: 4283 clrl %d3
4bcee: 6002 bras 4bcf2 <pipe_write+0x96>
ret = -EINTR;
4bcf0: 76fc moveq #-4,%d3 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
4bcf2: 42a7 clrl %sp@-
4bcf4: 2046 moveal %d6,%a0
4bcf6: 42a7 clrl %sp@-
4bcf8: 2f2a 0028 movel %a2@(40),%sp@-
4bcfc: 4e90 jsr %a0@
4bcfe: 4fef 000c lea %sp@(12),%sp
4bd02: 4a80 tstl %d0
4bd04: 6600 00ca bnew 4bdd0 <pipe_write+0x174>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
4bd08: 53aa 001c subql #1,%a2@(28)
if (ret != 0)
4bd0c: 4a83 tstl %d3
4bd0e: 6600 0098 bnew 4bda8 <pipe_write+0x14c>
goto out_locked;
if (pipe->Readers == 0) {
4bd12: 4aaa 0010 tstl %a2@(16)
4bd16: 6700 008e beqw 4bda6 <pipe_write+0x14a>
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
4bd1a: 202a 0004 movel %a2@(4),%d0
4bd1e: 2600 movel %d0,%d3
4bd20: 222a 000c movel %a2@(12),%d1
4bd24: 9681 subl %d1,%d3
4bd26: ba83 cmpl %d3,%d5
4bd28: 6294 bhis 4bcbe <pipe_write+0x62>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
4bd2a: 2044 moveal %d4,%a0
4bd2c: 91c2 subal %d2,%a0
4bd2e: b1c3 cmpal %d3,%a0
4bd30: 6402 bccs 4bd34 <pipe_write+0xd8>
4bd32: 2608 movel %a0,%d3
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4bd34: 2a01 movel %d1,%d5
4bd36: daaa 0008 addl %a2@(8),%d5
4bd3a: 4c40 5001 remul %d0,%d1,%d5
4bd3e: 2a00 movel %d0,%d5
4bd40: 9a81 subl %d1,%d5
4bd42: 2012 movel %a2@,%d0
4bd44: d081 addl %d1,%d0
4bd46: 220c movel %a4,%d1
4bd48: d282 addl %d2,%d1
if (chunk > chunk1) {
4bd4a: ba83 cmpl %d3,%d5
4bd4c: 6c20 bges 4bd6e <pipe_write+0x112>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4bd4e: 2f05 movel %d5,%sp@-
4bd50: 2f01 movel %d1,%sp@-
4bd52: 2f00 movel %d0,%sp@-
4bd54: 4e93 jsr %a3@
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4bd56: 2203 movel %d3,%d1
4bd58: 9285 subl %d5,%d1
4bd5a: 2005 movel %d5,%d0
4bd5c: d082 addl %d2,%d0
4bd5e: 2f01 movel %d1,%sp@-
4bd60: 4874 0800 pea %a4@(00000000,%d0:l)
4bd64: 2f12 movel %a2@,%sp@-
4bd66: 4e93 jsr %a3@
4bd68: 4fef 0018 lea %sp@(24),%sp
4bd6c: 600c bras 4bd7a <pipe_write+0x11e>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4bd6e: 2f03 movel %d3,%sp@-
4bd70: 2f01 movel %d1,%sp@-
4bd72: 2f00 movel %d0,%sp@-
4bd74: 4e93 jsr %a3@
4bd76: 4fef 000c lea %sp@(12),%sp
pipe->Length += chunk;
4bd7a: d7aa 000c addl %d3,%a2@(12)
if (pipe->waitingReaders > 0)
4bd7e: 4aaa 0018 tstl %a2@(24)
4bd82: 670c beqs 4bd90 <pipe_write+0x134>
PIPE_WAKEUPREADERS(pipe);
4bd84: 486e fffc pea %fp@(-4)
4bd88: 2f2a 002c movel %a2@(44),%sp@-
4bd8c: 4e95 jsr %a5@
4bd8e: 508f addql #8,%sp
written += chunk;
4bd90: d483 addl %d3,%d2
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
4bd92: 7a01 moveq #1,%d5
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
4bd94: b882 cmpl %d2,%d4
4bd96: 6282 bhis 4bd1a <pipe_write+0xbe>
4bd98: 4283 clrl %d3
4bd9a: 600c bras 4bda8 <pipe_write+0x14c>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
4bd9c: 76e0 moveq #-32,%d3
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
int chunk, chunk1, written = 0, ret = 0;
4bd9e: 4282 clrl %d2
4bda0: 6006 bras 4bda8 <pipe_write+0x14c>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
4bda2: 76f5 moveq #-11,%d3
4bda4: 6002 bras 4bda8 <pipe_write+0x14c>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
4bda6: 76e0 moveq #-32,%d3 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
4bda8: 2f2a 0028 movel %a2@(40),%sp@-
4bdac: 4eb9 0004 7778 jsr 47778 <rtems_semaphore_release>
4bdb2: 588f addql #4,%sp
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
4bdb4: 70e0 moveq #-32,%d0
4bdb6: b083 cmpl %d3,%d0
4bdb8: 6618 bnes 4bdd2 <pipe_write+0x176>
kill(getpid(), SIGPIPE);
4bdba: 4eb9 0004 c5bc jsr 4c5bc <getpid>
4bdc0: 4878 000d pea d <OPER1+0x1>
4bdc4: 2f00 movel %d0,%sp@-
4bdc6: 4eb9 0004 c85c jsr 4c85c <kill>
4bdcc: 508f addql #8,%sp
4bdce: 6002 bras 4bdd2 <pipe_write+0x176>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
4bdd0: 76fc moveq #-4,%d3 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4bdd2: 4a82 tstl %d2
4bdd4: 6e0c bgts 4bde2 <pipe_write+0x186>
4bdd6: 6008 bras 4bde0 <pipe_write+0x184>
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
4bdd8: 4282 clrl %d2 <== NOT EXECUTED
4bdda: 6006 bras 4bde2 <pipe_write+0x186> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
4bddc: 74fc moveq #-4,%d2 <== NOT EXECUTED
4bdde: 6002 bras 4bde2 <pipe_write+0x186> <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4bde0: 2403 movel %d3,%d2
return written;
return ret;
}
4bde2: 2002 movel %d2,%d0
4bde4: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4bdea: 4e5e unlk %fp <== NOT EXECUTED
00046cac <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
46cac: 4e56 0000 linkw %fp,#0
46cb0: 202e 000c movel %fp@(12),%d0
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
46cb4: 2200 movel %d0,%d1
46cb6: 5381 subql #1,%d1
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
46cb8: 52b9 0006 4060 addql #1,64060 <rtems_malloc_statistics+0x8>
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
46cbe: c280 andl %d0,%d1
46cc0: 6610 bnes 46cd2 <posix_memalign+0x26> <== NEVER TAKEN
46cc2: 123c 0003 moveb #3,%d1
46cc6: b280 cmpl %d0,%d1
46cc8: 6408 bccs 46cd2 <posix_memalign+0x26>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
46cca: 4e5e unlk %fp
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
46ccc: 4ef9 0004 6e4c jmp 46e4c <rtems_memalign>
}
46cd2: 7016 moveq #22,%d0
46cd4: 4e5e unlk %fp <== NOT EXECUTED
0004a3e8 <pthread_attr_getstack>:
int pthread_attr_getstack(
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
4a3e8: 4e56 0000 linkw %fp,#0
4a3ec: 206e 0008 moveal %fp@(8),%a0
4a3f0: 2f0a movel %a2,%sp@-
4a3f2: 246e 000c moveal %fp@(12),%a2
4a3f6: 226e 0010 moveal %fp@(16),%a1
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
4a3fa: 4a88 tstl %a0
4a3fc: 6718 beqs 4a416 <pthread_attr_getstack+0x2e> <== NEVER TAKEN
4a3fe: 4a90 tstl %a0@
4a400: 6714 beqs 4a416 <pthread_attr_getstack+0x2e>
4a402: 4a8a tstl %a2
4a404: 6710 beqs 4a416 <pthread_attr_getstack+0x2e>
4a406: 4a89 tstl %a1
4a408: 670c beqs 4a416 <pthread_attr_getstack+0x2e>
return EINVAL;
*stackaddr = attr->stackaddr;
4a40a: 24a8 0004 movel %a0@(4),%a2@
*stacksize = attr->stacksize;
return 0;
4a40e: 4280 clrl %d0
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
4a410: 22a8 0008 movel %a0@(8),%a1@
return 0;
4a414: 6002 bras 4a418 <pthread_attr_getstack+0x30>
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
4a416: 7016 moveq #22,%d0
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
4a418: 245f moveal %sp@+,%a2
4a41a: 4e5e unlk %fp
...
0004a52c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
4a52c: 4e56 0000 linkw %fp,#0
4a530: 206e 0008 moveal %fp@(8),%a0
4a534: 222e 000c movel %fp@(12),%d1
4a538: 2f02 movel %d2,%sp@-
if ( !attr || !attr->is_initialized )
4a53a: 4a88 tstl %a0
4a53c: 671e beqs 4a55c <pthread_attr_setschedpolicy+0x30>
4a53e: 4a90 tstl %a0@
4a540: 671a beqs 4a55c <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
4a542: 7004 moveq #4,%d0
4a544: b081 cmpl %d1,%d0
4a546: 6518 bcss 4a560 <pthread_attr_setschedpolicy+0x34>
4a548: 103c 0001 moveb #1,%d0
4a54c: 7417 moveq #23,%d2
4a54e: e3a8 lsll %d1,%d0
4a550: c082 andl %d2,%d0
4a552: 670c beqs 4a560 <pthread_attr_setschedpolicy+0x34><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
4a554: 2141 0014 movel %d1,%a0@(20)
return 0;
4a558: 4280 clrl %d0
4a55a: 600a bras 4a566 <pthread_attr_setschedpolicy+0x3a>
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
4a55c: 7016 moveq #22,%d0
4a55e: 6006 bras 4a566 <pthread_attr_setschedpolicy+0x3a>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
4a560: 203c 0000 0086 movel #134,%d0
}
}
4a566: 241f movel %sp@+,%d2
4a568: 4e5e unlk %fp <== NOT EXECUTED
00045bac <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
45bac: 4e56 ffe0 linkw %fp,#-32
45bb0: 206e 000c moveal %fp@(12),%a0
45bb4: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
45bb8: 246e 0008 moveal %fp@(8),%a2
45bbc: 242e 0010 movel %fp@(16),%d2
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
45bc0: 4a8a tstl %a2
45bc2: 6700 0092 beqw 45c56 <pthread_barrier_init+0xaa>
return EINVAL;
if ( count == 0 )
45bc6: 4a82 tstl %d2
45bc8: 6700 008c beqw 45c56 <pthread_barrier_init+0xaa>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
45bcc: 4a88 tstl %a0
45bce: 6610 bnes 45be0 <pthread_barrier_init+0x34>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
45bd0: 260e movel %fp,%d3
45bd2: 5183 subql #8,%d3
45bd4: 2f03 movel %d3,%sp@-
45bd6: 4eb9 0004 5af4 jsr 45af4 <pthread_barrierattr_init>
45bdc: 588f addql #4,%sp
the_attr = &my_attr;
45bde: 2043 moveal %d3,%a0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
45be0: 4a90 tstl %a0@
45be2: 6772 beqs 45c56 <pthread_barrier_init+0xaa> <== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
45be4: 4aa8 0004 tstl %a0@(4)
45be8: 666c bnes 45c56 <pthread_barrier_init+0xaa> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45bea: 2039 0005 ff4c movel 5ff4c <_Thread_Dispatch_disable_level>,%d0
45bf0: 5280 addql #1,%d0
45bf2: 23c0 0005 ff4c movel %d0,5ff4c <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45bf8: 2039 0005 ff4c movel 5ff4c <_Thread_Dispatch_disable_level>,%d0
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
45bfe: 42ae fff0 clrl %fp@(-16)
the_attributes.maximum_count = count;
45c02: 2d42 fff4 movel %d2,%fp@(-12)
* This function allocates a barrier control block from
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
45c06: 4879 0006 0242 pea 60242 <_POSIX_Barrier_Information>
45c0c: 4eb9 0004 7b28 jsr 47b28 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
45c12: 588f addql #4,%sp
45c14: 2640 moveal %d0,%a3
45c16: 4a80 tstl %d0
45c18: 660a bnes 45c24 <pthread_barrier_init+0x78>
_Thread_Enable_dispatch();
45c1a: 4eb9 0004 8b9c jsr 48b9c <_Thread_Enable_dispatch>
return EAGAIN;
45c20: 700b moveq #11,%d0
45c22: 6034 bras 45c58 <pthread_barrier_init+0xac>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
45c24: 486e fff0 pea %fp@(-16)
45c28: 486b 0010 pea %a3@(16)
45c2c: 4eb9 0004 7208 jsr 47208 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45c32: 202b 0008 movel %a3@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45c36: 4281 clrl %d1
45c38: 2079 0006 025a moveal 6025a <_POSIX_Barrier_Information+0x18>,%a0
45c3e: 3200 movew %d0,%d1
45c40: 218b 1c00 movel %a3,%a0@(00000000,%d1:l:4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
45c44: 42ab 000c clrl %a3@(12)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
45c48: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
45c4a: 4eb9 0004 8b9c jsr 48b9c <_Thread_Enable_dispatch>
return 0;
45c50: 508f addql #8,%sp
45c52: 4280 clrl %d0
45c54: 6002 bras 45c58 <pthread_barrier_init+0xac>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
45c56: 7016 moveq #22,%d0
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
_Thread_Enable_dispatch();
return 0;
}
45c58: 4cee 0c0c ffe0 moveml %fp@(-32),%d2-%d3/%a2-%a3
45c5e: 4e5e unlk %fp
...
000455b8 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
455b8: 4e56 0000 linkw %fp,#0
455bc: 2f03 movel %d3,%sp@-
455be: 262e 000c movel %fp@(12),%d3
455c2: 2f02 movel %d2,%sp@-
455c4: 242e 0008 movel %fp@(8),%d2
/*
* The POSIX standard does not address what to do when the routine
* is NULL. It also does not address what happens when we cannot
* allocate memory or anything else bad happens.
*/
if ( !routine )
455c8: 675a beqs 45624 <pthread_cleanup_push+0x6c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
455ca: 2039 0005 f8d2 movel 5f8d2 <_Thread_Dispatch_disable_level>,%d0
455d0: 5280 addql #1,%d0
455d2: 23c0 0005 f8d2 movel %d0,5f8d2 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
455d8: 2039 0005 f8d2 movel 5f8d2 <_Thread_Dispatch_disable_level>,%d0
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
455de: 4878 0010 pea 10 <INVALID_OPERATION>
455e2: 4eb9 0004 955c jsr 4955c <_Workspace_Allocate>
if ( handler ) {
455e8: 588f addql #4,%sp
455ea: 4a80 tstl %d0
455ec: 6726 beqs 45614 <pthread_cleanup_push+0x5c> <== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
455ee: 2079 0005 fd34 moveal 5fd34 <_Per_CPU_Information+0xc>,%a0
handler_stack = &thread_support->Cancellation_Handlers;
455f4: 2228 0102 movel %a0@(258),%d1
handler->routine = routine;
455f8: 2040 moveal %d0,%a0
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
if ( handler ) {
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
455fa: 0681 0000 00e4 addil #228,%d1
handler->routine = routine;
45600: 2142 0008 movel %d2,%a0@(8)
handler->arg = arg;
45604: 2143 000c movel %d3,%a0@(12)
_Chain_Append( handler_stack, &handler->Node );
45608: 2f00 movel %d0,%sp@-
4560a: 2f01 movel %d1,%sp@-
4560c: 4eb9 0004 6cdc jsr 46cdc <_Chain_Append>
45612: 508f addql #8,%sp
}
_Thread_Enable_dispatch();
}
45614: 242e fff8 movel %fp@(-8),%d2
45618: 262e fffc movel %fp@(-4),%d3
4561c: 4e5e unlk %fp
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
4561e: 4ef9 0004 8634 jmp 48634 <_Thread_Enable_dispatch>
}
45624: 242e fff8 movel %fp@(-8),%d2
45628: 262e fffc movel %fp@(-4),%d3
4562c: 4e5e unlk %fp <== NOT EXECUTED
00046188 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
46188: 4e56 0000 linkw %fp,#0
4618c: 206e 0008 moveal %fp@(8),%a0
if ( !attr || attr->is_initialized == false )
46190: 4a88 tstl %a0
46192: 670a beqs 4619e <pthread_condattr_destroy+0x16>
46194: 4a90 tstl %a0@
46196: 6706 beqs 4619e <pthread_condattr_destroy+0x16> <== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
46198: 4290 clrl %a0@
return 0;
4619a: 4280 clrl %d0
4619c: 6002 bras 461a0 <pthread_condattr_destroy+0x18>
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
4619e: 7016 moveq #22,%d0
attr->is_initialized = false;
return 0;
}
461a0: 4e5e unlk %fp <== NOT EXECUTED
0004c8d0 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
4c8d0: 4e56 0000 linkw %fp,#0
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
4c8d4: 2f2e 0008 movel %fp@(8),%sp@-
4c8d8: 2f39 0005 effa movel 5effa <_Per_CPU_Information+0xc>,%sp@-
4c8de: 4eb9 0004 c7e0 jsr 4c7e0 <_POSIX_Thread_Exit>
4c8e4: 508f addql #8,%sp <== NOT EXECUTED
}
4c8e6: 4e5e unlk %fp <== NOT EXECUTED
...
0005af7c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
5af7c: 4e56 fff0 linkw %fp,#-16
5af80: 48d7 040c moveml %d2-%d3/%a2,%sp@
5af84: 242e 000c movel %fp@(12),%d2
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
5af88: 670a beqs 5af94 <pthread_kill+0x18>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
5af8a: 2602 movel %d2,%d3
5af8c: 5383 subql #1,%d3
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
5af8e: 701f moveq #31,%d0
5af90: b083 cmpl %d3,%d0
5af92: 640e bccs 5afa2 <pthread_kill+0x26>
rtems_set_errno_and_return_minus_one( EINVAL );
5af94: 4eb9 0004 cd68 jsr 4cd68 <__errno>
5af9a: 7216 moveq #22,%d1
5af9c: 2040 moveal %d0,%a0
5af9e: 2081 movel %d1,%a0@
5afa0: 607a bras 5b01c <pthread_kill+0xa0>
the_thread = _Thread_Get( thread, &location );
5afa2: 486e fffc pea %fp@(-4)
5afa6: 2f2e 0008 movel %fp@(8),%sp@-
5afaa: 4eb9 0004 7da8 jsr 47da8 <_Thread_Get>
switch ( location ) {
5afb0: 508f addql #8,%sp
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
5afb2: 2440 moveal %d0,%a2
switch ( location ) {
5afb4: 4aae fffc tstl %fp@(-4)
5afb8: 6656 bnes 5b010 <pthread_kill+0x94> <== NEVER TAKEN
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
5afba: 2202 movel %d2,%d1
5afbc: 2002 movel %d2,%d0
5afbe: e589 lsll #2,%d1
5afc0: e988 lsll #4,%d0
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
5afc2: 206a 0102 moveal %a2@(258),%a0
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
5afc6: 9081 subl %d1,%d0
5afc8: 0680 0005 f03c addil #389180,%d0
5afce: 7201 moveq #1,%d1
5afd0: 2240 moveal %d0,%a1
5afd2: b291 cmpl %a1@,%d1
5afd4: 6730 beqs 5b006 <pthread_kill+0x8a>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
5afd6: 7001 moveq #1,%d0
5afd8: e7a8 lsll %d3,%d0
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
5afda: 81a8 00d4 orl %d0,%a0@(212)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
5afde: 42a7 clrl %sp@-
5afe0: 2f02 movel %d2,%sp@-
5afe2: 2f0a movel %a2,%sp@-
5afe4: 4eb9 0005 ae80 jsr 5ae80 <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
5afea: 4fef 000c lea %sp@(12),%sp
5afee: 4ab9 0005 eff6 tstl 5eff6 <_Per_CPU_Information+0x8>
5aff4: 6710 beqs 5b006 <pthread_kill+0x8a>
5aff6: b5f9 0005 effa cmpal 5effa <_Per_CPU_Information+0xc>,%a2
5affc: 6608 bnes 5b006 <pthread_kill+0x8a>
_Thread_Dispatch_necessary = true;
5affe: 7001 moveq #1,%d0
5b000: 13c0 0005 f006 moveb %d0,5f006 <_Per_CPU_Information+0x18>
}
_Thread_Enable_dispatch();
5b006: 4eb9 0004 7d80 jsr 47d80 <_Thread_Enable_dispatch>
return 0;
5b00c: 4280 clrl %d0
5b00e: 600e bras 5b01e <pthread_kill+0xa2>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
5b010: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
5b016: 2040 moveal %d0,%a0 <== NOT EXECUTED
5b018: 7003 moveq #3,%d0 <== NOT EXECUTED
5b01a: 2080 movel %d0,%a0@ <== NOT EXECUTED
5b01c: 70ff moveq #-1,%d0
}
5b01e: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
5b024: 4e5e unlk %fp <== NOT EXECUTED
0004753c <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
4753c: 4e56 fffc linkw %fp,#-4
47540: 2f03 movel %d3,%sp@-
47542: 2f02 movel %d2,%sp@-
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
47544: 486e fffc pea %fp@(-4)
47548: 2f2e 000c movel %fp@(12),%sp@-
4754c: 4eb9 0004 7624 jsr 47624 <_POSIX_Absolute_timeout_to_ticks>
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
47552: 508f addql #8,%sp
47554: 2400 movel %d0,%d2
47556: 7003 moveq #3,%d0
47558: b082 cmpl %d2,%d0
4755a: 57c3 seq %d3
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
4755c: 2f2e fffc movel %fp@(-4),%sp@-
47560: 4483 negl %d3
47562: 4280 clrl %d0
47564: 1003 moveb %d3,%d0
47566: 2f00 movel %d0,%sp@-
47568: 2f2e 0008 movel %fp@(8),%sp@-
4756c: 4eb9 0004 7444 jsr 47444 <_POSIX_Mutex_Lock_support>
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
47572: 4fef 000c lea %sp@(12),%sp
47576: 4a03 tstb %d3
47578: 661c bnes 47596 <pthread_mutex_timedlock+0x5a>
4757a: 7210 moveq #16,%d1
4757c: b280 cmpl %d0,%d1
4757e: 6616 bnes 47596 <pthread_mutex_timedlock+0x5a>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
47580: 4a82 tstl %d2
47582: 670c beqs 47590 <pthread_mutex_timedlock+0x54> <== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
47584: 5382 subql #1,%d2
47586: 123c 0001 moveb #1,%d1
4758a: b282 cmpl %d2,%d1
4758c: 6508 bcss 47596 <pthread_mutex_timedlock+0x5a> <== NEVER TAKEN
4758e: 6004 bras 47594 <pthread_mutex_timedlock+0x58>
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
47590: 7016 moveq #22,%d0 <== NOT EXECUTED
47592: 6002 bras 47596 <pthread_mutex_timedlock+0x5a> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
47594: 7074 moveq #116,%d0
}
return lock_status;
}
47596: 242e fff4 movel %fp@(-12),%d2
4759a: 262e fff8 movel %fp@(-8),%d3
4759e: 4e5e unlk %fp
...
00045420 <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
45420: 4e56 0000 linkw %fp,#0
45424: 206e 0008 moveal %fp@(8),%a0
45428: 226e 000c moveal %fp@(12),%a1
if ( !attr )
4542c: 4a88 tstl %a0
4542e: 6710 beqs 45440 <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !attr->is_initialized )
45430: 4a90 tstl %a0@
45432: 670c beqs 45440 <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !type )
45434: 4a89 tstl %a1
45436: 6708 beqs 45440 <pthread_mutexattr_gettype+0x20> <== NEVER TAKEN
return EINVAL;
*type = attr->type;
45438: 22a8 0010 movel %a0@(16),%a1@
return 0;
4543c: 4280 clrl %d0
4543e: 6002 bras 45442 <pthread_mutexattr_gettype+0x22>
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
return EINVAL;
45440: 7016 moveq #22,%d0
*type = attr->type;
return 0;
}
45442: 4e5e unlk %fp
...
00047184 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
47184: 4e56 0000 linkw %fp,#0
47188: 206e 0008 moveal %fp@(8),%a0
4718c: 202e 000c movel %fp@(12),%d0
if ( !attr || !attr->is_initialized )
47190: 4a88 tstl %a0
47192: 6712 beqs 471a6 <pthread_mutexattr_setpshared+0x22>
47194: 4a90 tstl %a0@
47196: 670e beqs 471a6 <pthread_mutexattr_setpshared+0x22>
return EINVAL;
switch ( pshared ) {
47198: 7201 moveq #1,%d1
4719a: b280 cmpl %d0,%d1
4719c: 6508 bcss 471a6 <pthread_mutexattr_setpshared+0x22><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
4719e: 2140 0004 movel %d0,%a0@(4)
return 0;
471a2: 4280 clrl %d0
471a4: 6002 bras 471a8 <pthread_mutexattr_setpshared+0x24>
default:
return EINVAL;
471a6: 7016 moveq #22,%d0
}
}
471a8: 4e5e unlk %fp <== NOT EXECUTED
00045474 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
45474: 4e56 0000 linkw %fp,#0
45478: 206e 0008 moveal %fp@(8),%a0
4547c: 202e 000c movel %fp@(12),%d0
if ( !attr || !attr->is_initialized )
45480: 4a88 tstl %a0
45482: 6712 beqs 45496 <pthread_mutexattr_settype+0x22>
45484: 4a90 tstl %a0@
45486: 670e beqs 45496 <pthread_mutexattr_settype+0x22> <== NEVER TAKEN
return EINVAL;
switch ( type ) {
45488: 7203 moveq #3,%d1
4548a: b280 cmpl %d0,%d1
4548c: 6508 bcss 45496 <pthread_mutexattr_settype+0x22>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
4548e: 2140 0010 movel %d0,%a0@(16)
return 0;
45492: 4280 clrl %d0
45494: 6002 bras 45498 <pthread_mutexattr_settype+0x24>
default:
return EINVAL;
45496: 7016 moveq #22,%d0
}
}
45498: 4e5e unlk %fp <== NOT EXECUTED
00045f94 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
45f94: 4e56 fff0 linkw %fp,#-16
45f98: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
45f9c: 246e 0008 moveal %fp@(8),%a2
45fa0: 266e 000c moveal %fp@(12),%a3
if ( !once_control || !init_routine )
45fa4: 4a8a tstl %a2
45fa6: 674a beqs 45ff2 <pthread_once+0x5e>
45fa8: 4a8b tstl %a3
45faa: 6746 beqs 45ff2 <pthread_once+0x5e>
return EINVAL;
if ( !once_control->init_executed ) {
45fac: 4aaa 0004 tstl %a2@(4)
45fb0: 6644 bnes 45ff6 <pthread_once+0x62>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
45fb2: 240e movel %fp,%d2
45fb4: 5982 subql #4,%d2
45fb6: 2f02 movel %d2,%sp@-
45fb8: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
45fbc: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
45fc0: 4eb9 0004 6ab8 jsr 46ab8 <rtems_task_mode>
if ( !once_control->init_executed ) {
45fc6: 4fef 000c lea %sp@(12),%sp
45fca: 4aaa 0004 tstl %a2@(4)
45fce: 660c bnes 45fdc <pthread_once+0x48> <== NEVER TAKEN
once_control->is_initialized = true;
45fd0: 7001 moveq #1,%d0
45fd2: 2480 movel %d0,%a2@
once_control->init_executed = true;
45fd4: 7001 moveq #1,%d0
45fd6: 2540 0004 movel %d0,%a2@(4)
(*init_routine)();
45fda: 4e93 jsr %a3@
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
45fdc: 2f02 movel %d2,%sp@-
45fde: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
45fe2: 2f2e fffc movel %fp@(-4),%sp@-
45fe6: 4eb9 0004 6ab8 jsr 46ab8 <rtems_task_mode>
45fec: 4fef 000c lea %sp@(12),%sp
45ff0: 6004 bras 45ff6 <pthread_once+0x62>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
45ff2: 7016 moveq #22,%d0
45ff4: 6002 bras 45ff8 <pthread_once+0x64>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
45ff6: 4280 clrl %d0
}
45ff8: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
45ffe: 4e5e unlk %fp
...
00046670 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
46670: 4e56 ffe8 linkw %fp,#-24
46674: 206e 000c moveal %fp@(12),%a0
46678: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4667c: 246e 0008 moveal %fp@(8),%a2
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
46680: 4a8a tstl %a2
46682: 6700 008c beqw 46710 <pthread_rwlock_init+0xa0>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
46686: 4a88 tstl %a0
46688: 6614 bnes 4669e <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
4668a: 240e movel %fp,%d2
4668c: 0682 ffff fff4 addil #-12,%d2
46692: 2f02 movel %d2,%sp@-
46694: 4eb9 0004 6fd8 jsr 46fd8 <pthread_rwlockattr_init>
4669a: 588f addql #4,%sp
the_attr = &default_attr;
4669c: 2042 moveal %d2,%a0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
4669e: 4a90 tstl %a0@
466a0: 676e beqs 46710 <pthread_rwlock_init+0xa0> <== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
466a2: 4aa8 0004 tstl %a0@(4)
466a6: 6668 bnes 46710 <pthread_rwlock_init+0xa0> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
466a8: 2039 0006 156c movel 6156c <_Thread_Dispatch_disable_level>,%d0
466ae: 5280 addql #1,%d0
466b0: 23c0 0006 156c movel %d0,6156c <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
466b6: 2039 0006 156c movel 6156c <_Thread_Dispatch_disable_level>,%d0
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
466bc: 42ae fffc clrl %fp@(-4)
* This function allocates a RWLock control block from
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
466c0: 4879 0006 16cc pea 616cc <_POSIX_RWLock_Information>
466c6: 4eb9 0004 8b54 jsr 48b54 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
466cc: 588f addql #4,%sp
466ce: 2640 moveal %d0,%a3
466d0: 4a80 tstl %d0
466d2: 660a bnes 466de <pthread_rwlock_init+0x6e>
_Thread_Enable_dispatch();
466d4: 4eb9 0004 9bc8 jsr 49bc8 <_Thread_Enable_dispatch>
return EAGAIN;
466da: 700b moveq #11,%d0
466dc: 6034 bras 46712 <pthread_rwlock_init+0xa2>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
466de: 486e fffc pea %fp@(-4)
466e2: 486b 0010 pea %a3@(16)
466e6: 4eb9 0004 8340 jsr 48340 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
466ec: 202b 0008 movel %a3@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
466f0: 4281 clrl %d1
466f2: 2079 0006 16e4 moveal 616e4 <_POSIX_RWLock_Information+0x18>,%a0
466f8: 3200 movew %d0,%d1
466fa: 218b 1c00 movel %a3,%a0@(00000000,%d1:l:4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
466fe: 42ab 000c clrl %a3@(12)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
46702: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
46704: 4eb9 0004 9bc8 jsr 49bc8 <_Thread_Enable_dispatch>
return 0;
4670a: 508f addql #8,%sp
4670c: 4280 clrl %d0
4670e: 6002 bras 46712 <pthread_rwlock_init+0xa2>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
46710: 7016 moveq #22,%d0
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
46712: 4cee 0c04 ffe8 moveml %fp@(-24),%d2/%a2-%a3
46718: 4e5e unlk %fp <== NOT EXECUTED
00046784 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
46784: 4e56 ffec linkw %fp,#-20
46788: 48d7 040c moveml %d2-%d3/%a2,%sp@
4678c: 246e 0008 moveal %fp@(8),%a2
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
46790: 4a8a tstl %a2
46792: 6700 0086 beqw 4681a <pthread_rwlock_timedrdlock+0x96>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
46796: 486e fffc pea %fp@(-4)
4679a: 2f2e 000c movel %fp@(12),%sp@-
4679e: 4eb9 0004 c598 jsr 4c598 <_POSIX_Absolute_timeout_to_ticks>
467a4: 486e fff8 pea %fp@(-8)
467a8: 2400 movel %d0,%d2
467aa: 2f12 movel %a2@,%sp@-
467ac: 4879 0006 16cc pea 616cc <_POSIX_RWLock_Information>
467b2: 4eb9 0004 8fb4 jsr 48fb4 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
467b8: 4fef 0014 lea %sp@(20),%sp
467bc: 4aae fff8 tstl %fp@(-8)
467c0: 6658 bnes 4681a <pthread_rwlock_timedrdlock+0x96><== NEVER TAKEN
int _EXFUN(pthread_rwlock_init,
(pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedrdlock,
467c2: 7203 moveq #3,%d1
467c4: b282 cmpl %d2,%d1
467c6: 57c3 seq %d3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
467c8: 42a7 clrl %sp@-
467ca: 2f2e fffc movel %fp@(-4),%sp@-
467ce: 4483 negl %d3
467d0: 4281 clrl %d1
467d2: 1203 moveb %d3,%d1
467d4: 2040 moveal %d0,%a0
467d6: 2f01 movel %d1,%sp@-
467d8: 2f12 movel %a2@,%sp@-
467da: 4868 0010 pea %a0@(16)
467de: 4eb9 0004 8374 jsr 48374 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
467e4: 4eb9 0004 9bc8 jsr 49bc8 <_Thread_Enable_dispatch>
467ea: 2079 0006 19ce moveal 619ce <_Per_CPU_Information+0xc>,%a0
if ( !do_wait ) {
467f0: 4fef 0014 lea %sp@(20),%sp
467f4: 4a03 tstb %d3
467f6: 6614 bnes 4680c <pthread_rwlock_timedrdlock+0x88><== NEVER TAKEN
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
467f8: 7002 moveq #2,%d0
467fa: b0a8 0034 cmpl %a0@(52),%d0
467fe: 660c bnes 4680c <pthread_rwlock_timedrdlock+0x88>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
46800: 4a82 tstl %d2
46802: 6716 beqs 4681a <pthread_rwlock_timedrdlock+0x96><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
46804: 5382 subql #1,%d2
46806: 7201 moveq #1,%d1
46808: b282 cmpl %d2,%d1
4680a: 6412 bccs 4681e <pthread_rwlock_timedrdlock+0x9a><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
4680c: 2f28 0034 movel %a0@(52),%sp@-
46810: 4eb9 0004 68d4 jsr 468d4 <_POSIX_RWLock_Translate_core_RWLock_return_code>
46816: 588f addql #4,%sp
46818: 6006 bras 46820 <pthread_rwlock_timedrdlock+0x9c>
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
4681a: 7016 moveq #22,%d0
4681c: 6002 bras 46820 <pthread_rwlock_timedrdlock+0x9c>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
4681e: 7074 moveq #116,%d0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
46820: 4cee 040c ffec moveml %fp@(-20),%d2-%d3/%a2
46826: 4e5e unlk %fp
...
0004682c <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
4682c: 4e56 ffec linkw %fp,#-20
46830: 48d7 040c moveml %d2-%d3/%a2,%sp@
46834: 246e 0008 moveal %fp@(8),%a2
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
46838: 4a8a tstl %a2
4683a: 6700 0086 beqw 468c2 <pthread_rwlock_timedwrlock+0x96>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
4683e: 486e fffc pea %fp@(-4)
46842: 2f2e 000c movel %fp@(12),%sp@-
46846: 4eb9 0004 c598 jsr 4c598 <_POSIX_Absolute_timeout_to_ticks>
4684c: 486e fff8 pea %fp@(-8)
46850: 2400 movel %d0,%d2
46852: 2f12 movel %a2@,%sp@-
46854: 4879 0006 16cc pea 616cc <_POSIX_RWLock_Information>
4685a: 4eb9 0004 8fb4 jsr 48fb4 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
46860: 4fef 0014 lea %sp@(20),%sp
46864: 4aae fff8 tstl %fp@(-8)
46868: 6658 bnes 468c2 <pthread_rwlock_timedwrlock+0x96>
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
4686a: 7203 moveq #3,%d1
4686c: b282 cmpl %d2,%d1
4686e: 57c3 seq %d3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
46870: 42a7 clrl %sp@-
46872: 2f2e fffc movel %fp@(-4),%sp@-
46876: 4483 negl %d3
46878: 4281 clrl %d1
4687a: 1203 moveb %d3,%d1
4687c: 2040 moveal %d0,%a0
4687e: 2f01 movel %d1,%sp@-
46880: 2f12 movel %a2@,%sp@-
46882: 4868 0010 pea %a0@(16)
46886: 4eb9 0004 8420 jsr 48420 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
4688c: 4eb9 0004 9bc8 jsr 49bc8 <_Thread_Enable_dispatch>
46892: 2079 0006 19ce moveal 619ce <_Per_CPU_Information+0xc>,%a0
if ( !do_wait &&
46898: 4fef 0014 lea %sp@(20),%sp
4689c: 4a03 tstb %d3
4689e: 6614 bnes 468b4 <pthread_rwlock_timedwrlock+0x88>
468a0: 7002 moveq #2,%d0
468a2: b0a8 0034 cmpl %a0@(52),%d0
468a6: 660c bnes 468b4 <pthread_rwlock_timedwrlock+0x88>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
468a8: 4a82 tstl %d2
468aa: 6716 beqs 468c2 <pthread_rwlock_timedwrlock+0x96><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
468ac: 5382 subql #1,%d2
468ae: 7201 moveq #1,%d1
468b0: b282 cmpl %d2,%d1
468b2: 6412 bccs 468c6 <pthread_rwlock_timedwrlock+0x9a><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
468b4: 2f28 0034 movel %a0@(52),%sp@-
468b8: 4eb9 0004 68d4 jsr 468d4 <_POSIX_RWLock_Translate_core_RWLock_return_code>
468be: 588f addql #4,%sp
468c0: 6006 bras 468c8 <pthread_rwlock_timedwrlock+0x9c>
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
468c2: 7016 moveq #22,%d0
468c4: 6002 bras 468c8 <pthread_rwlock_timedwrlock+0x9c>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
468c6: 7074 moveq #116,%d0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
468c8: 4cee 040c ffec moveml %fp@(-20),%d2-%d3/%a2
468ce: 4e5e unlk %fp
...
00046ff8 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
46ff8: 4e56 0000 linkw %fp,#0
46ffc: 206e 0008 moveal %fp@(8),%a0
47000: 202e 000c movel %fp@(12),%d0
if ( !attr )
47004: 4a88 tstl %a0
47006: 6712 beqs 4701a <pthread_rwlockattr_setpshared+0x22>
return EINVAL;
if ( !attr->is_initialized )
47008: 4a90 tstl %a0@
4700a: 670e beqs 4701a <pthread_rwlockattr_setpshared+0x22>
return EINVAL;
switch ( pshared ) {
4700c: 7201 moveq #1,%d1
4700e: b280 cmpl %d0,%d1
47010: 6508 bcss 4701a <pthread_rwlockattr_setpshared+0x22><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
47012: 2140 0004 movel %d0,%a0@(4)
return 0;
47016: 4280 clrl %d0
47018: 6002 bras 4701c <pthread_rwlockattr_setpshared+0x24>
default:
return EINVAL;
4701a: 7016 moveq #22,%d0
}
}
4701c: 4e5e unlk %fp <== NOT EXECUTED
00047dc4 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
47dc4: 4e56 ffe0 linkw %fp,#-32
47dc8: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
47dcc: 242e 000c movel %fp@(12),%d2
47dd0: 282e 0010 movel %fp@(16),%d4
int rc;
/*
* Check all the parameters
*/
if ( !param )
47dd4: 6700 00d8 beqw 47eae <pthread_setschedparam+0xea>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
47dd8: 486e fff8 pea %fp@(-8)
47ddc: 486e fff4 pea %fp@(-12)
47de0: 2f04 movel %d4,%sp@-
47de2: 2f02 movel %d2,%sp@-
47de4: 4eb9 0004 d330 jsr 4d330 <_POSIX_Thread_Translate_sched_param>
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
47dea: 4fef 0010 lea %sp@(16),%sp
* Check all the parameters
*/
if ( !param )
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
47dee: 2600 movel %d0,%d3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
47df0: 6600 00c2 bnew 47eb4 <pthread_setschedparam+0xf0>
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
47df4: 486e fffc pea %fp@(-4)
47df8: 2f2e 0008 movel %fp@(8),%sp@-
47dfc: 4eb9 0004 a82c jsr 4a82c <_Thread_Get>
switch ( location ) {
47e02: 508f addql #8,%sp
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
47e04: 2640 moveal %d0,%a3
switch ( location ) {
47e06: 4aae fffc tstl %fp@(-4)
47e0a: 6600 00a6 bnew 47eb2 <pthread_setschedparam+0xee>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
47e0e: 246b 0102 moveal %a3@(258),%a2
if ( api->schedpolicy == SCHED_SPORADIC )
47e12: 7004 moveq #4,%d0
47e14: b0aa 0084 cmpl %a2@(132),%d0
47e18: 660c bnes 47e26 <pthread_setschedparam+0x62>
(void) _Watchdog_Remove( &api->Sporadic_timer );
47e1a: 486a 00a8 pea %a2@(168)
47e1e: 4eb9 0004 b6ac jsr 4b6ac <_Watchdog_Remove>
47e24: 588f addql #4,%sp
api->schedpolicy = policy;
47e26: 2542 0084 movel %d2,%a2@(132)
api->schedparam = *param;
47e2a: 4878 001c pea 1c <OPER2+0x8>
47e2e: 2f04 movel %d4,%sp@-
47e30: 486a 0088 pea %a2@(136)
47e34: 4eb9 0004 fe40 jsr 4fe40 <memcpy>
the_thread->budget_algorithm = budget_algorithm;
47e3a: 276e fff4 007a movel %fp@(-12),%a3@(122)
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
47e40: 4fef 000c lea %sp@(12),%sp
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
47e44: 276e fff8 007e movel %fp@(-8),%a3@(126)
switch ( api->schedpolicy ) {
47e4a: 4a82 tstl %d2
47e4c: 6d58 blts 47ea6 <pthread_setschedparam+0xe2> <== NEVER TAKEN
47e4e: 7002 moveq #2,%d0
47e50: b082 cmpl %d2,%d0
47e52: 6c0a bges 47e5e <pthread_setschedparam+0x9a>
47e54: 103c 0004 moveb #4,%d0
47e58: b082 cmpl %d2,%d0
47e5a: 664a bnes 47ea6 <pthread_setschedparam+0xe2> <== NEVER TAKEN
47e5c: 602a bras 47e88 <pthread_setschedparam+0xc4>
47e5e: 4280 clrl %d0
47e60: 1039 0006 1a1a moveb 61a1a <rtems_maximum_priority>,%d0
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
47e66: 41f9 0006 33d0 lea 633d0 <_Thread_Ticks_per_timeslice>,%a0
47e6c: 90aa 0088 subl %a2@(136),%d0
47e70: 2750 0076 movel %a0@,%a3@(118)
the_thread->real_priority =
47e74: 2740 0018 movel %d0,%a3@(24)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
47e78: 4878 0001 pea 1 <ADD>
47e7c: 2f00 movel %d0,%sp@-
47e7e: 2f0b movel %a3,%sp@-
47e80: 4eb9 0004 a3b4 jsr 4a3b4 <_Thread_Change_priority>
47e86: 601a bras 47ea2 <pthread_setschedparam+0xde>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
47e88: 256a 0088 00a4 movel %a2@(136),%a2@(164)
_Watchdog_Remove( &api->Sporadic_timer );
47e8e: 486a 00a8 pea %a2@(168)
47e92: 4eb9 0004 b6ac jsr 4b6ac <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
47e98: 2f0b movel %a3,%sp@-
47e9a: 42a7 clrl %sp@-
47e9c: 4eb9 0004 7c9e jsr 47c9e <_POSIX_Threads_Sporadic_budget_TSR>
break;
47ea2: 4fef 000c lea %sp@(12),%sp
}
_Thread_Enable_dispatch();
47ea6: 4eb9 0004 a804 jsr 4a804 <_Thread_Enable_dispatch>
return 0;
47eac: 6006 bras 47eb4 <pthread_setschedparam+0xf0>
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
47eae: 7616 moveq #22,%d3
47eb0: 6002 bras 47eb4 <pthread_setschedparam+0xf0>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
47eb2: 7603 moveq #3,%d3
}
47eb4: 2003 movel %d3,%d0
47eb6: 4cee 0c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a3
47ebc: 4e5e unlk %fp <== NOT EXECUTED
00045d30 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
45d30: 4e56 0000 linkw %fp,#0
45d34: 2f02 movel %d2,%sp@-
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
45d36: 4ab9 0005 fd30 tstl 5fd30 <_Per_CPU_Information+0x8>
45d3c: 664c bnes 45d8a <pthread_testcancel+0x5a> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45d3e: 2039 0005 f8d2 movel 5f8d2 <_Thread_Dispatch_disable_level>,%d0
45d44: 5280 addql #1,%d0
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
45d46: 2079 0005 fd34 moveal 5fd34 <_Per_CPU_Information+0xc>,%a0
45d4c: 23c0 0005 f8d2 movel %d0,5f8d2 <_Thread_Dispatch_disable_level>
45d52: 2068 0102 moveal %a0@(258),%a0
return _Thread_Dispatch_disable_level;
45d56: 2039 0005 f8d2 movel 5f8d2 <_Thread_Dispatch_disable_level>,%d0
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
45d5c: 4aa8 00d8 tstl %a0@(216)
45d60: 660a bnes 45d6c <pthread_testcancel+0x3c> <== NEVER TAKEN
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
45d62: 4aa8 00e0 tstl %a0@(224)
45d66: 56c2 sne %d2
45d68: 4482 negl %d2
45d6a: 6002 bras 45d6e <pthread_testcancel+0x3e>
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
45d6c: 4202 clrb %d2 <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
45d6e: 4eb9 0004 8634 jsr 48634 <_Thread_Enable_dispatch>
if ( cancel )
45d74: 4a02 tstb %d2
45d76: 6712 beqs 45d8a <pthread_testcancel+0x5a>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
45d78: 4878 ffff pea ffffffff <LESS>
45d7c: 2f39 0005 fd34 movel 5fd34 <_Per_CPU_Information+0xc>,%sp@-
45d82: 4eb9 0004 b240 jsr 4b240 <_POSIX_Thread_Exit>
45d88: 508f addql #8,%sp <== NOT EXECUTED
}
45d8a: 242e fffc movel %fp@(-4),%d2
45d8e: 4e5e unlk %fp
...
00049d38 <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
49d38: 4e56 ffec linkw %fp,#-20
49d3c: 48d7 043c moveml %d2-%d5/%a2,%sp@
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
49d40: 4878 0010 pea 10 <INVALID_OPERATION>
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
49d44: 242e 0008 movel %fp@(8),%d2
49d48: 282e 000c movel %fp@(12),%d4
49d4c: 262e 0010 movel %fp@(16),%d3
49d50: 1a2e 0017 moveb %fp@(23),%d5
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
49d54: 4eb9 0004 391c jsr 4391c <malloc>
if (rd == NULL) {
49d5a: 588f addql #4,%sp
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
49d5c: 2440 moveal %d0,%a2
if (rd == NULL) {
49d5e: 4a80 tstl %d0
49d60: 6740 beqs 49da2 <ramdisk_allocate+0x6a> <== NEVER TAKEN
return NULL;
}
if (area_begin == NULL) {
49d62: 4a82 tstl %d2
49d64: 6622 bnes 49d88 <ramdisk_allocate+0x50> <== NEVER TAKEN
area_begin = calloc(block_count, block_size);
49d66: 2f04 movel %d4,%sp@-
49d68: 2f03 movel %d3,%sp@-
49d6a: 4eb9 0004 3294 jsr 43294 <calloc>
if (area_begin == NULL) {
49d70: 508f addql #8,%sp
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
49d72: 2400 movel %d0,%d2
if (area_begin == NULL) {
49d74: 660e bnes 49d84 <ramdisk_allocate+0x4c> <== ALWAYS TAKEN
free(rd);
49d76: 2f0a movel %a2,%sp@- <== NOT EXECUTED
return NULL;
49d78: 95ca subal %a2,%a2 <== NOT EXECUTED
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
if (area_begin == NULL) {
free(rd);
49d7a: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
return NULL;
49d80: 588f addql #4,%sp <== NOT EXECUTED
49d82: 601e bras 49da2 <ramdisk_allocate+0x6a> <== NOT EXECUTED
}
rd->malloced = true;
49d84: 7001 moveq #1,%d0
49d86: 6002 bras 49d8a <ramdisk_allocate+0x52>
} else {
rd->malloced = false;
49d88: 4200 clrb %d0 <== NOT EXECUTED
}
rd->block_size = block_size;
49d8a: 2484 movel %d4,%a2@
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
49d8c: 1540 000d moveb %d0,%a2@(13)
}
rd->block_size = block_size;
rd->block_num = block_count;
49d90: 2543 0004 movel %d3,%a2@(4)
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
49d94: 7001 moveq #1,%d0
rd->malloced = false;
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
rd->trace = trace;
49d96: 1545 000e moveb %d5,%a2@(14)
} else {
rd->malloced = false;
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
49d9a: 2542 0008 movel %d2,%a2@(8)
rd->trace = trace;
rd->initialized = true;
49d9e: 1540 000c moveb %d0,%a2@(12)
return rd;
}
49da2: 200a movel %a2,%d0
49da4: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
49daa: 4e5e unlk %fp <== NOT EXECUTED
00049dae <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
49dae: 4e56 0000 linkw %fp,#0
49db2: 2f0a movel %a2,%sp@-
49db4: 246e 0008 moveal %fp@(8),%a2
if (rd != NULL) {
49db8: 4a8a tstl %a2
49dba: 6722 beqs 49dde <ramdisk_free+0x30> <== NEVER TAKEN
if (rd->malloced) {
49dbc: 4a2a 000d tstb %a2@(13)
49dc0: 670c beqs 49dce <ramdisk_free+0x20> <== NEVER TAKEN
free(rd->area);
49dc2: 2f2a 0008 movel %a2@(8),%sp@-
49dc6: 4eb9 0004 3630 jsr 43630 <free>
49dcc: 588f addql #4,%sp
}
free(rd);
49dce: 2d4a 0008 movel %a2,%fp@(8)
}
}
49dd2: 246e fffc moveal %fp@(-4),%a2
49dd6: 4e5e unlk %fp
{
if (rd != NULL) {
if (rd->malloced) {
free(rd->area);
}
free(rd);
49dd8: 4ef9 0004 3630 jmp 43630 <free>
}
}
49dde: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
49de2: 4e5e unlk %fp <== NOT EXECUTED
00049c4c <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
49c4c: 4e56 ffe8 linkw %fp,#-24
49c50: 206e 0008 moveal %fp@(8),%a0
49c54: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
49c58: 202e 000c movel %fp@(12),%d0
49c5c: 246e 0010 moveal %fp@(16),%a2
switch (req)
49c60: 0c80 c018 4201 cmpil #-1072152063,%d0
49c66: 6600 00ac bnew 49d14 <ramdisk_ioctl+0xc8>
break;
}
errno = EINVAL;
return -1;
}
49c6a: 2868 002c moveal %a0@(44),%a4
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
49c6e: 2012 movel %a2@,%d0
49c70: 670a beqs 49c7c <ramdisk_ioctl+0x30>
49c72: 7201 moveq #1,%d1
49c74: b280 cmpl %d0,%d1
49c76: 6600 008c bnew 49d04 <ramdisk_ioctl+0xb8>
49c7a: 603a bras 49cb6 <ramdisk_ioctl+0x6a>
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
49c7c: 262c 0008 movel %a4@(8),%d3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49c80: 47ea 0018 lea %a2@(24),%a3
49c84: 4282 clrl %d2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
49c86: 4bf9 0005 0b90 lea 50b90 <memcpy>,%a5
49c8c: 6020 bras 49cae <ramdisk_ioctl+0x62>
49c8e: 2013 movel %a3@,%d0
49c90: 4c14 0800 mulsl %a4@,%d0
49c94: 2043 moveal %d3,%a0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49c96: 5282 addql #1,%d2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
49c98: 2f2b 0004 movel %a3@(4),%sp@-
49c9c: 4870 0800 pea %a0@(00000000,%d0:l)
49ca0: 2f2b 0008 movel %a3@(8),%sp@-
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49ca4: 47eb 0010 lea %a3@(16),%a3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
49ca8: 4e95 jsr %a5@
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49caa: 4fef 000c lea %sp@(12),%sp
49cae: b4aa 0010 cmpl %a2@(16),%d2
49cb2: 65da bcss 49c8e <ramdisk_ioctl+0x42>
49cb4: 6038 bras 49cee <ramdisk_ioctl+0xa2>
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
49cb6: 262c 0008 movel %a4@(8),%d3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49cba: 47ea 0018 lea %a2@(24),%a3
49cbe: 4282 clrl %d2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
49cc0: 4bf9 0005 0b90 lea 50b90 <memcpy>,%a5
49cc6: 6020 bras 49ce8 <ramdisk_ioctl+0x9c>
49cc8: 2013 movel %a3@,%d0
49cca: 4c14 0800 mulsl %a4@,%d0
49cce: 2043 moveal %d3,%a0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49cd0: 5282 addql #1,%d2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
49cd2: 2f2b 0004 movel %a3@(4),%sp@-
49cd6: 2f2b 0008 movel %a3@(8),%sp@-
49cda: 4870 0800 pea %a0@(00000000,%d0:l)
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49cde: 47eb 0010 lea %a3@(16),%a3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
49ce2: 4e95 jsr %a5@
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49ce4: 4fef 000c lea %sp@(12),%sp
49ce8: b4aa 0010 cmpl %a2@(16),%d2
49cec: 65da bcss 49cc8 <ramdisk_ioctl+0x7c>
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
49cee: 42aa 000c clrl %a2@(12)
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
49cf2: 42a7 clrl %sp@-
49cf4: 2f2a 0008 movel %a2@(8),%sp@-
49cf8: 206a 0004 moveal %a2@(4),%a0
49cfc: 4e90 jsr %a0@
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
49cfe: 508f addql #8,%sp
49d00: 4280 clrl %d0
49d02: 602a bras 49d2e <ramdisk_ioctl+0xe2>
default:
errno = EINVAL;
49d04: 4eb9 0005 0370 jsr 50370 <__errno> <== NOT EXECUTED
49d0a: 2040 moveal %d0,%a0 <== NOT EXECUTED
49d0c: 7016 moveq #22,%d0 <== NOT EXECUTED
49d0e: 2080 movel %d0,%a0@ <== NOT EXECUTED
return -1;
49d10: 70ff moveq #-1,%d0 <== NOT EXECUTED
49d12: 601a bras 49d2e <ramdisk_ioctl+0xe2> <== NOT EXECUTED
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
49d14: 2d4a 0010 movel %a2,%fp@(16)
49d18: 2d40 000c movel %d0,%fp@(12)
break;
}
errno = EINVAL;
return -1;
}
49d1c: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
49d22: 2d48 0008 movel %a0,%fp@(8)
break;
}
errno = EINVAL;
return -1;
}
49d26: 4e5e unlk %fp
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
49d28: 4ef9 0004 c13e jmp 4c13e <rtems_blkdev_ioctl>
break;
}
errno = EINVAL;
return -1;
}
49d2e: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
49d34: 4e5e unlk %fp <== NOT EXECUTED
00049de6 <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
49de6: 4e56 ffe8 linkw %fp,#-24
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
49dea: 204e moveal %fp,%a0
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
49dec: 48d7 007c moveml %d2-%d6,%sp@
49df0: 2a2e 0008 movel %fp@(8),%d5
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
49df4: 42a0 clrl %a0@-
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
49df6: 2c2e 000c movel %fp@(12),%d6
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
49dfa: 2f08 movel %a0,%sp@-
49dfc: 4879 0005 f816 pea 5f816 <ramdisk_ops>
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
49e02: 142e 0013 moveb %fp@(19),%d2
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
49e06: 42a7 clrl %sp@-
49e08: 4eb9 0004 6e1c jsr 46e1c <rtems_io_register_driver>
if (sc != RTEMS_SUCCESSFUL) {
49e0e: 4fef 000c lea %sp@(12),%sp
49e12: 4a80 tstl %d0
49e14: 6676 bnes 49e8c <ramdisk_register+0xa6> <== NEVER TAKEN
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
49e16: 0282 0000 00ff andil #255,%d2
49e1c: 2f02 movel %d2,%sp@-
49e1e: 2f06 movel %d6,%sp@-
49e20: 2f05 movel %d5,%sp@-
49e22: 42a7 clrl %sp@-
49e24: 4eb9 0004 9d38 jsr 49d38 <ramdisk_allocate>
if (rd == NULL) {
49e2a: 4fef 0010 lea %sp@(16),%sp
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
49e2e: 2800 movel %d0,%d4
if (rd == NULL) {
49e30: 660e bnes 49e40 <ramdisk_register+0x5a> <== ALWAYS TAKEN
rtems_io_unregister_driver(major);
49e32: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
49e36: 4eb9 0004 6f50 jsr 46f50 <rtems_io_unregister_driver> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
49e3c: 588f addql #4,%sp <== NOT EXECUTED
49e3e: 604c bras 49e8c <ramdisk_register+0xa6> <== NOT EXECUTED
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
49e40: 2f2e 0014 movel %fp@(20),%sp@-
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
temp.__overlay.minor = _minor;
return temp.device;
49e44: 4283 clrl %d3
49e46: 242e fffc movel %fp@(-4),%d2
49e4a: 2f00 movel %d0,%sp@-
49e4c: 4879 0004 9c4c pea 49c4c <ramdisk_ioctl>
49e52: 2f06 movel %d6,%sp@-
49e54: 2f05 movel %d5,%sp@-
49e56: 2f03 movel %d3,%sp@-
49e58: 2f02 movel %d2,%sp@-
49e5a: 4eb9 0004 26a8 jsr 426a8 <rtems_disk_create_phys>
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
49e60: 4fef 001c lea %sp@(28),%sp
49e64: 4a80 tstl %d0
49e66: 6716 beqs 49e7e <ramdisk_register+0x98> <== ALWAYS TAKEN
ramdisk_free(rd);
49e68: 2f04 movel %d4,%sp@- <== NOT EXECUTED
49e6a: 4eb9 0004 9dae jsr 49dae <ramdisk_free> <== NOT EXECUTED
rtems_io_unregister_driver(major);
49e70: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
49e74: 4eb9 0004 6f50 jsr 46f50 <rtems_io_unregister_driver> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
49e7a: 508f addql #8,%sp <== NOT EXECUTED
49e7c: 600e bras 49e8c <ramdisk_register+0xa6> <== NOT EXECUTED
}
*dev_ptr = dev;
49e7e: 206e 0018 moveal %fp@(24),%a0
return RTEMS_SUCCESSFUL;
49e82: 4280 clrl %d0
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
49e84: 2082 movel %d2,%a0@
49e86: 2143 0004 movel %d3,%a0@(4)
return RTEMS_SUCCESSFUL;
49e8a: 6002 bras 49e8e <ramdisk_register+0xa8>
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
49e8c: 700d moveq #13,%d0 <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
49e8e: 4cee 007c ffe8 moveml %fp@(-24),%d2-%d6
49e94: 4e5e unlk %fp <== NOT EXECUTED
0005a9a4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
5a9a4: 4e56 fff4 linkw %fp,#-12
5a9a8: 202e 0008 movel %fp@(8),%d0
5a9ac: 222e 000c movel %fp@(12),%d1
5a9b0: 206e 0010 moveal %fp@(16),%a0
5a9b4: 48d7 040c moveml %d2-%d3/%a2,%sp@
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
5a9b8: b0b9 0005 d2e2 cmpl 5d2e2 <rtems_libio_number_iops>,%d0
5a9be: 6436 bccs 5a9f6 <read+0x52>
iop = rtems_libio_iop( fd );
5a9c0: 2400 movel %d0,%d2
5a9c2: ed88 lsll #6,%d0
5a9c4: e78a lsll #3,%d2
5a9c6: 2479 0005 ea44 moveal 5ea44 <rtems_libio_iops>,%a2
5a9cc: 9082 subl %d2,%d0
5a9ce: d5c0 addal %d0,%a2
rtems_libio_check_is_open( iop );
5a9d0: 202a 0014 movel %a2@(20),%d0
5a9d4: 0800 0008 btst #8,%d0
5a9d8: 671c beqs 5a9f6 <read+0x52>
rtems_libio_check_buffer( buffer );
5a9da: 4a81 tstl %d1
5a9dc: 660e bnes 5a9ec <read+0x48> <== ALWAYS TAKEN
5a9de: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
5a9e4: 7216 moveq #22,%d1 <== NOT EXECUTED
5a9e6: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a9e8: 2081 movel %d1,%a0@ <== NOT EXECUTED
5a9ea: 6016 bras 5aa02 <read+0x5e> <== NOT EXECUTED
rtems_libio_check_count( count );
5a9ec: 4a88 tstl %a0
5a9ee: 6744 beqs 5aa34 <read+0x90>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
5a9f0: 0800 0001 btst #1,%d0
5a9f4: 6610 bnes 5aa06 <read+0x62>
5a9f6: 4eb9 0004 cd68 jsr 4cd68 <__errno>
5a9fc: 2040 moveal %d0,%a0
5a9fe: 7009 moveq #9,%d0
5aa00: 2080 movel %d0,%a0@
5aa02: 70ff moveq #-1,%d0
5aa04: 6030 bras 5aa36 <read+0x92>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
5aa06: 226a 0020 moveal %a2@(32),%a1
5aa0a: 2f08 movel %a0,%sp@-
5aa0c: 2f01 movel %d1,%sp@-
5aa0e: 2f0a movel %a2,%sp@-
5aa10: 2069 0008 moveal %a1@(8),%a0
5aa14: 4e90 jsr %a0@
if ( rc > 0 )
5aa16: 4fef 000c lea %sp@(12),%sp
5aa1a: 4a80 tstl %d0
5aa1c: 6f18 bles 5aa36 <read+0x92>
iop->offset += rc;
5aa1e: 2600 movel %d0,%d3
5aa20: 5bc2 smi %d2
5aa22: 49c2 extbl %d2
5aa24: d7aa 0010 addl %d3,%a2@(16)
5aa28: 222a 000c movel %a2@(12),%d1
5aa2c: d382 addxl %d2,%d1
5aa2e: 2541 000c movel %d1,%a2@(12)
5aa32: 6002 bras 5aa36 <read+0x92>
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
5aa34: 4280 clrl %d0
if ( rc > 0 )
iop->offset += rc;
return rc;
}
5aa36: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
5aa3c: 4e5e unlk %fp <== NOT EXECUTED
00044ab4 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
44ab4: 4e56 ffdc linkw %fp,#-36
44ab8: 48d7 001c moveml %d2-%d4,%sp@
44abc: 282e 0008 movel %fp@(8),%d4
44ac0: 262e 000c movel %fp@(12),%d3
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
44ac4: 660e bnes 44ad4 <readlink+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
44ac6: 4eb9 0004 e200 jsr 4e200 <__errno>
44acc: 720e moveq #14,%d1
44ace: 2040 moveal %d0,%a0
44ad0: 2081 movel %d1,%a0@
44ad2: 607c bras 44b50 <readlink+0x9c>
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
44ad4: 2f04 movel %d4,%sp@-
44ad6: 240e movel %fp,%d2
44ad8: 0682 ffff ffec addil #-20,%d2
44ade: 4eb9 0004 f588 jsr 4f588 <strlen>
44ae4: 4297 clrl %sp@
44ae6: 2f02 movel %d2,%sp@-
44ae8: 42a7 clrl %sp@-
44aea: 2f00 movel %d0,%sp@-
44aec: 2f04 movel %d4,%sp@-
44aee: 4eb9 0004 376c jsr 4376c <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
44af4: 4fef 0014 lea %sp@(20),%sp
44af8: 4a80 tstl %d0
44afa: 6654 bnes 44b50 <readlink+0x9c> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
44afc: 206e fff8 moveal %fp@(-8),%a0
44b00: 2f02 movel %d2,%sp@-
44b02: 2068 0010 moveal %a0@(16),%a0
44b06: 4e90 jsr %a0@
44b08: 588f addql #4,%sp
44b0a: 7204 moveq #4,%d1
44b0c: b280 cmpl %d0,%d1
44b0e: 6718 beqs 44b28 <readlink+0x74>
rtems_filesystem_freenode( &loc );
44b10: 2f02 movel %d2,%sp@-
44b12: 4eb9 0004 3938 jsr 43938 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
44b18: 4eb9 0004 e200 jsr 4e200 <__errno>
44b1e: 588f addql #4,%sp
44b20: 2040 moveal %d0,%a0
44b22: 7016 moveq #22,%d0
44b24: 2080 movel %d0,%a0@
44b26: 6028 bras 44b50 <readlink+0x9c>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
44b28: 2f2e 0010 movel %fp@(16),%sp@-
44b2c: 206e fff8 moveal %fp@(-8),%a0
44b30: 2f03 movel %d3,%sp@-
44b32: 2f02 movel %d2,%sp@-
44b34: 2068 003c moveal %a0@(60),%a0
44b38: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
44b3a: 2f02 movel %d2,%sp@-
44b3c: 2d40 ffe8 movel %d0,%fp@(-24)
44b40: 4eb9 0004 3938 jsr 43938 <rtems_filesystem_freenode>
return result;
44b46: 202e ffe8 movel %fp@(-24),%d0
44b4a: 4fef 0010 lea %sp@(16),%sp
44b4e: 6002 bras 44b52 <readlink+0x9e>
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
return -1;
44b50: 70ff moveq #-1,%d0
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
44b52: 4cee 001c ffdc moveml %fp@(-36),%d2-%d4
44b58: 4e5e unlk %fp <== NOT EXECUTED
00044464 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
44464: 4e56 ffe4 linkw %fp,#-28
44468: 202e 0008 movel %fp@(8),%d0
4446c: 48d7 0cdc moveml %d2-%d4/%d6-%d7/%a2-%a3,%sp@
44470: 246e 000c moveal %fp@(12),%a2
44474: 262e 0010 movel %fp@(16),%d3
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
44478: b0b9 0005 dae2 cmpl 5dae2 <rtems_libio_number_iops>,%d0
4447e: 6420 bccs 444a0 <readv+0x3c>
iop = rtems_libio_iop( fd );
44480: 2200 movel %d0,%d1
44482: ed88 lsll #6,%d0
44484: e789 lsll #3,%d1
44486: 2679 0005 f244 moveal 5f244 <rtems_libio_iops>,%a3
4448c: 9081 subl %d1,%d0
4448e: d7c0 addal %d0,%a3
rtems_libio_check_is_open( iop );
44490: 202b 0014 movel %a3@(20),%d0
44494: 0800 0008 btst #8,%d0
44498: 6706 beqs 444a0 <readv+0x3c>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4449a: 0800 0001 btst #1,%d0
4449e: 6610 bnes 444b0 <readv+0x4c> <== ALWAYS TAKEN
444a0: 4eb9 0004 d7d8 jsr 4d7d8 <__errno>
444a6: 7209 moveq #9,%d1
444a8: 2040 moveal %d0,%a0
444aa: 2081 movel %d1,%a0@
444ac: 6000 0098 braw 44546 <readv+0xe2>
/*
* Argument validation on IO vector
*/
if ( !iov )
444b0: 4a8a tstl %a2
444b2: 6728 beqs 444dc <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
444b4: 4a83 tstl %d3
444b6: 6f24 bles 444dc <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
444b8: 0c83 0000 0400 cmpil #1024,%d3
444be: 6e1c bgts 444dc <readv+0x78> <== NEVER TAKEN
444c0: 204a moveal %a2,%a0
444c2: 93c9 subal %a1,%a1
444c4: 4281 clrl %d1
444c6: 7001 moveq #1,%d0
444c8: 6002 bras 444cc <readv+0x68>
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
444ca: 2204 movel %d4,%d1
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
444cc: 4a90 tstl %a0@
444ce: 670c beqs 444dc <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
444d0: 2428 0004 movel %a0@(4),%d2
444d4: 2802 movel %d2,%d4
444d6: d881 addl %d1,%d4
if ( total < old )
444d8: b284 cmpl %d4,%d1
444da: 6f0e bles 444ea <readv+0x86>
rtems_set_errno_and_return_minus_one( EINVAL );
444dc: 4eb9 0004 d7d8 jsr 4d7d8 <__errno>
444e2: 2040 moveal %d0,%a0
444e4: 7016 moveq #22,%d0
444e6: 2080 movel %d0,%a0@
444e8: 605c bras 44546 <readv+0xe2>
if ( iov[v].iov_len )
all_zeros = false;
444ea: 4a82 tstl %d2
444ec: 57c1 seq %d1
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
444ee: 5289 addql #1,%a1
444f0: 5088 addql #8,%a0
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
444f2: c081 andl %d1,%d0
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
444f4: b689 cmpl %a1,%d3
444f6: 66d2 bnes 444ca <readv+0x66>
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
444f8: 4a00 tstb %d0
444fa: 6646 bnes 44542 <readv+0xde>
444fc: 4284 clrl %d4
444fe: 4282 clrl %d2
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
44500: 206b 0020 moveal %a3@(32),%a0
44504: 2f2a 0004 movel %a2@(4),%sp@-
44508: 2f12 movel %a2@,%sp@-
4450a: 2f0b movel %a3,%sp@-
4450c: 2068 0008 moveal %a0@(8),%a0
44510: 4e90 jsr %a0@
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
44512: 4fef 000c lea %sp@(12),%sp
44516: 4a80 tstl %d0
44518: 6d2c blts 44546 <readv+0xe2> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
4451a: 6716 beqs 44532 <readv+0xce> <== NEVER TAKEN
iop->offset += bytes;
total += bytes;
4451c: d480 addl %d0,%d2
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
4451e: 2e00 movel %d0,%d7
44520: 5bc6 smi %d6
44522: 49c6 extbl %d6
44524: dfab 0010 addl %d7,%a3@(16)
44528: 222b 000c movel %a3@(12),%d1
4452c: d386 addxl %d6,%d1
4452e: 2741 000c movel %d1,%a3@(12)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
44532: b0aa 0004 cmpl %a2@(4),%d0
44536: 6610 bnes 44548 <readv+0xe4> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
44538: 5284 addql #1,%d4
4453a: 508a addql #8,%a2
4453c: b684 cmpl %d4,%d3
4453e: 66c0 bnes 44500 <readv+0x9c>
44540: 6006 bras 44548 <readv+0xe4>
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
return 0;
44542: 4282 clrl %d2
44544: 6002 bras 44548 <readv+0xe4>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
44546: 74ff moveq #-1,%d2
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
44548: 2002 movel %d2,%d0
4454a: 4cee 0cdc ffe4 moveml %fp@(-28),%d2-%d4/%d6-%d7/%a2-%a3
44550: 4e5e unlk %fp <== NOT EXECUTED
0005aac4 <realloc>:
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
5aac4: 7003 moveq #3,%d0
void *realloc(
void *ptr,
size_t size
)
{
5aac6: 4e56 fff0 linkw %fp,#-16
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
5aaca: 52b9 0005 ea6c addql #1,5ea6c <rtems_malloc_statistics+0x10>
void *realloc(
void *ptr,
size_t size
)
{
5aad0: 48d7 001c moveml %d2-%d4,%sp@
5aad4: 242e 0008 movel %fp@(8),%d2
5aad8: 262e 000c movel %fp@(12),%d3
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
5aadc: b0b9 0005 ecdc cmpl 5ecdc <_System_state_Current>,%d0
5aae2: 6614 bnes 5aaf8 <realloc+0x34> <== NEVER TAKEN
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
5aae4: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
5aaea: 6600 00ac bnew 5ab98 <realloc+0xd4>
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
5aaee: 4ab9 0005 eff6 tstl 5eff6 <_Per_CPU_Information+0x8>
5aaf4: 6600 00a2 bnew 5ab98 <realloc+0xd4>
}
/*
* Continue with realloc().
*/
if ( !ptr )
5aaf8: 4a82 tstl %d2
5aafa: 6612 bnes 5ab0e <realloc+0x4a>
return malloc( size );
5aafc: 2d43 0008 movel %d3,%fp@(8)
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
5ab00: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
5ab06: 4e5e unlk %fp
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
5ab08: 4ef9 0004 2e54 jmp 42e54 <malloc>
if ( !size ) {
5ab0e: 4a83 tstl %d3
5ab10: 660c bnes 5ab1e <realloc+0x5a> <== ALWAYS TAKEN
free( ptr );
5ab12: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5ab14: 4eb9 0004 2b68 jsr 42b68 <free> <== NOT EXECUTED
return (void *) 0;
5ab1a: 588f addql #4,%sp <== NOT EXECUTED
5ab1c: 607a bras 5ab98 <realloc+0xd4> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
5ab1e: 486e fffc pea %fp@(-4)
5ab22: 2f02 movel %d2,%sp@-
5ab24: 2f39 0005 d29a movel 5d29a <RTEMS_Malloc_Heap>,%sp@-
5ab2a: 4eb9 0005 b03c jsr 5b03c <_Protected_heap_Get_block_size>
5ab30: 4fef 000c lea %sp@(12),%sp
5ab34: 4a00 tstb %d0
5ab36: 660e bnes 5ab46 <realloc+0x82>
errno = EINVAL;
5ab38: 4eb9 0004 cd68 jsr 4cd68 <__errno>
5ab3e: 2040 moveal %d0,%a0
5ab40: 7016 moveq #22,%d0
5ab42: 2080 movel %d0,%a0@
5ab44: 6052 bras 5ab98 <realloc+0xd4>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
5ab46: 2f03 movel %d3,%sp@-
5ab48: 2f02 movel %d2,%sp@-
5ab4a: 2f39 0005 d29a movel 5d29a <RTEMS_Malloc_Heap>,%sp@-
5ab50: 4eb9 0005 b078 jsr 5b078 <_Protected_heap_Resize_block>
5ab56: 4fef 000c lea %sp@(12),%sp
5ab5a: 4a00 tstb %d0
5ab5c: 663c bnes 5ab9a <realloc+0xd6>
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
5ab5e: 2f03 movel %d3,%sp@-
5ab60: 4eb9 0004 2e54 jsr 42e54 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
5ab66: 588f addql #4,%sp
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
5ab68: 53b9 0005 ea60 subql #1,5ea60 <rtems_malloc_statistics+0x4>
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
5ab6e: 2800 movel %d0,%d4
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
5ab70: 6726 beqs 5ab98 <realloc+0xd4>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
5ab72: 202e fffc movel %fp@(-4),%d0
5ab76: b083 cmpl %d3,%d0
5ab78: 6402 bccs 5ab7c <realloc+0xb8> <== NEVER TAKEN
5ab7a: 2600 movel %d0,%d3
5ab7c: 2f03 movel %d3,%sp@-
5ab7e: 2f02 movel %d2,%sp@-
5ab80: 2f04 movel %d4,%sp@-
5ab82: 4eb9 0004 d588 jsr 4d588 <memcpy>
free( ptr );
5ab88: 2f02 movel %d2,%sp@-
return new_area;
5ab8a: 2404 movel %d4,%d2
if ( !new_area ) {
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
5ab8c: 4eb9 0004 2b68 jsr 42b68 <free>
return new_area;
5ab92: 4fef 0010 lea %sp@(16),%sp
5ab96: 6002 bras 5ab9a <realloc+0xd6>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
5ab98: 4282 clrl %d2
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
5ab9a: 2002 movel %d2,%d0
5ab9c: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
5aba2: 4e5e unlk %fp
...
00043a9c <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
43a9c: 4e56 ffbc linkw %fp,#-68
43aa0: 48d7 047c moveml %d2-%d6/%a2,%sp@
43aa4: 2a2e 0008 movel %fp@(8),%d5
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
43aa8: 2f05 movel %d5,%sp@-
43aaa: 4eb9 0004 2d30 jsr 42d30 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
43ab0: 588f addql #4,%sp
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
43ab2: 2c00 movel %d0,%d6
43ab4: 200e movel %fp,%d0
43ab6: 0680 ffff ffd4 addil #-44,%d0
if ( parentpathlen == 0 )
43abc: 4a86 tstl %d6
43abe: 6616 bnes 43ad6 <rmdir+0x3a>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
43ac0: 2f00 movel %d0,%sp@-
43ac2: 486e fffc pea %fp@(-4)
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
43ac6: 4204 clrb %d4
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
43ac8: 2f05 movel %d5,%sp@-
43aca: 4eb9 0004 3bc8 jsr 43bc8 <rtems_filesystem_get_start_loc>
43ad0: 4fef 000c lea %sp@(12),%sp
43ad4: 601e bras 43af4 <rmdir+0x58>
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
43ad6: 42a7 clrl %sp@-
43ad8: 2f00 movel %d0,%sp@-
43ada: 4878 0002 pea 2 <DOUBLE_FLOAT>
43ade: 2f06 movel %d6,%sp@-
43ae0: 2f05 movel %d5,%sp@-
43ae2: 4eb9 0004 2ce4 jsr 42ce4 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
43ae8: 4fef 0014 lea %sp@(20),%sp
43aec: 4a80 tstl %d0
43aee: 6600 00c8 bnew 43bb8 <rmdir+0x11c>
return -1;
free_parentloc = true;
43af2: 7801 moveq #1,%d4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
43af4: 4878 0014 pea 14 <OPER2>
43af8: 260e movel %fp,%d3
43afa: 0683 ffff ffd4 addil #-44,%d3
43b00: 240e movel %fp,%d2
43b02: 0682 ffff ffe8 addil #-24,%d2
name = pathname + parentpathlen;
43b08: da86 addl %d6,%d5
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
43b0a: 45f9 0004 e6b0 lea 4e6b0 <strlen>,%a2
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
43b10: 2f03 movel %d3,%sp@-
43b12: 2f02 movel %d2,%sp@-
43b14: 4eb9 0004 db64 jsr 4db64 <memcpy>
name = pathname + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
43b1a: 2f05 movel %d5,%sp@-
43b1c: 4e92 jsr %a2@
43b1e: 2e80 movel %d0,%sp@
43b20: 2f05 movel %d5,%sp@-
43b22: 4eb9 0004 2d72 jsr 42d72 <rtems_filesystem_prefix_separators>
43b28: da80 addl %d0,%d5
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
43b2a: 2f05 movel %d5,%sp@-
43b2c: 4e92 jsr %a2@
43b2e: 4297 clrl %sp@
43b30: 2f02 movel %d2,%sp@-
43b32: 42a7 clrl %sp@-
43b34: 2f00 movel %d0,%sp@-
43b36: 2f05 movel %d5,%sp@-
43b38: 4eb9 0004 2c74 jsr 42c74 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
43b3e: 4fef 0028 lea %sp@(40),%sp
43b42: 4a80 tstl %d0
43b44: 6710 beqs 43b56 <rmdir+0xba>
if ( free_parentloc )
43b46: 4a04 tstb %d4
43b48: 676e beqs 43bb8 <rmdir+0x11c>
rtems_filesystem_freenode( &parentloc );
43b4a: 2f03 movel %d3,%sp@-
43b4c: 4eb9 0004 2db0 jsr 42db0 <rtems_filesystem_freenode>
43b52: 588f addql #4,%sp
43b54: 6062 bras 43bb8 <rmdir+0x11c>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
43b56: 206e fff4 moveal %fp@(-12),%a0
43b5a: 2f02 movel %d2,%sp@-
43b5c: 2068 0010 moveal %a0@(16),%a0
43b60: 4e90 jsr %a0@
43b62: 588f addql #4,%sp
43b64: 7201 moveq #1,%d1
43b66: b280 cmpl %d0,%d1
43b68: 6724 beqs 43b8e <rmdir+0xf2>
rtems_filesystem_freenode( &loc );
43b6a: 2f02 movel %d2,%sp@-
43b6c: 45f9 0004 2db0 lea 42db0 <rtems_filesystem_freenode>,%a2
43b72: 4e92 jsr %a2@
if ( free_parentloc )
43b74: 588f addql #4,%sp
43b76: 4a04 tstb %d4
43b78: 6706 beqs 43b80 <rmdir+0xe4> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
43b7a: 2f03 movel %d3,%sp@-
43b7c: 4e92 jsr %a2@
43b7e: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( ENOTDIR );
43b80: 4eb9 0004 d344 jsr 4d344 <__errno>
43b86: 2040 moveal %d0,%a0
43b88: 7014 moveq #20,%d0
43b8a: 2080 movel %d0,%a0@
43b8c: 602a bras 43bb8 <rmdir+0x11c>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
43b8e: 2f02 movel %d2,%sp@-
43b90: 206e fff0 moveal %fp@(-16),%a0
43b94: 2f03 movel %d3,%sp@-
43b96: 2068 0034 moveal %a0@(52),%a0
rtems_filesystem_freenode( &loc );
43b9a: 45f9 0004 2db0 lea 42db0 <rtems_filesystem_freenode>,%a2
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
43ba0: 4e90 jsr %a0@
43ba2: 2a00 movel %d0,%d5
rtems_filesystem_freenode( &loc );
43ba4: 2f02 movel %d2,%sp@-
43ba6: 4e92 jsr %a2@
if ( free_parentloc )
43ba8: 4fef 000c lea %sp@(12),%sp
43bac: 4a04 tstb %d4
43bae: 670a beqs 43bba <rmdir+0x11e>
rtems_filesystem_freenode( &parentloc );
43bb0: 2f03 movel %d3,%sp@-
43bb2: 4e92 jsr %a2@
43bb4: 588f addql #4,%sp
43bb6: 6002 bras 43bba <rmdir+0x11e>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
43bb8: 7aff moveq #-1,%d5
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
43bba: 2005 movel %d5,%d0
43bbc: 4cee 047c ffbc moveml %fp@(-68),%d2-%d6/%a2
43bc2: 4e5e unlk %fp
...
000466bc <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
466bc: 4e56 ffc8 linkw %fp,#-56
466c0: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
466c4: 4879 0006 12c8 pea 612c8 <aio_request_queue>
466ca: 4bf9 0004 6fe0 lea 46fe0 <pthread_mutex_lock>,%a5
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
466d0: 246e 0008 moveal %fp@(8),%a2
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
466d4: 4e95 jsr %a5@
if (result != 0) {
466d6: 588f addql #4,%sp
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
466d8: 2400 movel %d0,%d2
if (result != 0) {
466da: 670c beqs 466e8 <rtems_aio_enqueue+0x2c> <== ALWAYS TAKEN
free (req);
466dc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
466de: 4eb9 0004 33b4 jsr 433b4 <free> <== NOT EXECUTED
466e4: 6000 01b2 braw 46898 <rtems_aio_enqueue+0x1dc> <== NOT EXECUTED
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
466e8: 47f9 0004 77b8 lea 477b8 <pthread_self>,%a3
466ee: 4e93 jsr %a3@
466f0: 486e ffdc pea %fp@(-36)
466f4: 486e fffc pea %fp@(-4)
466f8: 2f00 movel %d0,%sp@-
466fa: 4eb9 0004 73dc jsr 473dc <pthread_getschedparam>
req->caller_thread = pthread_self ();
46700: 4e93 jsr %a3@
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
46702: 206a 0014 moveal %a2@(20),%a0
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
46706: 7277 moveq #119,%d1
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
46708: 4fef 000c lea %sp@(12),%sp
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
4670c: 2540 0010 movel %d0,%a2@(16)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
46710: 202e ffdc movel %fp@(-36),%d0
46714: 90a8 0014 subl %a0@(20),%d0
req->policy = policy;
46718: 256e fffc 0008 movel %fp@(-4),%a2@(8)
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
4671e: 2540 000c movel %d0,%a2@(12)
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
46722: 2141 0030 movel %d1,%a0@(48)
req->aiocbp->return_value = 0;
46726: 42a8 0034 clrl %a0@(52)
if ((aio_request_queue.idle_threads == 0) &&
4672a: 4ab9 0006 1330 tstl 61330 <aio_request_queue+0x68>
46730: 6600 009e bnew 467d0 <rtems_aio_enqueue+0x114>
46734: 7004 moveq #4,%d0
46736: b0b9 0006 132c cmpl 6132c <aio_request_queue+0x64>,%d0
4673c: 6d00 0092 bltw 467d0 <rtems_aio_enqueue+0x114>
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
46740: 4878 0001 pea 1 <ADD>
46744: 2f10 movel %a0@,%sp@-
46746: 4879 0006 1310 pea 61310 <aio_request_queue+0x48>
4674c: 4eb9 0004 62ba jsr 462ba <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
46752: 4fef 000c lea %sp@(12),%sp
46756: 7201 moveq #1,%d1
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
46758: 2640 moveal %d0,%a3
if (r_chain->new_fd == 1) {
4675a: b2ab 0018 cmpl %a3@(24),%d1
4675e: 6666 bnes 467c6 <rtems_aio_enqueue+0x10a>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
46760: 2f0a movel %a2,%sp@-
46762: 486b 0008 pea %a3@(8)
46766: 4eb9 0004 88b0 jsr 488b0 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
4676c: 42ab 0018 clrl %a3@(24)
pthread_mutex_init (&r_chain->mutex, NULL);
46770: 42a7 clrl %sp@-
46772: 486b 001c pea %a3@(28)
46776: 4eb9 0004 6ec4 jsr 46ec4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
4677c: 42a7 clrl %sp@-
4677e: 486b 0020 pea %a3@(32)
46782: 4eb9 0004 6b54 jsr 46b54 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
46788: 2f0b movel %a3,%sp@-
4678a: 487a fbf4 pea %pc@(46380 <rtems_aio_handle>)
4678e: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8>
46794: 486e fff8 pea %fp@(-8)
46798: 4eb9 0004 71d8 jsr 471d8 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
4679e: 4fef 0028 lea %sp@(40),%sp
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
pthread_cond_init (&r_chain->cond, NULL);
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
467a2: 2440 moveal %d0,%a2
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
467a4: 4a80 tstl %d0
467a6: 6714 beqs 467bc <rtems_aio_enqueue+0x100> <== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
467a8: 4879 0006 12c8 pea 612c8 <aio_request_queue> <== NOT EXECUTED
return result;
467ae: 240a movel %a2,%d2 <== NOT EXECUTED
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
467b0: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
467b6: 588f addql #4,%sp <== NOT EXECUTED
467b8: 6000 00e0 braw 4689a <rtems_aio_enqueue+0x1de> <== NOT EXECUTED
}
++aio_request_queue.active_threads;
467bc: 52b9 0006 132c addql #1,6132c <aio_request_queue+0x64>
467c2: 6000 00c8 braw 4688c <rtems_aio_enqueue+0x1d0>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
467c6: 49eb 001c lea %a3@(28),%a4
467ca: 2f0c movel %a4,%sp@-
467cc: 4e95 jsr %a5@
467ce: 6028 bras 467f8 <rtems_aio_enqueue+0x13c>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
467d0: 42a7 clrl %sp@-
467d2: 2f10 movel %a0@,%sp@-
467d4: 49f9 0004 62ba lea 462ba <rtems_aio_search_fd>,%a4
467da: 4879 0006 1310 pea 61310 <aio_request_queue+0x48>
467e0: 4e94 jsr %a4@
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
467e2: 4fef 000c lea %sp@(12),%sp
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
467e6: 2640 moveal %d0,%a3
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
467e8: 4a80 tstl %d0
467ea: 6730 beqs 4681c <rtems_aio_enqueue+0x160>
{
pthread_mutex_lock (&r_chain->mutex);
467ec: 49eb 001c lea %a3@(28),%a4
467f0: 2f0c movel %a4,%sp@-
467f2: 4eb9 0004 6fe0 jsr 46fe0 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
467f8: 2f0a movel %a2,%sp@-
467fa: 486b 0008 pea %a3@(8)
467fe: 4eb9 0004 65ba jsr 465ba <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
46804: 486b 0020 pea %a3@(32)
46808: 4eb9 0004 6c04 jsr 46c04 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
4680e: 2f0c movel %a4,%sp@-
46810: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
46816: 4fef 0014 lea %sp@(20),%sp
4681a: 6070 bras 4688c <rtems_aio_enqueue+0x1d0>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
4681c: 4878 0001 pea 1 <ADD>
46820: 206a 0014 moveal %a2@(20),%a0
46824: 2f10 movel %a0@,%sp@-
46826: 4879 0006 131c pea 6131c <aio_request_queue+0x54>
4682c: 4e94 jsr %a4@
if (r_chain->new_fd == 1) {
4682e: 4fef 000c lea %sp@(12),%sp
46832: 7201 moveq #1,%d1
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
46834: 2640 moveal %d0,%a3
46836: 5080 addql #8,%d0
if (r_chain->new_fd == 1) {
46838: b2ab 0018 cmpl %a3@(24),%d1
4683c: 662c bnes 4686a <rtems_aio_enqueue+0x1ae>
4683e: 2f0a movel %a2,%sp@-
46840: 2f00 movel %d0,%sp@-
46842: 4eb9 0004 88b0 jsr 488b0 <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
46848: 42ab 0018 clrl %a3@(24)
pthread_mutex_init (&r_chain->mutex, NULL);
4684c: 42a7 clrl %sp@-
4684e: 486b 001c pea %a3@(28)
46852: 4eb9 0004 6ec4 jsr 46ec4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
46858: 42a7 clrl %sp@-
4685a: 486b 0020 pea %a3@(32)
4685e: 4eb9 0004 6b54 jsr 46b54 <pthread_cond_init>
46864: 4fef 0018 lea %sp@(24),%sp
46868: 600c bras 46876 <rtems_aio_enqueue+0x1ba>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
4686a: 2f0a movel %a2,%sp@-
4686c: 2f00 movel %d0,%sp@-
4686e: 4eb9 0004 65ba jsr 465ba <rtems_aio_insert_prio>
46874: 508f addql #8,%sp
if (aio_request_queue.idle_threads > 0)
46876: 4ab9 0006 1330 tstl 61330 <aio_request_queue+0x68>
4687c: 6f0e bles 4688c <rtems_aio_enqueue+0x1d0> <== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
4687e: 4879 0006 12cc pea 612cc <aio_request_queue+0x4> <== NOT EXECUTED
46884: 4eb9 0004 6c04 jsr 46c04 <pthread_cond_signal> <== NOT EXECUTED
4688a: 588f addql #4,%sp <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
4688c: 4879 0006 12c8 pea 612c8 <aio_request_queue>
46892: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return 0;
46898: 588f addql #4,%sp
}
4689a: 2002 movel %d2,%d0
4689c: 4cee 3c04 ffc8 moveml %fp@(-56),%d2/%a2-%a5
468a2: 4e5e unlk %fp
...
00046380 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
46380: 4e56 ffac linkw %fp,#-84
46384: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
46388: 240e movel %fp,%d2
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
4638a: 280e movel %fp,%d4
4638c: 2e0e movel %fp,%d7
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
4638e: 2a3c 0004 6fe0 movel #290784,%d5
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
46394: 49f9 0004 7078 lea 47078 <pthread_mutex_unlock>,%a4
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
4639a: 0682 ffff fff4 addil #-12,%d2
463a0: 4bf9 0004 6a28 lea 46a28 <clock_gettime>,%a5
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
463a6: 0684 ffff ffd8 addil #-40,%d4
463ac: 5987 subql #4,%d7
static void *
rtems_aio_handle (void *arg)
{
rtems_aio_request_chain *r_chain = arg;
463ae: 246e 0008 moveal %fp@(8),%a2
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
463b2: 260a movel %a2,%d3
463b4: 0683 0000 001c addil #28,%d3
463ba: 2045 moveal %d5,%a0
463bc: 2f03 movel %d3,%sp@-
463be: 4e90 jsr %a0@
if (result != 0)
463c0: 588f addql #4,%sp
463c2: 4a80 tstl %d0
463c4: 6600 01e8 bnew 465ae <rtems_aio_handle+0x22e>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
463c8: 200a movel %a2,%d0
463ca: 0680 0000 000c addil #12,%d0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
463d0: 266a 0008 moveal %a2@(8),%a3
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
463d4: b08b cmpl %a3,%d0
463d6: 6700 00d8 beqw 464b0 <rtems_aio_handle+0x130>
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
463da: 2c3c 0004 77b8 movel #292792,%d6
463e0: 2046 moveal %d6,%a0
463e2: 4e90 jsr %a0@
463e4: 2f04 movel %d4,%sp@-
463e6: 2f07 movel %d7,%sp@-
463e8: 2f00 movel %d0,%sp@-
463ea: 4eb9 0004 73dc jsr 473dc <pthread_getschedparam>
param.sched_priority = req->priority;
pthread_setschedparam (pthread_self(), req->policy, ¶m);
463f0: 222b 0008 movel %a3@(8),%d1
463f4: 2046 moveal %d6,%a0
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
param.sched_priority = req->priority;
463f6: 2d6b 000c ffd8 movel %a3@(12),%fp@(-40)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
463fc: 2d41 ffd4 movel %d1,%fp@(-44)
46400: 4e90 jsr %a0@
46402: 2f04 movel %d4,%sp@-
46404: 2f2e ffd4 movel %fp@(-44),%sp@-
46408: 2f00 movel %d0,%sp@-
4640a: 4eb9 0004 77cc jsr 477cc <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
46410: 2f0b movel %a3,%sp@-
46412: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
46418: 2f03 movel %d3,%sp@-
4641a: 4e94 jsr %a4@
switch (req->aiocbp->aio_lio_opcode) {
4641c: 206b 0014 moveal %a3@(20),%a0
46420: 4fef 0020 lea %sp@(32),%sp
46424: 7202 moveq #2,%d1
46426: 2028 002c movel %a0@(44),%d0
4642a: b280 cmpl %d0,%d1
4642c: 672a beqs 46458 <rtems_aio_handle+0xd8>
4642e: 123c 0003 moveb #3,%d1
46432: b280 cmpl %d0,%d1
46434: 6740 beqs 46476 <rtems_aio_handle+0xf6> <== NEVER TAKEN
46436: 123c 0001 moveb #1,%d1
4643a: b280 cmpl %d0,%d1
4643c: 6648 bnes 46486 <rtems_aio_handle+0x106> <== NEVER TAKEN
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
4643e: 2f28 0008 movel %a0@(8),%sp@-
46442: 2f28 0004 movel %a0@(4),%sp@-
46446: 2f28 0010 movel %a0@(16),%sp@-
4644a: 2f28 000c movel %a0@(12),%sp@-
4644e: 2f10 movel %a0@,%sp@-
46450: 4eb9 0004 fbdc jsr 4fbdc <pread>
46456: 6018 bras 46470 <rtems_aio_handle+0xf0>
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
46458: 2f28 0008 movel %a0@(8),%sp@-
4645c: 2f28 0004 movel %a0@(4),%sp@-
46460: 2f28 0010 movel %a0@(16),%sp@-
46464: 2f28 000c movel %a0@(12),%sp@-
46468: 2f10 movel %a0@,%sp@-
4646a: 4eb9 0004 fca0 jsr 4fca0 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
46470: 4fef 0014 lea %sp@(20),%sp
46474: 600a bras 46480 <rtems_aio_handle+0x100>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
46476: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
46478: 4eb9 0004 c5a8 jsr 4c5a8 <fsync> <== NOT EXECUTED
break;
4647e: 588f addql #4,%sp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
46480: 72ff moveq #-1,%d1
46482: b280 cmpl %d0,%d1
46484: 661a bnes 464a0 <rtems_aio_handle+0x120> <== ALWAYS TAKEN
req->aiocbp->return_value = -1;
46486: 266b 0014 moveal %a3@(20),%a3 <== NOT EXECUTED
4648a: 70ff moveq #-1,%d0 <== NOT EXECUTED
4648c: 2740 0034 movel %d0,%a3@(52) <== NOT EXECUTED
req->aiocbp->error_code = errno;
46490: 4eb9 0004 f1bc jsr 4f1bc <__errno> <== NOT EXECUTED
46496: 2040 moveal %d0,%a0 <== NOT EXECUTED
46498: 2750 0030 movel %a0@,%a3@(48) <== NOT EXECUTED
4649c: 6000 ff14 braw 463b2 <rtems_aio_handle+0x32> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
464a0: 206b 0014 moveal %a3@(20),%a0
464a4: 2140 0034 movel %d0,%a0@(52)
req->aiocbp->error_code = 0;
464a8: 42a8 0030 clrl %a0@(48)
464ac: 6000 ff04 braw 463b2 <rtems_aio_handle+0x32>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
464b0: 2f03 movel %d3,%sp@-
464b2: 4e94 jsr %a4@
pthread_mutex_lock (&aio_request_queue.mutex);
464b4: 4879 0006 12c8 pea 612c8 <aio_request_queue>
464ba: 2045 moveal %d5,%a0
464bc: 4e90 jsr %a0@
if (rtems_chain_is_empty (chain))
464be: 508f addql #8,%sp
464c0: b7ea 0008 cmpal %a2@(8),%a3
464c4: 6600 00da bnew 465a0 <rtems_aio_handle+0x220>
{
clock_gettime (CLOCK_REALTIME, &timeout);
464c8: 2f02 movel %d2,%sp@-
464ca: 4878 0001 pea 1 <ADD>
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
464ce: 2c0a movel %a2,%d6
464d0: 0686 0000 0020 addil #32,%d6
464d6: 47f9 0004 6c78 lea 46c78 <pthread_cond_timedwait>,%a3
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
464dc: 4e95 jsr %a5@
timeout.tv_sec += 3;
464de: 56ae fff4 addql #3,%fp@(-12)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
464e2: 2f02 movel %d2,%sp@-
464e4: 4879 0006 12c8 pea 612c8 <aio_request_queue>
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
464ea: 42ae fff8 clrl %fp@(-8)
result = pthread_cond_timedwait (&r_chain->cond,
464ee: 2f06 movel %d6,%sp@-
464f0: 4e93 jsr %a3@
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
464f2: 4fef 0014 lea %sp@(20),%sp
464f6: 7274 moveq #116,%d1
464f8: b280 cmpl %d0,%d1
464fa: 6600 00a4 bnew 465a0 <rtems_aio_handle+0x220>
464fe: 2f0a movel %a2,%sp@-
46500: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
46506: 2f03 movel %d3,%sp@-
46508: 4eb9 0004 6da8 jsr 46da8 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
4650e: 2f06 movel %d6,%sp@-
46510: 4eb9 0004 6a94 jsr 46a94 <pthread_cond_destroy>
free (r_chain);
46516: 2f0a movel %a2,%sp@-
46518: 4eb9 0004 33b4 jsr 433b4 <free>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
4651e: 4fef 0010 lea %sp@(16),%sp
46522: 41f9 0006 1320 lea 61320 <aio_request_queue+0x58>,%a0
46528: b1f9 0006 131c cmpal 6131c <aio_request_queue+0x54>,%a0
4652e: 664c bnes 4657c <rtems_aio_handle+0x1fc>
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
46530: 2f02 movel %d2,%sp@-
46532: 4878 0001 pea 1 <ADD>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
46536: 52b9 0006 1330 addql #1,61330 <aio_request_queue+0x68>
--aio_request_queue.active_threads;
4653c: 53b9 0006 132c subql #1,6132c <aio_request_queue+0x64>
clock_gettime (CLOCK_REALTIME, &timeout);
46542: 4e95 jsr %a5@
timeout.tv_sec += 3;
46544: 56ae fff4 addql #3,%fp@(-12)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
46548: 2f02 movel %d2,%sp@-
4654a: 4879 0006 12c8 pea 612c8 <aio_request_queue>
46550: 4879 0006 12cc pea 612cc <aio_request_queue+0x4>
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
46556: 42ae fff8 clrl %fp@(-8)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
4655a: 4e93 jsr %a3@
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
4655c: 4fef 0014 lea %sp@(20),%sp
46560: 7274 moveq #116,%d1
46562: b280 cmpl %d0,%d1
46564: 6616 bnes 4657c <rtems_aio_handle+0x1fc> <== NEVER TAKEN
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
46566: 4879 0006 12c8 pea 612c8 <aio_request_queue>
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
4656c: 53b9 0006 1330 subql #1,61330 <aio_request_queue+0x68>
pthread_mutex_unlock (&aio_request_queue.mutex);
46572: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return NULL;
46578: 588f addql #4,%sp
4657a: 6032 bras 465ae <rtems_aio_handle+0x22e>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4657c: 2479 0006 131c moveal 6131c <aio_request_queue+0x54>,%a2
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
46582: 53b9 0006 1330 subql #1,61330 <aio_request_queue+0x68>
++aio_request_queue.active_threads;
46588: 52b9 0006 132c addql #1,6132c <aio_request_queue+0x64>
4658e: 2f0a movel %a2,%sp@-
46590: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
46596: 2f0a movel %a2,%sp@-
46598: 4eb9 0004 634a jsr 4634a <rtems_aio_move_to_work>
4659e: 508f addql #8,%sp
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
465a0: 4879 0006 12c8 pea 612c8 <aio_request_queue>
465a6: 4e94 jsr %a4@
465a8: 588f addql #4,%sp
465aa: 6000 fe06 braw 463b2 <rtems_aio_handle+0x32>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
465ae: 4280 clrl %d0
465b0: 4cee 3cfc ffac moveml %fp@(-84),%d2-%d7/%a2-%a5
465b6: 4e5e unlk %fp <== NOT EXECUTED
000461d0 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
461d0: 4e56 0000 linkw %fp,#0
461d4: 2f02 movel %d2,%sp@-
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
461d6: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8>
461dc: 4eb9 0004 7184 jsr 47184 <pthread_attr_init>
if (result != 0)
461e2: 588f addql #4,%sp
int
rtems_aio_init (void)
{
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
461e4: 2400 movel %d0,%d2
if (result != 0)
461e6: 6600 00c8 bnew 462b0 <rtems_aio_init+0xe0>
return result;
result =
461ea: 42a7 clrl %sp@-
461ec: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8>
461f2: 4eb9 0004 71b0 jsr 471b0 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
461f8: 508f addql #8,%sp
461fa: 4a80 tstl %d0
461fc: 670e beqs 4620c <rtems_aio_init+0x3c> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
461fe: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> <== NOT EXECUTED
46204: 4eb9 0004 7168 jsr 47168 <pthread_attr_destroy> <== NOT EXECUTED
4620a: 588f addql #4,%sp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
4620c: 42a7 clrl %sp@-
4620e: 4879 0006 12c8 pea 612c8 <aio_request_queue>
46214: 4eb9 0004 6ec4 jsr 46ec4 <pthread_mutex_init>
if (result != 0)
4621a: 508f addql #8,%sp
4621c: 4a80 tstl %d0
4621e: 670e beqs 4622e <rtems_aio_init+0x5e> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
46220: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> <== NOT EXECUTED
46226: 4eb9 0004 7168 jsr 47168 <pthread_attr_destroy> <== NOT EXECUTED
4622c: 588f addql #4,%sp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
4622e: 42a7 clrl %sp@-
46230: 4879 0006 12cc pea 612cc <aio_request_queue+0x4>
46236: 4eb9 0004 6b54 jsr 46b54 <pthread_cond_init>
if (result != 0) {
4623c: 508f addql #8,%sp
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
4623e: 2400 movel %d0,%d2
if (result != 0) {
46240: 671a beqs 4625c <rtems_aio_init+0x8c> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
46242: 4879 0006 12c8 pea 612c8 <aio_request_queue> <== NOT EXECUTED
46248: 4eb9 0004 6da8 jsr 46da8 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
4624e: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> <== NOT EXECUTED
46254: 4eb9 0004 7168 jsr 47168 <pthread_attr_destroy> <== NOT EXECUTED
4625a: 508f addql #8,%sp <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4625c: 42b9 0006 1314 clrl 61314 <aio_request_queue+0x4c>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
46262: 203c 0006 1314 movel #398100,%d0
46268: 23c0 0006 1310 movel %d0,61310 <aio_request_queue+0x48>
head->previous = NULL;
tail->previous = head;
4626e: 203c 0006 1310 movel #398096,%d0
46274: 23c0 0006 1318 movel %d0,61318 <aio_request_queue+0x50>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4627a: 203c 0006 1320 movel #398112,%d0
46280: 23c0 0006 131c movel %d0,6131c <aio_request_queue+0x54>
head->previous = NULL;
tail->previous = head;
46286: 203c 0006 131c movel #398108,%d0
4628c: 23c0 0006 1324 movel %d0,61324 <aio_request_queue+0x5c>
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
46292: 203c 0000 b00b movel #45067,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
46298: 42b9 0006 1320 clrl 61320 <aio_request_queue+0x58>
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
4629e: 42b9 0006 132c clrl 6132c <aio_request_queue+0x64>
aio_request_queue.idle_threads = 0;
462a4: 42b9 0006 1330 clrl 61330 <aio_request_queue+0x68>
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
462aa: 23c0 0006 1328 movel %d0,61328 <aio_request_queue+0x60>
return result;
}
462b0: 2002 movel %d2,%d0
462b2: 242e fffc movel %fp@(-4),%d2
462b6: 4e5e unlk %fp <== NOT EXECUTED
000465ba <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
465ba: 4e56 0000 linkw %fp,#0
465be: 202e 0008 movel %fp@(8),%d0
465c2: 2240 moveal %d0,%a1
465c4: 2f0b movel %a3,%sp@-
465c6: 2059 moveal %a1@+,%a0
465c8: 2f0a movel %a2,%sp@-
465ca: 246e 000c moveal %fp@(12),%a2
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
465ce: b3c8 cmpal %a0,%a1
465d0: 672e beqs 46600 <rtems_aio_insert_prio+0x46> <== NEVER TAKEN
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
465d2: 2668 0014 moveal %a0@(20),%a3
465d6: 202b 0014 movel %a3@(20),%d0
while (req->aiocbp->aio_reqprio > prio &&
465da: 266a 0014 moveal %a2@(20),%a3
465de: 222b 0014 movel %a3@(20),%d1
465e2: 600a bras 465ee <rtems_aio_insert_prio+0x34>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
465e4: 2050 moveal %a0@,%a0 <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
465e6: 2668 0014 moveal %a0@(20),%a3 <== NOT EXECUTED
465ea: 202b 0014 movel %a3@(20),%d0 <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
465ee: b081 cmpl %d1,%d0
465f0: 6c04 bges 465f6 <rtems_aio_insert_prio+0x3c> <== ALWAYS TAKEN
465f2: b3c8 cmpal %a0,%a1 <== NOT EXECUTED
465f4: 66ee bnes 465e4 <rtems_aio_insert_prio+0x2a> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
465f6: 2d4a 000c movel %a2,%fp@(12)
465fa: 2d68 0004 0008 movel %a0@(4),%fp@(8)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
46600: 245f moveal %sp@+,%a2
46602: 265f moveal %sp@+,%a3
46604: 4e5e unlk %fp
46606: 4ef9 0004 88b0 jmp 488b0 <_Chain_Insert>
0004634a <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
4634a: 4e56 0000 linkw %fp,#0
4634e: 226e 0008 moveal %fp@(8),%a1
rtems_aio_request_chain *temp;
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
46352: 2079 0006 1310 moveal 61310 <aio_request_queue+0x48>,%a0
while (temp->fildes < r_chain->fildes &&
46358: 2029 0014 movel %a1@(20),%d0
4635c: 6002 bras 46360 <rtems_aio_move_to_work+0x16>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
4635e: 2050 moveal %a0@,%a0
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
46360: b0a8 0014 cmpl %a0@(20),%d0
46364: 6f08 bles 4636e <rtems_aio_move_to_work+0x24>
46366: b1fc 0006 1314 cmpal #398100,%a0
4636c: 66f0 bnes 4635e <rtems_aio_move_to_work+0x14> <== ALWAYS TAKEN
4636e: 2f09 movel %a1,%sp@-
46370: 2f28 0004 movel %a0@(4),%sp@-
46374: 4eb9 0004 88b0 jsr 488b0 <_Chain_Insert>
4637a: 508f addql #8,%sp
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
4637c: 4e5e unlk %fp <== NOT EXECUTED
00046662 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
46662: 4e56 0000 linkw %fp,#0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
46666: 206e 0008 moveal %fp@(8),%a0
4666a: 2f0a movel %a2,%sp@-
4666c: 202e 000c movel %fp@(12),%d0
46670: 2458 moveal %a0@+,%a2
if (rtems_chain_is_empty (chain))
46672: b1ca cmpal %a2,%a0
46674: 6604 bnes 4667a <rtems_aio_remove_req+0x18>
46676: 6036 bras 466ae <rtems_aio_remove_req+0x4c>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
46678: 2452 moveal %a2@,%a2 <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
4667a: b1ca cmpal %a2,%a0
4667c: 6734 beqs 466b2 <rtems_aio_remove_req+0x50> <== NEVER TAKEN
4667e: b0aa 0014 cmpl %a2@(20),%d0
46682: 66f4 bnes 46678 <rtems_aio_remove_req+0x16> <== NEVER TAKEN
46684: 2f0a movel %a2,%sp@-
46686: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
4668c: 206a 0014 moveal %a2@(20),%a0
46690: 203c 0000 008c movel #140,%d0
46696: 2140 0030 movel %d0,%a0@(48)
current->aiocbp->return_value = -1;
4669a: 70ff moveq #-1,%d0
4669c: 2140 0034 movel %d0,%a0@(52)
free (current);
466a0: 2f0a movel %a2,%sp@-
466a2: 4eb9 0004 33b4 jsr 433b4 <free>
}
return AIO_CANCELED;
466a8: 508f addql #8,%sp
466aa: 4280 clrl %d0
466ac: 6006 bras 466b4 <rtems_aio_remove_req+0x52>
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
466ae: 7002 moveq #2,%d0
466b0: 6002 bras 466b4 <rtems_aio_remove_req+0x52>
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
466b2: 7001 moveq #1,%d0 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
466b4: 246e fffc moveal %fp@(-4),%a2
466b8: 4e5e unlk %fp <== NOT EXECUTED
0004a372 <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
4a372: 4e56 fff4 linkw %fp,#-12
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
4a376: 1039 0006 1712 moveb 61712 <bdbuf_cache+0x2e>,%d0
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
4a37c: 48d7 040c moveml %d2-%d3/%a2,%sp@
4a380: 246e 0008 moveal %fp@(8),%a2
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
4a384: 4a00 tstb %d0
4a386: 672a beqs 4a3b2 <rtems_bdbuf_add_to_modified_list_after_access+0x40><== ALWAYS TAKEN
4a388: 2039 0006 1718 movel 61718 <bdbuf_cache+0x34>,%d0 <== NOT EXECUTED
4a38e: 2239 0006 171c movel 6171c <bdbuf_cache+0x38>,%d1 <== NOT EXECUTED
4a394: 242a 0012 movel %a2@(18),%d2 <== NOT EXECUTED
4a398: 262a 0016 movel %a2@(22),%d3 <== NOT EXECUTED
4a39c: 9681 subl %d1,%d3 <== NOT EXECUTED
4a39e: 9580 subxl %d0,%d2 <== NOT EXECUTED
4a3a0: 6610 bnes 4a3b2 <rtems_bdbuf_add_to_modified_list_after_access+0x40><== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
4a3a2: 4eba fce8 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>) <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
4a3a6: 4eba fb5c jsr %pc@(49f04 <rtems_bdbuf_lock_sync>) <== NOT EXECUTED
rtems_bdbuf_unlock_sync ();
4a3aa: 4eba fd06 jsr %pc@(4a0b2 <rtems_bdbuf_unlock_sync>) <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4a3ae: 4eba fb28 jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>) <== NOT EXECUTED
* difficult question. Is a snapshot of a block that is changing better than
* nothing being written? We have tended to think we should hold changes for
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
4a3b2: 202a 0022 movel %a2@(34),%d0
4a3b6: 7603 moveq #3,%d3
4a3b8: b680 cmpl %d0,%d3
4a3ba: 670a beqs 4a3c6 <rtems_bdbuf_add_to_modified_list_after_access+0x54>
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
4a3bc: 202a 0022 movel %a2@(34),%d0
4a3c0: 7205 moveq #5,%d1
4a3c2: b280 cmpl %d0,%d1
4a3c4: 660a bnes 4a3d0 <rtems_bdbuf_add_to_modified_list_after_access+0x5e>
bd->hold_timer = bdbuf_config.swap_block_hold;
4a3c6: 41f9 0005 e9fc lea 5e9fc <rtems_bdbuf_configuration+0x10>,%a0
4a3cc: 2550 002e movel %a0@,%a2@(46)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a3d0: 7007 moveq #7,%d0
4a3d2: 2540 0022 movel %d0,%a2@(34)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4a3d6: 2f0a movel %a2,%sp@-
4a3d8: 4879 0006 1730 pea 61730 <bdbuf_cache+0x4c>
4a3de: 4eb9 0004 71e4 jsr 471e4 <_Chain_Append>
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
4a3e4: 202a 0026 movel %a2@(38),%d0
4a3e8: 508f addql #8,%sp
4a3ea: 6716 beqs 4a402 <rtems_bdbuf_add_to_modified_list_after_access+0x90>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4a3ec: 223c 0006 1748 movel #399176,%d1
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
4a3f2: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4a3f8: 2d41 0008 movel %d1,%fp@(8)
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
4a3fc: 4e5e unlk %fp
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4a3fe: 6000 ff46 braw 4a346 <rtems_bdbuf_wake>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
4a402: 2039 0006 1758 movel 61758 <bdbuf_cache+0x74>,%d0
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
4a408: 670c beqs 4a416 <rtems_bdbuf_add_to_modified_list_after_access+0xa4>
rtems_bdbuf_wake_swapper ();
}
4a40a: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
4a410: 4e5e unlk %fp
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
4a412: 6000 fce8 braw 4a0fc <rtems_bdbuf_wake_swapper>
}
4a416: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
4a41c: 4e5e unlk %fp <== NOT EXECUTED
0004a1ea <rtems_bdbuf_anonymous_wait>:
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
4a1ea: 4e56 0000 linkw %fp,#0
4a1ee: 2f0a movel %a2,%sp@-
4a1f0: 246e 0008 moveal %fp@(8),%a2
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
4a1f4: 2012 movel %a2@,%d0
4a1f6: 5280 addql #1,%d0
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
4a1f8: 2f02 movel %d2,%sp@-
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
4a1fa: 2480 movel %d0,%a2@
* blocking or just hits that window, and before this task has blocked on the
* semaphore. If the preempting task flushes the queue this task will not see
* the flush and may block for ever or until another transaction flushes this
* semaphore.
*/
prev_mode = rtems_bdbuf_disable_preemption ();
4a1fc: 4eba ff88 jsr %pc@(4a186 <rtems_bdbuf_disable_preemption>)
4a200: 2400 movel %d0,%d2
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
4a202: 4eba fe88 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
4a206: 42a7 clrl %sp@-
4a208: 42a7 clrl %sp@-
4a20a: 2f2a 0004 movel %a2@(4),%sp@-
4a20e: 4eb9 0004 66c8 jsr 466c8 <rtems_semaphore_obtain>
if (sc == RTEMS_TIMEOUT)
4a214: 4fef 000c lea %sp@(12),%sp
4a218: 7206 moveq #6,%d1
4a21a: b280 cmpl %d0,%d1
4a21c: 6608 bnes 4a226 <rtems_bdbuf_anonymous_wait+0x3c><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
4a21e: 2f3c 4200 0012 movel #1107296274,%sp@- <== NOT EXECUTED
4a224: 600c bras 4a232 <rtems_bdbuf_anonymous_wait+0x48><== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
4a226: 720d moveq #13,%d1
4a228: b280 cmpl %d0,%d1
4a22a: 670c beqs 4a238 <rtems_bdbuf_anonymous_wait+0x4e><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
4a22c: 2f3c 4200 0010 movel #1107296272,%sp@- <== NOT EXECUTED
4a232: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4a238: 4eba fc9e jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
rtems_bdbuf_restore_preemption (prev_mode);
4a23c: 2f02 movel %d2,%sp@-
4a23e: 4eba ff7a jsr %pc@(4a1ba <rtems_bdbuf_restore_preemption>)
--waiters->count;
4a242: 2012 movel %a2@,%d0
4a244: 5380 subql #1,%d0
4a246: 588f addql #4,%sp
4a248: 2480 movel %d0,%a2@
}
4a24a: 242e fff8 movel %fp@(-8),%d2
4a24e: 246e fffc moveal %fp@(-4),%a2
4a252: 4e5e unlk %fp <== NOT EXECUTED
0004a186 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
4a186: 4e56 fffc linkw %fp,#-4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
4a18a: 204e moveal %fp,%a0
4a18c: 42a0 clrl %a0@-
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4a18e: 2f08 movel %a0,%sp@-
4a190: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
4a194: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
4a198: 4eb9 0004 dfd4 jsr 4dfd4 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
4a19e: 4fef 000c lea %sp@(12),%sp
4a1a2: 4a80 tstl %d0
4a1a4: 670c beqs 4a1b2 <rtems_bdbuf_disable_preemption+0x2c><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
4a1a6: 2f3c 4200 000f movel #1107296271,%sp@- <== NOT EXECUTED
4a1ac: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
return prev_mode;
}
4a1b2: 202e fffc movel %fp@(-4),%d0
4a1b6: 4e5e unlk %fp <== NOT EXECUTED
0004a9ec <rtems_bdbuf_execute_transfer_request>:
static rtems_status_code
rtems_bdbuf_execute_transfer_request (const rtems_disk_device *dd,
rtems_blkdev_request *req,
bool cache_locked)
{
4a9ec: 4e56 ffd8 linkw %fp,#-40
4a9f0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4a9f4: 142e 0013 moveb %fp@(19),%d2
4a9f8: 266e 0008 moveal %fp@(8),%a3
4a9fc: 246e 000c moveal %fp@(12),%a2
int result = 0;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
4aa00: 6704 beqs 4aa06 <rtems_bdbuf_execute_transfer_request+0x1a>
rtems_bdbuf_unlock_cache ();
4aa02: 4eba f688 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
result = dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
4aa06: 2f0a movel %a2,%sp@-
4aa08: 2f3c c018 4201 movel #-1072152063,%sp@-
4aa0e: 2f2b 0008 movel %a3@(8),%sp@-
4aa12: 206b 0028 moveal %a3@(40),%a0
4aa16: 4e90 jsr %a0@
if (result == 0)
4aa18: 4fef 000c lea %sp@(12),%sp
4aa1c: 4a80 tstl %d0
4aa1e: 6610 bnes 4aa30 <rtems_bdbuf_execute_transfer_request+0x44>
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
4aa20: 4878 0002 pea 2 <DOUBLE_FLOAT>
4aa24: 4eba f722 jsr %pc@(4a148 <rtems_bdbuf_wait_for_event>)
sc = req->status;
4aa28: 262a 000c movel %a2@(12),%d3
4aa2c: 588f addql #4,%sp
4aa2e: 6002 bras 4aa32 <rtems_bdbuf_execute_transfer_request+0x46>
}
else
sc = RTEMS_IO_ERROR;
4aa30: 761b moveq #27,%d3
rtems_bdbuf_lock_cache ();
4aa32: 4eba f4a4 jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
4aa36: 284a moveal %a2,%a4
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4aa38: 4284 clrl %d4
4aa3a: 2e3c 0004 e3cc movel #320460,%d7
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4aa40: 4bf9 0004 71e4 lea 471e4 <_Chain_Append>,%a5
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int result = 0;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
4aa46: 4205 clrb %d5
bool cache_locked)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int result = 0;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
4aa48: 4206 clrb %d6
else
sc = RTEMS_IO_ERROR;
rtems_bdbuf_lock_cache ();
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4aa4a: 6066 bras 4aab2 <rtems_bdbuf_execute_transfer_request+0xc6>
{
rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;
4aa4c: 266c 0024 moveal %a4@(36),%a3
bool waiters = bd->waiters;
4aa50: 202b 0026 movel %a3@(38),%d0
if (waiters)
4aa54: 6704 beqs 4aa5a <rtems_bdbuf_execute_transfer_request+0x6e>
wake_transfer_waiters = true;
4aa56: 7c01 moveq #1,%d6
4aa58: 6002 bras 4aa5c <rtems_bdbuf_execute_transfer_request+0x70>
else
wake_buffer_waiters = true;
4aa5a: 7a01 moveq #1,%d5
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4aa5c: 206b 002a moveal %a3@(42),%a0
4aa60: 53a8 000c subql #1,%a0@(12)
else
wake_buffer_waiters = true;
rtems_bdbuf_group_release (bd);
if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
4aa64: 4a83 tstl %d3
4aa66: 661e bnes 4aa86 <rtems_bdbuf_execute_transfer_request+0x9a>
4aa68: 202b 0022 movel %a3@(34),%d0
4aa6c: 7209 moveq #9,%d1
4aa6e: b280 cmpl %d0,%d1
4aa70: 6614 bnes 4aa86 <rtems_bdbuf_execute_transfer_request+0x9a><== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4aa72: 7002 moveq #2,%d0
4aa74: 2740 0022 movel %d0,%a3@(34)
4aa78: 2f0b movel %a3,%sp@-
4aa7a: 4879 0006 1724 pea 61724 <bdbuf_cache+0x40>
4aa80: 4e95 jsr %a5@
4aa82: 508f addql #8,%sp
4aa84: 6026 bras 4aaac <rtems_bdbuf_execute_transfer_request+0xc0>
4aa86: 7201 moveq #1,%d1
4aa88: 2741 0022 movel %d1,%a3@(34)
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4aa8c: 202b 0026 movel %a3@(38),%d0
4aa90: 661a bnes 4aaac <rtems_bdbuf_execute_transfer_request+0xc0>
{
rtems_bdbuf_remove_from_tree (bd);
4aa92: 2f0b movel %a3,%sp@-
4aa94: 4eba fa52 jsr %pc@(4a4e8 <rtems_bdbuf_remove_from_tree>)
4aa98: 2047 moveal %d7,%a0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4aa9a: 42ab 0022 clrl %a3@(34)
4aa9e: 2f0b movel %a3,%sp@-
4aaa0: 4879 0006 1724 pea 61724 <bdbuf_cache+0x40>
4aaa6: 4e90 jsr %a0@
4aaa8: 4fef 000c lea %sp@(12),%sp
else
sc = RTEMS_IO_ERROR;
rtems_bdbuf_lock_cache ();
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4aaac: 5284 addql #1,%d4
4aaae: 49ec 0010 lea %a4@(16),%a4
4aab2: b8aa 0010 cmpl %a2@(16),%d4
4aab6: 6594 bcss 4aa4c <rtems_bdbuf_execute_transfer_request+0x60>
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
4aab8: 4a06 tstb %d6
4aaba: 670c beqs 4aac8 <rtems_bdbuf_execute_transfer_request+0xdc>
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
4aabc: 4879 0006 1750 pea 61750 <bdbuf_cache+0x6c>
4aac2: 4eba f882 jsr %pc@(4a346 <rtems_bdbuf_wake>)
4aac6: 588f addql #4,%sp
if (wake_buffer_waiters)
4aac8: 4a05 tstb %d5
4aaca: 670c beqs 4aad8 <rtems_bdbuf_execute_transfer_request+0xec>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4aacc: 4879 0006 1758 pea 61758 <bdbuf_cache+0x74>
4aad2: 4eba f872 jsr %pc@(4a346 <rtems_bdbuf_wake>)
4aad6: 588f addql #4,%sp
if (!cache_locked)
4aad8: 4a02 tstb %d2
4aada: 6604 bnes 4aae0 <rtems_bdbuf_execute_transfer_request+0xf4>
rtems_bdbuf_unlock_cache ();
4aadc: 4eba f5ae jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
4aae0: 4a83 tstl %d3
4aae2: 6708 beqs 4aaec <rtems_bdbuf_execute_transfer_request+0x100>
4aae4: 700d moveq #13,%d0
4aae6: b083 cmpl %d3,%d0
4aae8: 6702 beqs 4aaec <rtems_bdbuf_execute_transfer_request+0x100>
return sc;
else
return RTEMS_IO_ERROR;
4aaea: 761b moveq #27,%d3
}
4aaec: 2003 movel %d3,%d0
4aaee: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5
4aaf4: 4e5e unlk %fp <== NOT EXECUTED
00049f30 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
49f30: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
49f34: 202e 0008 movel %fp@(8),%d0 <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
49f38: 4840 swap %d0 <== NOT EXECUTED
49f3a: 4240 clrw %d0 <== NOT EXECUTED
49f3c: 80ae 000c orl %fp@(12),%d0 <== NOT EXECUTED
49f40: 2f00 movel %d0,%sp@- <== NOT EXECUTED
49f42: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
0004b884 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4b884: 4e56 ffe4 linkw %fp,#-28
4b888: 48d7 041c moveml %d2-%d4/%a2,%sp@
4b88c: 242e 0008 movel %fp@(8),%d2
4b890: 262e 000c movel %fp@(12),%d3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
4b894: 42ae fff4 clrl %fp@(-12)
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
4b898: 42ae fff8 clrl %fp@(-8)
size_t bds_per_group = 0;
4b89c: 42ae fffc clrl %fp@(-4)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4b8a0: 4a39 0006 1768 tstb 61768 <bdbuf_cache+0x84>
4b8a6: 6700 0092 beqw 4b93a <rtems_bdbuf_get+0xb6>
4b8aa: 486e fffc pea %fp@(-4)
4b8ae: 486e fff8 pea %fp@(-8)
4b8b2: 486e fff4 pea %fp@(-12)
4b8b6: 2f2e 0010 movel %fp@(16),%sp@-
4b8ba: 2f03 movel %d3,%sp@-
4b8bc: 2f02 movel %d2,%sp@-
4b8be: 4eba eb60 jsr %pc@(4a420 <rtems_bdbuf_obtain_disk.part.7>)
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
4b8c2: 4fef 0018 lea %sp@(24),%sp
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4b8c6: 2800 movel %d0,%d4
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
4b8c8: 6672 bnes 4b93c <rtems_bdbuf_get+0xb8> <== NEVER TAKEN
return sc;
rtems_bdbuf_lock_cache ();
4b8ca: 4eba e60c jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dev);
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
4b8ce: 2f2e fffc movel %fp@(-4),%sp@-
4b8d2: 2f2e fff8 movel %fp@(-8),%sp@-
4b8d6: 2f03 movel %d3,%sp@-
4b8d8: 2f02 movel %d2,%sp@-
4b8da: 4eba fa38 jsr %pc@(4b314 <rtems_bdbuf_get_buffer_for_access>)
switch (bd->state)
4b8de: 4fef 0010 lea %sp@(16),%sp
4b8e2: 7202 moveq #2,%d1
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dev);
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
4b8e4: 2440 moveal %d0,%a2
switch (bd->state)
4b8e6: 202a 0022 movel %a2@(34),%d0
4b8ea: b280 cmpl %d0,%d1
4b8ec: 6712 beqs 4b900 <rtems_bdbuf_get+0x7c>
4b8ee: 123c 0007 moveb #7,%d1
4b8f2: b280 cmpl %d0,%d1
4b8f4: 6716 beqs 4b90c <rtems_bdbuf_get+0x88>
4b8f6: 123c 0001 moveb #1,%d1
4b8fa: b280 cmpl %d0,%d1
4b8fc: 6616 bnes 4b914 <rtems_bdbuf_get+0x90> <== NEVER TAKEN
4b8fe: 6004 bras 4b904 <rtems_bdbuf_get+0x80>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b900: 7003 moveq #3,%d0
4b902: 600a bras 4b90e <rtems_bdbuf_get+0x8a>
4b904: 7205 moveq #5,%d1
4b906: 2541 0022 movel %d1,%a2@(34)
4b90a: 6018 bras 4b924 <rtems_bdbuf_get+0xa0>
4b90c: 7004 moveq #4,%d0
4b90e: 2540 0022 movel %d0,%a2@(34)
4b912: 6010 bras 4b924 <rtems_bdbuf_get+0xa0>
* so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_2);
4b914: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4b918: 2f3c 4200 001e movel #1107296286,%sp@- <== NOT EXECUTED
4b91e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b920: 4eba e60e jsr %pc@(49f30 <rtems_bdbuf_fatal>) <== NOT EXECUTED
{
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
rtems_bdbuf_unlock_cache ();
4b924: 4eba e766 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
rtems_bdbuf_release_disk (dd);
4b928: 2f2e fff4 movel %fp@(-12),%sp@-
4b92c: 4eba e7aa jsr %pc@(4a0d8 <rtems_bdbuf_release_disk>)
*bd_ptr = bd;
4b930: 206e 0014 moveal %fp@(20),%a0
return RTEMS_SUCCESSFUL;
4b934: 588f addql #4,%sp
rtems_bdbuf_unlock_cache ();
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
4b936: 208a movel %a2,%a0@
return RTEMS_SUCCESSFUL;
4b938: 6002 bras 4b93c <rtems_bdbuf_get+0xb8>
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4b93a: 7816 moveq #22,%d4 <== NOT EXECUTED
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
return RTEMS_SUCCESSFUL;
}
4b93c: 2004 movel %d4,%d0
4b93e: 4cee 041c ffe4 moveml %fp@(-28),%d2-%d4/%a2
4b944: 4e5e unlk %fp <== NOT EXECUTED
0004b314 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
4b314: 4e56 ffd4 linkw %fp,#-44
4b318: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4b31c: 242e 0008 movel %fp@(8),%d2
4b320: 262e 000c movel %fp@(12),%d3
4b324: 2a2e 0010 movel %fp@(16),%d5
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
4b328: 2e3c 0004 a2ea movel #303850,%d7
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4b32e: 47fa ef26 lea %pc@(4a256 <rtems_bdbuf_wait>),%a3
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4b332: 2c3c 0004 721c movel #291356,%d6
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4b338: 4bf9 0004 71e4 lea 471e4 <_Chain_Append>,%a5
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract (&bd->link);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
4b33e: 45fa edbc lea %pc@(4a0fc <rtems_bdbuf_wake_swapper>),%a2
{
if (bd->group->bds_per_group != bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4b342: 49fa f490 lea %pc@(4a7d4 <rtems_bdbuf_remove_from_tree_and_lru_list>),%a4
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
4b346: 282e 0014 movel %fp@(20),%d4
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
4b34a: 2f05 movel %d5,%sp@-
4b34c: 2047 moveal %d7,%a0
4b34e: 2f03 movel %d3,%sp@-
4b350: 2f02 movel %d2,%sp@-
4b352: 2f39 0006 1720 movel 61720 <bdbuf_cache+0x3c>,%sp@-
4b358: 4e90 jsr %a0@
4b35a: 4fef 0010 lea %sp@(16),%sp
4b35e: 2040 moveal %d0,%a0
if (bd != NULL)
4b360: 4a80 tstl %d0
4b362: 6700 00c4 beqw 4b428 <rtems_bdbuf_get_buffer_for_access+0x114>
{
if (bd->group->bds_per_group != bds_per_group)
4b366: 2268 002a moveal %a0@(42),%a1
4b36a: b8a9 0008 cmpl %a1@(8),%d4
4b36e: 6700 00ee beqw 4b45e <rtems_bdbuf_get_buffer_for_access+0x14a>
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4b372: 2028 0022 movel %a0@(34),%d0
4b376: 720a moveq #10,%d1
4b378: b280 cmpl %d0,%d1
4b37a: 656e bcss 4b3ea <rtems_bdbuf_get_buffer_for_access+0xd6><== NEVER TAKEN
4b37c: 303b 0a08 movew %pc@(4b386 <rtems_bdbuf_get_buffer_for_access+0x72>,%d0:l:2),%d0
4b380: 48c0 extl %d0
4b382: 4efb 0802 jmp %pc@(4b386 <rtems_bdbuf_get_buffer_for_access+0x72>,%d0:l)
4b386: 0072 .short 0x0072 <== NOT EXECUTED
4b388: 003c .short 0x003c <== NOT EXECUTED
4b38a: 003c .short 0x003c <== NOT EXECUTED
4b38c: 0046 .short 0x0046 <== NOT EXECUTED
4b38e: 0046 .short 0x0046 <== NOT EXECUTED
4b390: 0046 .short 0x0046 <== NOT EXECUTED
4b392: 0046 .short 0x0046 <== NOT EXECUTED
4b394: 0016 .short 0x0016 <== NOT EXECUTED
4b396: 004e .short 0x004e <== NOT EXECUTED
4b398: 004e .short 0x004e <== NOT EXECUTED
4b39a: 004e .short 0x004e <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b39c: 7008 moveq #8,%d0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4b39e: 2246 moveal %d6,%a1 <== NOT EXECUTED
4b3a0: 2140 0022 movel %d0,%a0@(34) <== NOT EXECUTED
4b3a4: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4b3a6: 2d48 fffc movel %a0,%fp@(-4) <== NOT EXECUTED
4b3aa: 4e91 jsr %a1@ <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4b3ac: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
4b3b0: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4b3b2: 4879 0006 173c pea 6173c <bdbuf_cache+0x58> <== NOT EXECUTED
4b3b8: 4e95 jsr %a5@ <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract (&bd->link);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
4b3ba: 4e92 jsr %a2@ <== NOT EXECUTED
4b3bc: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4b3c0: 6022 bras 4b3e4 <rtems_bdbuf_get_buffer_for_access+0xd0><== NOT EXECUTED
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_request_sync_for_modified_buffer (bd);
break;
case RTEMS_BDBUF_STATE_CACHED:
case RTEMS_BDBUF_STATE_EMPTY:
if (bd->waiters == 0)
4b3c2: 2028 0026 movel %a0@(38),%d0
4b3c6: 6730 beqs 4b3f8 <rtems_bdbuf_get_buffer_for_access+0xe4><== NEVER TAKEN
4b3c8: 6000 0084 braw 4b44e <rtems_bdbuf_get_buffer_for_access+0x13a>
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4b3cc: 4879 0006 1748 pea 61748 <bdbuf_cache+0x64>
4b3d2: 6006 bras 4b3da <rtems_bdbuf_get_buffer_for_access+0xc6>
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4b3d4: 4879 0006 1750 pea 61750 <bdbuf_cache+0x6c> <== NOT EXECUTED
4b3da: 2f08 movel %a0,%sp@-
4b3dc: 2d48 fffc movel %a0,%fp@(-4)
4b3e0: 4e93 jsr %a3@
4b3e2: 508f addql #8,%sp
4b3e4: 206e fffc moveal %fp@(-4),%a0
4b3e8: 6088 bras 4b372 <rtems_bdbuf_get_buffer_for_access+0x5e>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_8);
4b3ea: 2028 0022 movel %a0@(34),%d0 <== NOT EXECUTED
4b3ee: 2f3c 4200 0006 movel #1107296262,%sp@- <== NOT EXECUTED
4b3f4: 6000 00da braw 4b4d0 <rtems_bdbuf_get_buffer_for_access+0x1bc><== NOT EXECUTED
{
if (bd->group->bds_per_group != bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4b3f8: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4b3fa: 2d48 fffc movel %a0,%fp@(-4) <== NOT EXECUTED
4b3fe: 4e94 jsr %a4@ <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b400: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
4b404: 42a8 0022 clrl %a0@(34) <== NOT EXECUTED
4b408: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4b40a: 4879 0006 1724 pea 61724 <bdbuf_cache+0x40> <== NOT EXECUTED
4b410: 4eb9 0004 e3cc jsr 4e3cc <_Chain_Insert> <== NOT EXECUTED
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4b416: 4879 0006 1758 pea 61758 <bdbuf_cache+0x74> <== NOT EXECUTED
4b41c: 4eba ef28 jsr %pc@(4a346 <rtems_bdbuf_wake>) <== NOT EXECUTED
4b420: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4b424: 6000 ff24 braw 4b34a <rtems_bdbuf_get_buffer_for_access+0x36><== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
4b428: 2f04 movel %d4,%sp@-
4b42a: 2f05 movel %d5,%sp@-
4b42c: 2f03 movel %d3,%sp@-
4b42e: 2f02 movel %d2,%sp@-
4b430: 4eba fbc6 jsr %pc@(4aff8 <rtems_bdbuf_get_buffer_from_lru_list>)
if (bd == NULL)
4b434: 4fef 0010 lea %sp@(16),%sp
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
4b438: 2040 moveal %d0,%a0
if (bd == NULL)
4b43a: 4a80 tstl %d0
4b43c: 6620 bnes 4b45e <rtems_bdbuf_get_buffer_for_access+0x14a>
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4b43e: 203c 0006 1734 movel #399156,%d0
4b444: b0b9 0006 1730 cmpl 61730 <bdbuf_cache+0x4c>,%d0
4b44a: 6702 beqs 4b44e <rtems_bdbuf_get_buffer_for_access+0x13a>
rtems_bdbuf_wake_swapper ();
4b44c: 4e92 jsr %a2@
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
4b44e: 4879 0006 1758 pea 61758 <bdbuf_cache+0x74>
4b454: 4eba ed94 jsr %pc@(4a1ea <rtems_bdbuf_anonymous_wait>)
4b458: 588f addql #4,%sp
4b45a: 6000 feee braw 4b34a <rtems_bdbuf_get_buffer_for_access+0x36>
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4b45e: 45fa edf6 lea %pc@(4a256 <rtems_bdbuf_wait>),%a2
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4b462: 2028 0022 movel %a0@(34),%d0
4b466: 7209 moveq #9,%d1
4b468: 5380 subql #1,%d0
4b46a: b280 cmpl %d0,%d1
4b46c: 6558 bcss 4b4c6 <rtems_bdbuf_get_buffer_for_access+0x1b2><== NEVER TAKEN
4b46e: 303b 0a08 movew %pc@(4b478 <rtems_bdbuf_get_buffer_for_access+0x164>,%d0:l:2),%d0
4b472: 48c0 extl %d0
4b474: 4efb 0802 jmp %pc@(4b478 <rtems_bdbuf_get_buffer_for_access+0x164>,%d0:l)
4b478: 005e .short 0x005e <== NOT EXECUTED
4b47a: 001c .short 0x001c <== NOT EXECUTED
4b47c: 0030 .short 0x0030 <== NOT EXECUTED
4b47e: 0030 .short 0x0030 <== NOT EXECUTED
4b480: 0030 .short 0x0030 <== NOT EXECUTED
4b482: 0030 .short 0x0030 <== NOT EXECUTED
4b484: 0014 .short 0x0014 <== NOT EXECUTED
4b486: 0038 .short 0x0038 <== NOT EXECUTED
4b488: 0038 .short 0x0038 <== NOT EXECUTED
4b48a: 0038 .short 0x0038 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4b48c: 2268 002a moveal %a0@(42),%a1
4b490: 53a9 000c subql #1,%a1@(12)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4b494: 2f08 movel %a0,%sp@-
4b496: 2d48 fffc movel %a0,%fp@(-4)
4b49a: 4eb9 0004 721c jsr 4721c <_Chain_Extract>
4b4a0: 206e fffc moveal %fp@(-4),%a0
4b4a4: 588f addql #4,%sp
4b4a6: 602e bras 4b4d6 <rtems_bdbuf_get_buffer_for_access+0x1c2>
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4b4a8: 4879 0006 1748 pea 61748 <bdbuf_cache+0x64>
4b4ae: 6006 bras 4b4b6 <rtems_bdbuf_get_buffer_for_access+0x1a2>
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4b4b0: 4879 0006 1750 pea 61750 <bdbuf_cache+0x6c>
4b4b6: 2f08 movel %a0,%sp@-
4b4b8: 2d48 fffc movel %a0,%fp@(-4)
4b4bc: 4e92 jsr %a2@
4b4be: 206e fffc moveal %fp@(-4),%a0
4b4c2: 508f addql #8,%sp
4b4c4: 609c bras 4b462 <rtems_bdbuf_get_buffer_for_access+0x14e>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_7);
4b4c6: 2028 0022 movel %a0@(34),%d0 <== NOT EXECUTED
4b4ca: 2f3c 4200 0005 movel #1107296261,%sp@- <== NOT EXECUTED
4b4d0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b4d2: 4eba ea5c jsr %pc@(49f30 <rtems_bdbuf_fatal>) <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4b4d6: 2268 002a moveal %a0@(42),%a1
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
4b4da: 2008 movel %a0,%d0
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4b4dc: 52a9 000c addql #1,%a1@(12)
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
4b4e0: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4b4e6: 4e5e unlk %fp <== NOT EXECUTED
0004aff8 <rtems_bdbuf_get_buffer_from_lru_list>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
4aff8: 4e56 ff54 linkw %fp,#-172
4affc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4b000: 2c2e 0010 movel %fp@(16),%d6
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4b004: 2a3c 0004 a7d4 movel #305108,%d5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4b00a: 2679 0006 1724 moveal 61724 <bdbuf_cache+0x40>,%a3
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
4b010: 242e 0008 movel %fp@(8),%d2
4b014: 262e 000c movel %fp@(12),%d3
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
4b018: 6000 02d6 braw 4b2f0 <rtems_bdbuf_get_buffer_from_lru_list+0x2f8>
bd->group->bds_per_group, bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
4b01c: 202b 0026 movel %a3@(38),%d0
4b020: 6600 02cc bnew 4b2ee <rtems_bdbuf_get_buffer_from_lru_list+0x2f6>
{
if (bd->group->bds_per_group == bds_per_group)
4b024: 246b 002a moveal %a3@(42),%a2
4b028: 2a6a 0008 moveal %a2@(8),%a5
4b02c: bbee 0014 cmpal %fp@(20),%a5
4b030: 660e bnes 4b040 <rtems_bdbuf_get_buffer_from_lru_list+0x48>
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4b032: 2f0b movel %a3,%sp@-
4b034: 2045 moveal %d5,%a0
4b036: 4e90 jsr %a0@
4b038: 588f addql #4,%sp
4b03a: 224b moveal %a3,%a1
4b03c: 6000 00a4 braw 4b0e2 <rtems_bdbuf_get_buffer_from_lru_list+0xea>
empty_bd = bd;
}
else if (bd->group->users == 0)
4b040: 4aaa 000c tstl %a2@(12)
4b044: 6600 02a8 bnew 4b2ee <rtems_bdbuf_get_buffer_from_lru_list+0x2f6>
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
4b048: 2239 0006 1702 movel 61702 <bdbuf_cache+0x1e>,%d1
4b04e: 280d movel %a5,%d4
for (b = 0, bd = group->bdbuf;
4b050: 99cc subal %a4,%a4
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
4b052: 4c44 1001 remul %d4,%d1,%d1
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4b056: 783a moveq #58,%d4
4b058: 4c04 1800 mulsl %d4,%d1
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
4b05c: 202a 0010 movel %a2@(16),%d0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4b060: 2a41 moveal %d1,%a5
4b062: 6014 bras 4b078 <rtems_bdbuf_get_buffer_from_lru_list+0x80>
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4b064: 2f00 movel %d0,%sp@-
4b066: 2045 moveal %d5,%a0
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4b068: 528c addql #1,%a4
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4b06a: 2d40 ff7c movel %d0,%fp@(-132)
4b06e: 4e90 jsr %a0@
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4b070: 202e ff7c movel %fp@(-132),%d0
4b074: 588f addql #4,%sp
4b076: d08d addl %a5,%d0
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
4b078: b9ea 0008 cmpal %a2@(8),%a4
4b07c: 65e6 bcss 4b064 <rtems_bdbuf_get_buffer_from_lru_list+0x6c>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
4b07e: 202e 0014 movel %fp@(20),%d0
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4b082: 7e3a moveq #58,%d7
4b084: 387c 0001 moveaw #1,%a4
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
4b088: 2540 0008 movel %d0,%a2@(8)
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
4b08c: 2039 0006 1702 movel 61702 <bdbuf_cache+0x1e>,%d0
4b092: 282e 0014 movel %fp@(20),%d4
4b096: 4c44 0000 remul %d4,%d0,%d0
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4b09a: 2a6a 0010 moveal %a2@(16),%a5
4b09e: 4c07 0800 mulsl %d7,%d0
4b0a2: dbc0 addal %d0,%a5
4b0a4: 6020 bras 4b0c6 <rtems_bdbuf_get_buffer_from_lru_list+0xce>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b0a6: 42ad 0022 clrl %a5@(34)
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4b0aa: 528c addql #1,%a4
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4b0ac: 2f0d movel %a5,%sp@-
4b0ae: 4879 0006 1724 pea 61724 <bdbuf_cache+0x40>
4b0b4: 2d40 ff7c movel %d0,%fp@(-132)
4b0b8: 4eb9 0004 e3cc jsr 4e3cc <_Chain_Insert>
4b0be: 202e ff7c movel %fp@(-132),%d0
4b0c2: 508f addql #8,%sp
4b0c4: dbc0 addal %d0,%a5
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4b0c6: b9ea 0008 cmpal %a2@(8),%a4
4b0ca: 65da bcss 4b0a6 <rtems_bdbuf_get_buffer_from_lru_list+0xae>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
4b0cc: 7001 moveq #1,%d0
4b0ce: b08c cmpl %a4,%d0
4b0d0: 640c bccs 4b0de <rtems_bdbuf_get_buffer_from_lru_list+0xe6>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4b0d2: 4879 0006 1758 pea 61758 <bdbuf_cache+0x74>
4b0d8: 4eba f26c jsr %pc@(4a346 <rtems_bdbuf_wake>)
4b0dc: 588f addql #4,%sp
return group->bdbuf;
4b0de: 226a 0010 moveal %a2@(16),%a1
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
4b0e2: 4a89 tstl %a1
4b0e4: 6700 0208 beqw 4b2ee <rtems_bdbuf_get_buffer_from_lru_list+0x2f6>
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
4b0e8: 42a9 0008 clrl %a1@(8)
bd->avl.right = NULL;
4b0ec: 42a9 000c clrl %a1@(12)
rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
4b0f0: 2079 0006 1720 moveal 61720 <bdbuf_cache+0x3c>,%a0
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
4b0f6: 2342 0012 movel %d2,%a1@(18)
4b0fa: 2343 0016 movel %d3,%a1@(22)
bd->block = block;
4b0fe: 2346 001a movel %d6,%a1@(26)
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
4b102: 42a9 0026 clrl %a1@(38)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
4b106: 4a88 tstl %a0
4b108: 665e bnes 4b168 <rtems_bdbuf_get_buffer_from_lru_list+0x170>
{
*root = node;
4b10a: 23c9 0006 1720 movel %a1,61720 <bdbuf_cache+0x3c>
node->avl.left = NULL;
node->avl.right = NULL;
node->avl.bal = 0;
4b110: 4201 clrb %d1
bool modified = false;
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
4b112: 42a9 0008 clrl %a1@(8)
node->avl.right = NULL;
node->avl.bal = 0;
4b116: 1341 0011 moveb %d1,%a1@(17)
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
node->avl.right = NULL;
4b11a: 42a9 000c clrl %a1@(12)
4b11e: 6000 01c6 braw 4b2e6 <rtems_bdbuf_get_buffer_from_lru_list+0x2ee>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
4b122: 2004 movel %d4,%d0
4b124: 2205 movel %d5,%d1
4b126: 9283 subl %d3,%d1
4b128: 9182 subxl %d2,%d0
4b12a: 6622 bnes 4b14e <rtems_bdbuf_get_buffer_from_lru_list+0x156><== NEVER TAKEN
4b12c: 2028 001a movel %a0@(26),%d0
4b130: bc80 cmpl %d0,%d6
4b132: 6314 blss 4b148 <rtems_bdbuf_get_buffer_from_lru_list+0x150>
{
p->avl.cache = 1;
q = p->avl.right;
4b134: 2028 000c movel %a0@(12),%d0
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
4b138: 7201 moveq #1,%d1
4b13a: 1141 0010 moveb %d1,%a0@(16)
q = p->avl.right;
if (q == NULL)
4b13e: 4a80 tstl %d0
4b140: 6620 bnes 4b162 <rtems_bdbuf_get_buffer_from_lru_list+0x16a>
{
q = node;
p->avl.right = q = node;
4b142: 2149 000c movel %a1,%a0@(12)
4b146: 603c bras 4b184 <rtems_bdbuf_get_buffer_from_lru_list+0x18c>
break;
}
}
else if ((p->dev != dev) || (p->block != block))
4b148: bc80 cmpl %d0,%d6
4b14a: 6700 01bc beqw 4b308 <rtems_bdbuf_get_buffer_from_lru_list+0x310>
{
p->avl.cache = -1;
q = p->avl.left;
4b14e: 2028 0008 movel %a0@(8),%d0
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
4b152: 50c4 st %d4
4b154: 1144 0010 moveb %d4,%a0@(16)
q = p->avl.left;
if (q == NULL)
4b158: 4a80 tstl %d0
4b15a: 6606 bnes 4b162 <rtems_bdbuf_get_buffer_from_lru_list+0x16a>
{
q = node;
p->avl.left = q;
4b15c: 2149 0008 movel %a1,%a0@(8)
4b160: 6022 bras 4b184 <rtems_bdbuf_get_buffer_from_lru_list+0x18c>
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
4b162: 284a moveal %a2,%a4
4b164: 2040 moveal %d0,%a0
4b166: 6004 bras 4b16c <rtems_bdbuf_get_buffer_from_lru_list+0x174>
rtems_bdbuf_buffer* p = *root;
rtems_bdbuf_buffer* q;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
4b168: 49ee ff80 lea %fp@(-128),%a4
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4b16c: 244c moveal %a4,%a2
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
4b16e: 2828 0012 movel %a0@(18),%d4
4b172: 2a28 0016 movel %a0@(22),%d5
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4b176: 24c8 movel %a0,%a2@+
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
4b178: 2004 movel %d4,%d0
4b17a: 2205 movel %d5,%d1
4b17c: 9283 subl %d3,%d1
4b17e: 9182 subxl %d2,%d0
4b180: 65b2 bcss 4b134 <rtems_bdbuf_get_buffer_from_lru_list+0x13c><== NEVER TAKEN
4b182: 609e bras 4b122 <rtems_bdbuf_get_buffer_from_lru_list+0x12a>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
4b184: 42a9 000c clrl %a1@(12)
q->avl.bal = 0;
4b188: 4201 clrb %d1
}
p = q;
}
q->avl.left = q->avl.right = NULL;
4b18a: 42a9 0008 clrl %a1@(8)
q->avl.bal = 0;
4b18e: 1341 0011 moveb %d1,%a1@(17)
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4b192: 220e movel %fp,%d1
4b194: 0681 ffff ff80 addil #-128,%d1
4b19a: 6002 bras 4b19e <rtems_bdbuf_get_buffer_from_lru_list+0x1a6>
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
4b19c: 204a moveal %a2,%a0
{
if (p->avl.cache == -1)
4b19e: 76ff moveq #-1,%d3
4b1a0: 1428 0010 moveb %a0@(16),%d2
4b1a4: 1028 0011 moveb %a0@(17),%d0
4b1a8: 49c2 extbl %d2
4b1aa: b682 cmpl %d2,%d3
4b1ac: 667a bnes 4b228 <rtems_bdbuf_get_buffer_from_lru_list+0x230>
{
switch (p->avl.bal)
4b1ae: 4a00 tstb %d0
4b1b0: 6718 beqs 4b1ca <rtems_bdbuf_get_buffer_from_lru_list+0x1d2>
4b1b2: 49c0 extbl %d0
4b1b4: 7801 moveq #1,%d4
4b1b6: b880 cmpl %d0,%d4
4b1b8: 6708 beqs 4b1c2 <rtems_bdbuf_get_buffer_from_lru_list+0x1ca>
4b1ba: b680 cmpl %d0,%d3
4b1bc: 6600 00f6 bnew 4b2b4 <rtems_bdbuf_get_buffer_from_lru_list+0x2bc>
4b1c0: 6012 bras 4b1d4 <rtems_bdbuf_get_buffer_from_lru_list+0x1dc>
{
case 1:
p->avl.bal = 0;
4b1c2: 4207 clrb %d7
4b1c4: 1147 0011 moveb %d7,%a0@(17)
4b1c8: 6076 bras 4b240 <rtems_bdbuf_get_buffer_from_lru_list+0x248>
modified = false;
break;
case 0:
p->avl.bal = -1;
4b1ca: 50c0 st %d0
4b1cc: 1140 0011 moveb %d0,%a0@(17)
4b1d0: 6000 00e2 braw 4b2b4 <rtems_bdbuf_get_buffer_from_lru_list+0x2bc>
break;
case -1:
p1 = p->avl.left;
4b1d4: 2668 0008 moveal %a0@(8),%a3
if (p1->avl.bal == -1) /* simple LL-turn */
4b1d8: 74ff moveq #-1,%d2
4b1da: 102b 0011 moveb %a3@(17),%d0
4b1de: 49c0 extbl %d0
4b1e0: b480 cmpl %d0,%d2
4b1e2: 660c bnes 4b1f0 <rtems_bdbuf_get_buffer_from_lru_list+0x1f8><== ALWAYS TAKEN
{
p->avl.left = p1->avl.right;
4b1e4: 216b 000c 0008 movel %a3@(12),%a0@(8) <== NOT EXECUTED
p1->avl.right = p;
4b1ea: 2748 000c movel %a0,%a3@(12) <== NOT EXECUTED
4b1ee: 6076 bras 4b266 <rtems_bdbuf_get_buffer_from_lru_list+0x26e><== NOT EXECUTED
p->avl.bal = 0;
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
4b1f0: 246b 000c moveal %a3@(12),%a2
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4b1f4: 78ff moveq #-1,%d4
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4b1f6: 7e01 moveq #1,%d7
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4b1f8: 102a 0011 moveb %a2@(17),%d0
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4b1fc: 276a 0008 000c movel %a2@(8),%a3@(12)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4b202: 49c0 extbl %d0
4b204: b880 cmpl %d0,%d4
4b206: 56c0 sne %d0
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
4b208: 254b 0008 movel %a3,%a2@(8)
p->avl.left = p2->avl.right;
4b20c: 216a 000c 0008 movel %a2@(12),%a0@(8)
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4b212: 5280 addql #1,%d0
4b214: 1140 0011 moveb %d0,%a0@(17)
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
4b218: 2548 000c movel %a0,%a2@(12)
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4b21c: 102a 0011 moveb %a2@(17),%d0
4b220: 49c0 extbl %d0
4b222: be80 cmpl %d0,%d7
4b224: 57c0 seq %d0
4b226: 607e bras 4b2a6 <rtems_bdbuf_get_buffer_from_lru_list+0x2ae>
break;
}
}
else
{
switch (p->avl.bal)
4b228: 4a00 tstb %d0
4b22a: 6718 beqs 4b244 <rtems_bdbuf_get_buffer_from_lru_list+0x24c>
4b22c: 49c0 extbl %d0
4b22e: 7401 moveq #1,%d2
4b230: b480 cmpl %d0,%d2
4b232: 6718 beqs 4b24c <rtems_bdbuf_get_buffer_from_lru_list+0x254>
4b234: 76ff moveq #-1,%d3
4b236: b680 cmpl %d0,%d3
4b238: 667a bnes 4b2b4 <rtems_bdbuf_get_buffer_from_lru_list+0x2bc><== NEVER TAKEN
{
case -1:
p->avl.bal = 0;
4b23a: 4204 clrb %d4
4b23c: 1144 0011 moveb %d4,%a0@(17)
modified = false;
4b240: 4200 clrb %d0
4b242: 6072 bras 4b2b6 <rtems_bdbuf_get_buffer_from_lru_list+0x2be>
break;
case 0:
p->avl.bal = 1;
4b244: 7e01 moveq #1,%d7
4b246: 1147 0011 moveb %d7,%a0@(17)
4b24a: 6068 bras 4b2b4 <rtems_bdbuf_get_buffer_from_lru_list+0x2bc>
break;
case 1:
p1 = p->avl.right;
4b24c: 2668 000c moveal %a0@(12),%a3
if (p1->avl.bal == 1) /* simple RR-turn */
4b250: 7401 moveq #1,%d2
4b252: 102b 0011 moveb %a3@(17),%d0
4b256: 49c0 extbl %d0
4b258: b480 cmpl %d0,%d2
4b25a: 6614 bnes 4b270 <rtems_bdbuf_get_buffer_from_lru_list+0x278>
{
p->avl.right = p1->avl.left;
4b25c: 216b 0008 000c movel %a3@(8),%a0@(12)
p1->avl.left = p;
4b262: 2748 0008 movel %a0,%a3@(8)
p->avl.bal = 0;
4b266: 244b moveal %a3,%a2
4b268: 4203 clrb %d3
4b26a: 1143 0011 moveb %d3,%a0@(17)
4b26e: 603a bras 4b2aa <rtems_bdbuf_get_buffer_from_lru_list+0x2b2>
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
4b270: 246b 0008 moveal %a3@(8),%a2
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4b274: 7801 moveq #1,%d4
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4b276: 7eff moveq #-1,%d7
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4b278: 102a 0011 moveb %a2@(17),%d0
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4b27c: 276a 000c 0008 movel %a2@(12),%a3@(8)
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4b282: 49c0 extbl %d0
4b284: b880 cmpl %d0,%d4
4b286: 57c0 seq %d0
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
4b288: 254b 000c movel %a3,%a2@(12)
p->avl.right = p2->avl.left;
4b28c: 216a 0008 000c movel %a2@(8),%a0@(12)
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4b292: 1140 0011 moveb %d0,%a0@(17)
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
4b296: 2548 0008 movel %a0,%a2@(8)
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4b29a: 102a 0011 moveb %a2@(17),%d0
4b29e: 49c0 extbl %d0
4b2a0: be80 cmpl %d0,%d7
4b2a2: 56c0 sne %d0
4b2a4: 5280 addql #1,%d0
4b2a6: 1740 0011 moveb %d0,%a3@(17)
p = p2;
}
p->avl.bal = 0;
4b2aa: 204a moveal %a2,%a0
4b2ac: 4200 clrb %d0
4b2ae: 1540 0011 moveb %d0,%a2@(17)
4b2b2: 6002 bras 4b2b6 <rtems_bdbuf_get_buffer_from_lru_list+0x2be>
break;
}
}
else
{
switch (p->avl.bal)
4b2b4: 7001 moveq #1,%d0
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4b2b6: b28c cmpl %a4,%d1
4b2b8: 641c bccs 4b2d6 <rtems_bdbuf_get_buffer_from_lru_list+0x2de>
{
p = *--buf_prev;
4b2ba: 246c fffc moveal %a4@(-4),%a2
if (p->avl.cache == -1)
4b2be: 76ff moveq #-1,%d3
4b2c0: 142a 0010 moveb %a2@(16),%d2
4b2c4: 49c2 extbl %d2
4b2c6: b682 cmpl %d2,%d3
4b2c8: 6606 bnes 4b2d0 <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
{
p->avl.left = q;
4b2ca: 2548 0008 movel %a0,%a2@(8)
4b2ce: 600e bras 4b2de <rtems_bdbuf_get_buffer_from_lru_list+0x2e6>
}
else
{
p->avl.right = q;
4b2d0: 2548 000c movel %a0,%a2@(12)
4b2d4: 6008 bras 4b2de <rtems_bdbuf_get_buffer_from_lru_list+0x2e6>
}
}
else
{
*root = p;
4b2d6: 23c8 0006 1720 movel %a0,61720 <bdbuf_cache+0x3c>
4b2dc: 6008 bras 4b2e6 <rtems_bdbuf_get_buffer_from_lru_list+0x2ee>
4b2de: 598c subql #4,%a4
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
4b2e0: 4a00 tstb %d0
4b2e2: 6600 feb8 bnew 4b19c <rtems_bdbuf_get_buffer_from_lru_list+0x1a4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b2e6: 7801 moveq #1,%d4
4b2e8: 2344 0022 movel %d4,%a1@(34)
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dev, block);
return empty_bd;
4b2ec: 600e bras 4b2fc <rtems_bdbuf_get_buffer_from_lru_list+0x304>
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
}
4b2ee: 2653 moveal %a3@,%a3
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
4b2f0: b7fc 0006 1728 cmpal #399144,%a3
4b2f6: 6600 fd24 bnew 4b01c <rtems_bdbuf_get_buffer_from_lru_list+0x24>
}
node = rtems_chain_next (node);
}
return NULL;
4b2fa: 93c9 subal %a1,%a1
}
4b2fc: 2009 movel %a1,%d0
4b2fe: 4cee 3cfc ff54 moveml %fp@(-172),%d2-%d7/%a2-%a5
4b304: 4e5e unlk %fp
4b306: 4e75 rts
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_RECYCLE);
4b308: 2f3c 4200 001b movel #1107296283,%sp@- <== NOT EXECUTED
4b30e: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
0004b4ea <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
4b4ea: 4e56 ffe4 linkw %fp,#-28
4b4ee: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
4b4f2: 4ab9 0006 240e tstl 6240e <_Per_CPU_Information+0x8>
4b4f8: 6600 037a bnew 4b874 <rtems_bdbuf_init+0x38a>
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
4b4fc: 2439 0005 ea0c movel 5ea0c <rtems_bdbuf_configuration+0x20>,%d2
4b502: 2839 0005 ea10 movel 5ea10 <rtems_bdbuf_configuration+0x24>,%d4
4b508: 4c42 4000 remul %d2,%d0,%d4
4b50c: 4c42 4004 remul %d2,%d4,%d4
4b510: 4a80 tstl %d0
4b512: 6600 0364 bnew 4b878 <rtems_bdbuf_init+0x38e>
/*
* We use a special variable to manage the initialisation incase we have
* completing threads doing this. You may get errors if the another thread
* makes a call and we have not finished initialisation.
*/
prev_mode = rtems_bdbuf_disable_preemption ();
4b516: 4eba ec6e jsr %pc@(4a186 <rtems_bdbuf_disable_preemption>)
4b51a: 2600 movel %d0,%d3
if (bdbuf_cache.initialised)
4b51c: 4a39 0006 1768 tstb 61768 <bdbuf_cache+0x84>
4b522: 670e beqs 4b532 <rtems_bdbuf_init+0x48> <== ALWAYS TAKEN
{
rtems_bdbuf_restore_preemption (prev_mode);
4b524: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b526: 4eba ec92 jsr %pc@(4a1ba <rtems_bdbuf_restore_preemption>)<== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
4b52a: 588f addql #4,%sp <== NOT EXECUTED
4b52c: 700c moveq #12,%d0 <== NOT EXECUTED
4b52e: 6000 034a braw 4b87a <rtems_bdbuf_init+0x390> <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
4b532: 4878 0086 pea 86 <DBL_MANT_DIG+0x51>
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4b536: 45f9 0004 648c lea 4648c <rtems_semaphore_create>,%a2
{
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
4b53c: 42a7 clrl %sp@-
4b53e: 4879 0006 16e4 pea 616e4 <bdbuf_cache>
4b544: 4eb9 0005 0c00 jsr 50c00 <memset>
bdbuf_cache.initialised = true;
4b54a: 7001 moveq #1,%d0
rtems_bdbuf_restore_preemption (prev_mode);
4b54c: 2f03 movel %d3,%sp@-
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
bdbuf_cache.initialised = true;
4b54e: 13c0 0006 1768 moveb %d0,61768 <bdbuf_cache+0x84>
rtems_bdbuf_restore_preemption (prev_mode);
4b554: 4eba ec64 jsr %pc@(4a1ba <rtems_bdbuf_restore_preemption>)
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4b558: 4879 0006 170a pea 6170a <bdbuf_cache+0x26>
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
4b55e: 70ff moveq #-1,%d0
4b560: 72ff moveq #-1,%d1
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4b562: 42a7 clrl %sp@-
4b564: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
4b568: 4878 0001 pea 1 <ADD>
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
4b56c: 23c0 0006 1718 movel %d0,61718 <bdbuf_cache+0x34>
4b572: 23c1 0006 171c movel %d1,6171c <bdbuf_cache+0x38>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b578: 223c 0006 16ee movel #399086,%d1
head->previous = NULL;
tail->previous = head;
4b57e: 203c 0006 16ea movel #399082,%d0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b584: 23c1 0006 16ea movel %d1,616ea <bdbuf_cache+0x6>
4b58a: 223c 0006 1728 movel #399144,%d1
head->previous = NULL;
tail->previous = head;
4b590: 23c0 0006 16f2 movel %d0,616f2 <bdbuf_cache+0xe>
4b596: 203c 0006 1724 movel #399140,%d0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b59c: 23c1 0006 1724 movel %d1,61724 <bdbuf_cache+0x40>
4b5a2: 223c 0006 1734 movel #399156,%d1
head->previous = NULL;
tail->previous = head;
4b5a8: 23c0 0006 172c movel %d0,6172c <bdbuf_cache+0x48>
4b5ae: 203c 0006 1730 movel #399152,%d0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b5b4: 23c1 0006 1730 movel %d1,61730 <bdbuf_cache+0x4c>
4b5ba: 223c 0006 1740 movel #399168,%d1
head->previous = NULL;
tail->previous = head;
4b5c0: 23c0 0006 1738 movel %d0,61738 <bdbuf_cache+0x54>
4b5c6: 203c 0006 173c movel #399164,%d0
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4b5cc: 2f3c 4244 436c movel #1111769964,%sp@-
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4b5d2: 42b9 0006 16ee clrl 616ee <bdbuf_cache+0xa>
4b5d8: 42b9 0006 1728 clrl 61728 <bdbuf_cache+0x44>
4b5de: 42b9 0006 1734 clrl 61734 <bdbuf_cache+0x50>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b5e4: 23c1 0006 173c movel %d1,6173c <bdbuf_cache+0x58>
head->previous = NULL;
4b5ea: 42b9 0006 1740 clrl 61740 <bdbuf_cache+0x5c>
tail->previous = head;
4b5f0: 23c0 0006 1744 movel %d0,61744 <bdbuf_cache+0x60>
4b5f6: 4e92 jsr %a2@
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
4b5f8: 4fef 0024 lea %sp@(36),%sp
4b5fc: 4a80 tstl %d0
4b5fe: 6600 01f8 bnew 4b7f8 <rtems_bdbuf_init+0x30e>
goto error;
rtems_bdbuf_lock_cache ();
4b602: 4eba e8d4 jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
4b606: 4879 0006 170e pea 6170e <bdbuf_cache+0x2a>
4b60c: 42a7 clrl %sp@-
4b60e: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
4b612: 4878 0001 pea 1 <ADD>
4b616: 2f3c 4244 4373 movel #1111769971,%sp@-
4b61c: 4e92 jsr %a2@
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
4b61e: 4fef 0014 lea %sp@(20),%sp
4b622: 4a80 tstl %d0
4b624: 6600 01d2 bnew 4b7f8 <rtems_bdbuf_init+0x30e>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
4b628: 4879 0006 174c pea 6174c <bdbuf_cache+0x68>
4b62e: 42a7 clrl %sp@-
4b630: 4878 0024 pea 24 <OPER2+0x10>
4b634: 42a7 clrl %sp@-
4b636: 2f3c 4244 4361 movel #1111769953,%sp@-
4b63c: 4e92 jsr %a2@
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4b63e: 4fef 0014 lea %sp@(20),%sp
4b642: 4a80 tstl %d0
4b644: 6600 01b2 bnew 4b7f8 <rtems_bdbuf_init+0x30e>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
4b648: 4879 0006 1754 pea 61754 <bdbuf_cache+0x70>
4b64e: 42a7 clrl %sp@-
4b650: 4878 0024 pea 24 <OPER2+0x10>
4b654: 42a7 clrl %sp@-
4b656: 2f3c 4244 4374 movel #1111769972,%sp@-
4b65c: 4e92 jsr %a2@
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4b65e: 4fef 0014 lea %sp@(20),%sp
4b662: 4a80 tstl %d0
4b664: 6600 0192 bnew 4b7f8 <rtems_bdbuf_init+0x30e>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
4b668: 4879 0006 175c pea 6175c <bdbuf_cache+0x78>
4b66e: 42a7 clrl %sp@-
4b670: 4878 0024 pea 24 <OPER2+0x10>
4b674: 42a7 clrl %sp@-
4b676: 2f3c 4244 4362 movel #1111769954,%sp@-
4b67c: 4e92 jsr %a2@
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4b67e: 4fef 0014 lea %sp@(20),%sp
4b682: 4a80 tstl %d0
4b684: 6600 0172 bnew 4b7f8 <rtems_bdbuf_init+0x30e>
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4b688: 2639 0005 ea08 movel 5ea08 <rtems_bdbuf_configuration+0x1c>,%d3
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4b68e: 45f9 0004 3294 lea 43294 <calloc>,%a2
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4b694: 4c42 3003 remul %d2,%d3,%d3
bdbuf_cache.max_bds_per_group =
4b698: 23c4 0006 1702 movel %d4,61702 <bdbuf_cache+0x1e>
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4b69e: 2203 movel %d3,%d1
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4b6a0: 2f03 movel %d3,%sp@-
4b6a2: 4878 003a pea 3a <DBL_MANT_DIG+0x5>
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4b6a6: 4c44 1001 remul %d4,%d1,%d1
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
4b6aa: 23c3 0006 16fe movel %d3,616fe <bdbuf_cache+0x1a>
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4b6b0: 2801 movel %d1,%d4
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
4b6b2: 23c1 0006 1760 movel %d1,61760 <bdbuf_cache+0x7c>
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4b6b8: 4e92 jsr %a2@
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
4b6ba: 508f addql #8,%sp
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4b6bc: 23c0 0006 16f6 movel %d0,616f6 <bdbuf_cache+0x12>
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
4b6c2: 6700 0134 beqw 4b7f8 <rtems_bdbuf_init+0x30e>
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
4b6c6: 2f04 movel %d4,%sp@-
4b6c8: 4878 0014 pea 14 <OPER2>
4b6cc: 4e92 jsr %a2@
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
4b6ce: 508f addql #8,%sp
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
4b6d0: 23c0 0006 1764 movel %d0,61764 <bdbuf_cache+0x80>
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
4b6d6: 6700 0120 beqw 4b7f8 <rtems_bdbuf_init+0x30e>
* aligned. It is possible to free the memory allocated by rtems_memalign()
* with free(). Return 0 if allocated.
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
4b6da: 4c02 3800 mulsl %d2,%d3
4b6de: 2f03 movel %d3,%sp@-
4b6e0: 4878 0020 pea 20 <OPER2+0xc>
4b6e4: 4879 0006 16fa pea 616fa <bdbuf_cache+0x16>
4b6ea: 4eb9 0004 d62c jsr 4d62c <rtems_memalign>
4b6f0: 4fef 000c lea %sp@(12),%sp
4b6f4: 4a80 tstl %d0
4b6f6: 6600 0100 bnew 4b7f8 <rtems_bdbuf_init+0x30e>
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4b6fa: 2a39 0006 1764 movel 61764 <bdbuf_cache+0x80>,%d5
4b700: 4283 clrl %d3
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4b702: 47f9 0004 71e4 lea 471e4 <_Chain_Append>,%a3
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4b708: 2479 0006 16f6 moveal 616f6 <bdbuf_cache+0x12>,%a2
4b70e: 2839 0006 16fa movel 616fa <bdbuf_cache+0x16>,%d4
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4b714: 6040 bras 4b756 <rtems_bdbuf_init+0x26c>
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
bd->group = group;
4b716: 2545 002a movel %d5,%a2@(42)
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4b71a: 2c03 movel %d3,%d6
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
4b71c: 70ff moveq #-1,%d0
4b71e: 72ff moveq #-1,%d1
bd->group = group;
bd->buffer = buffer;
4b720: 2544 001e movel %d4,%a2@(30)
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
4b724: 2540 0012 movel %d0,%a2@(18)
4b728: 2541 0016 movel %d1,%a2@(22)
4b72c: 2f0a movel %a2,%sp@-
4b72e: 4879 0006 1724 pea 61724 <bdbuf_cache+0x40>
4b734: 4e93 jsr %a3@
bd->group = group;
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4b736: 2039 0006 1702 movel 61702 <bdbuf_cache+0x1e>,%d0
4b73c: 508f addql #8,%sp
4b73e: 4c40 6001 remul %d0,%d1,%d6
(bdbuf_cache.max_bds_per_group - 1))
4b742: 5380 subql #1,%d0
bd->group = group;
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4b744: b081 cmpl %d1,%d0
4b746: 6606 bnes 4b74e <rtems_bdbuf_init+0x264>
(bdbuf_cache.max_bds_per_group - 1))
group++;
4b748: 0685 0000 0014 addil #20,%d5
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
4b74e: 5283 addql #1,%d3
4b750: 45ea 003a lea %a2@(58),%a2
4b754: d882 addl %d2,%d4
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4b756: b6b9 0006 16fe cmpl 616fe <bdbuf_cache+0x1a>,%d3
4b75c: 65b8 bcss 4b716 <rtems_bdbuf_init+0x22c>
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4b75e: 2439 0006 1702 movel 61702 <bdbuf_cache+0x1e>,%d2
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
4b764: 763a moveq #58,%d3
4b766: 4c02 3800 mulsl %d2,%d3
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
4b76a: 4280 clrl %d0
group = bdbuf_cache.groups,
4b76c: 2079 0006 1764 moveal 61764 <bdbuf_cache+0x80>,%a0
bd = bdbuf_cache.bds;
4b772: 2239 0006 16f6 movel 616f6 <bdbuf_cache+0x12>,%d1
b < bdbuf_cache.group_count;
4b778: 2279 0006 1760 moveal 61760 <bdbuf_cache+0x7c>,%a1
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
4b77e: 6010 bras 4b790 <rtems_bdbuf_init+0x2a6>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
4b780: 2141 0010 movel %d1,%a0@(16)
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
4b784: 5280 addql #1,%d0
group++,
bd += bdbuf_cache.max_bds_per_group)
4b786: d283 addl %d3,%d1
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4b788: 2142 0008 movel %d2,%a0@(8)
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
4b78c: 41e8 0014 lea %a0@(20),%a0
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
4b790: b3c0 cmpal %d0,%a1
4b792: 66ec bnes 4b780 <rtems_bdbuf_init+0x296>
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
bdbuf_config.swapout_priority ?
4b794: 2039 0005 e9f4 movel 5e9f4 <rtems_bdbuf_configuration+0x8>,%d0
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
4b79a: 7201 moveq #1,%d1
4b79c: 13c1 0006 16e8 moveb %d1,616e8 <bdbuf_cache+0x4>
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
4b7a2: 4a80 tstl %d0
4b7a4: 6604 bnes 4b7aa <rtems_bdbuf_init+0x2c0> <== ALWAYS TAKEN
4b7a6: 103c 000f moveb #15,%d0 <== NOT EXECUTED
4b7aa: 4879 0006 16e4 pea 616e4 <bdbuf_cache>
4b7b0: 42a7 clrl %sp@-
4b7b2: 4878 0400 pea 400 <D_BIAS+0x2>
4b7b6: 4878 2000 pea 2000 <D_MAX_EXP+0x1801>
4b7ba: 2f00 movel %d0,%sp@-
4b7bc: 2f3c 4253 5750 movel #1112758096,%sp@-
4b7c2: 4eb9 0004 6880 jsr 46880 <rtems_task_create>
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
4b7c8: 4fef 0018 lea %sp@(24),%sp
4b7cc: 4a80 tstl %d0
4b7ce: 6628 bnes 4b7f8 <rtems_bdbuf_init+0x30e> <== NEVER TAKEN
goto error;
sc = rtems_task_start (bdbuf_cache.swapout,
4b7d0: 4879 0006 16e4 pea 616e4 <bdbuf_cache>
4b7d6: 487a f470 pea %pc@(4ac48 <rtems_bdbuf_swapout_task>)
4b7da: 2f39 0006 16e4 movel 616e4 <bdbuf_cache>,%sp@-
4b7e0: 4eb9 0004 6ab4 jsr 46ab4 <rtems_task_start>
rtems_bdbuf_swapout_task,
(rtems_task_argument) &bdbuf_cache);
if (sc != RTEMS_SUCCESSFUL)
4b7e6: 4fef 000c lea %sp@(12),%sp
4b7ea: 4a80 tstl %d0
4b7ec: 660a bnes 4b7f8 <rtems_bdbuf_init+0x30e> <== NEVER TAKEN
goto error;
rtems_bdbuf_unlock_cache ();
4b7ee: 4eba e89c jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
return RTEMS_SUCCESSFUL;
4b7f2: 4280 clrl %d0
4b7f4: 6000 0084 braw 4b87a <rtems_bdbuf_init+0x390>
error:
if (bdbuf_cache.swapout != 0)
4b7f8: 2039 0006 16e4 movel 616e4 <bdbuf_cache>,%d0 <== NOT EXECUTED
4b7fe: 670a beqs 4b80a <rtems_bdbuf_init+0x320> <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
4b800: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b802: 4eb9 0004 69a4 jsr 469a4 <rtems_task_delete> <== NOT EXECUTED
4b808: 588f addql #4,%sp <== NOT EXECUTED
free (bdbuf_cache.buffers);
4b80a: 2f39 0006 16fa movel 616fa <bdbuf_cache+0x16>,%sp@- <== NOT EXECUTED
4b810: 45f9 0004 3630 lea 43630 <free>,%a2 <== NOT EXECUTED
4b816: 4e92 jsr %a2@ <== NOT EXECUTED
free (bdbuf_cache.groups);
4b818: 2f39 0006 1764 movel 61764 <bdbuf_cache+0x80>,%sp@- <== NOT EXECUTED
4b81e: 4e92 jsr %a2@ <== NOT EXECUTED
free (bdbuf_cache.bds);
4b820: 2f39 0006 16f6 movel 616f6 <bdbuf_cache+0x12>,%sp@- <== NOT EXECUTED
4b826: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
4b828: 2f39 0006 175c movel 6175c <bdbuf_cache+0x78>,%sp@- <== NOT EXECUTED
4b82e: 45f9 0004 662c lea 4662c <rtems_semaphore_delete>,%a2 <== NOT EXECUTED
4b834: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
4b836: 2f39 0006 174c movel 6174c <bdbuf_cache+0x68>,%sp@- <== NOT EXECUTED
4b83c: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
4b83e: 2f39 0006 1754 movel 61754 <bdbuf_cache+0x70>,%sp@- <== NOT EXECUTED
4b844: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
4b846: 2f39 0006 170e movel 6170e <bdbuf_cache+0x2a>,%sp@- <== NOT EXECUTED
4b84c: 4e92 jsr %a2@ <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
4b84e: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4b852: 4ab9 0006 170a tstl 6170a <bdbuf_cache+0x26> <== NOT EXECUTED
4b858: 670e beqs 4b868 <rtems_bdbuf_init+0x37e> <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
4b85a: 4eba e830 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>) <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
4b85e: 2f39 0006 170a movel 6170a <bdbuf_cache+0x26>,%sp@- <== NOT EXECUTED
4b864: 4e92 jsr %a2@ <== NOT EXECUTED
4b866: 588f addql #4,%sp <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
4b868: 4200 clrb %d0 <== NOT EXECUTED
4b86a: 13c0 0006 1768 moveb %d0,61768 <bdbuf_cache+0x84> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
4b870: 700d moveq #13,%d0 <== NOT EXECUTED
4b872: 6006 bras 4b87a <rtems_bdbuf_init+0x390> <== NOT EXECUTED
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
return RTEMS_CALLED_FROM_ISR;
4b874: 7012 moveq #18,%d0 <== NOT EXECUTED
4b876: 6002 bras 4b87a <rtems_bdbuf_init+0x390> <== NOT EXECUTED
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
return RTEMS_INVALID_NUMBER;
4b878: 700a moveq #10,%d0 <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
return RTEMS_UNSATISFIED;
}
4b87a: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
4b880: 4e5e unlk %fp <== NOT EXECUTED
00049ed8 <rtems_bdbuf_lock_cache>:
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
49ed8: 4e56 0000 linkw %fp,#0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
49edc: 42a7 clrl %sp@-
49ede: 42a7 clrl %sp@-
49ee0: 2f39 0006 170a movel 6170a <bdbuf_cache+0x26>,%sp@-
49ee6: 4eb9 0004 66c8 jsr 466c8 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
49eec: 4fef 000c lea %sp@(12),%sp
49ef0: 4a80 tstl %d0
49ef2: 670c beqs 49f00 <rtems_bdbuf_lock_cache+0x28> <== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
49ef4: 2f3c 4200 000d movel #1107296269,%sp@- <== NOT EXECUTED
49efa: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_lock_cache (void)
{
rtems_bdbuf_lock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_LOCK);
}
49f00: 4e5e unlk %fp <== NOT EXECUTED
00049f04 <rtems_bdbuf_lock_sync>:
/**
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
49f04: 4e56 0000 linkw %fp,#0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
49f08: 42a7 clrl %sp@-
49f0a: 42a7 clrl %sp@-
49f0c: 2f39 0006 170e movel 6170e <bdbuf_cache+0x2a>,%sp@-
49f12: 4eb9 0004 66c8 jsr 466c8 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
49f18: 4fef 000c lea %sp@(12),%sp
49f1c: 4a80 tstl %d0
49f1e: 670c beqs 49f2c <rtems_bdbuf_lock_sync+0x28> <== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
49f20: 2f3c 4200 000b movel #1107296267,%sp@- <== NOT EXECUTED
49f26: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_lock_sync (void)
{
rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BLKDEV_FATAL_BDBUF_SYNC_LOCK);
}
49f2c: 4e5e unlk %fp <== NOT EXECUTED
0004a420 <rtems_bdbuf_obtain_disk.part.7>:
return bd;
}
static rtems_status_code
rtems_bdbuf_obtain_disk (dev_t dev,
4a420: 4e56 ffe4 linkw %fp,#-28
4a424: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
4a428: 2f2e 000c movel %fp@(12),%sp@-
4a42c: 2f2e 0008 movel %fp@(8),%sp@-
return bd;
}
static rtems_status_code
rtems_bdbuf_obtain_disk (dev_t dev,
4a430: 286e 0018 moveal %fp@(24),%a4
4a434: 266e 001c moveal %fp@(28),%a3
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
4a438: 4eb9 0004 2912 jsr 42912 <rtems_disk_obtain>
if (dd == NULL)
4a43e: 508f addql #8,%sp
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
4a440: 2440 moveal %d0,%a2
if (dd == NULL)
4a442: 4a80 tstl %d0
4a444: 6700 0092 beqw 4a4d8 <rtems_bdbuf_obtain_disk.part.7+0xb8>
return RTEMS_INVALID_ID;
*dd_ptr = dd;
4a448: 206e 0014 moveal %fp@(20),%a0
4a44c: 2080 movel %d0,%a0@
if (media_block_ptr != NULL)
4a44e: 4a8c tstl %a4
4a450: 673e beqs 4a490 <rtems_bdbuf_obtain_disk.part.7+0x70>
rtems_bdbuf_media_block (rtems_blkdev_bnum block,
size_t block_size,
size_t media_block_size)
{
return (rtems_blkdev_bnum)
((((uint64_t) block) * block_size) / media_block_size);
4a452: 262a 0020 movel %a2@(32),%d3
4a456: 4282 clrl %d2
4a458: 4284 clrl %d4
4a45a: 2f03 movel %d3,%sp@-
4a45c: 2f02 movel %d2,%sp@-
4a45e: 2f2e 0010 movel %fp@(16),%sp@-
4a462: 42a7 clrl %sp@-
4a464: 4eb9 0005 c854 jsr 5c854 <__muldi3>
4a46a: 2a2a 0024 movel %a2@(36),%d5
4a46e: 4fef 0010 lea %sp@(16),%sp
4a472: 2f05 movel %d5,%sp@-
4a474: 2f04 movel %d4,%sp@-
4a476: 2f01 movel %d1,%sp@-
4a478: 2f00 movel %d0,%sp@-
4a47a: 4eb9 0005 d134 jsr 5d134 <__udivdi3>
4a480: 4fef 0010 lea %sp@(16),%sp
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
dd->media_block_size);
if (mb >= dd->size)
4a484: b2aa 001c cmpl %a2@(28),%d1
4a488: 643c bccs 4a4c6 <rtems_bdbuf_obtain_disk.part.7+0xa6><== NEVER TAKEN
{
rtems_disk_release(dd);
return RTEMS_INVALID_NUMBER;
}
*media_block_ptr = mb + dd->start;
4a48a: d2aa 0018 addl %a2@(24),%d1
4a48e: 2881 movel %d1,%a4@
}
if (bds_per_group_ptr != NULL)
4a490: 4a8b tstl %a3
4a492: 6748 beqs 4a4dc <rtems_bdbuf_obtain_disk.part.7+0xbc>
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
4a494: 202a 0020 movel %a2@(32),%d0
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
4a498: b0b9 0005 ea10 cmpl 5ea10 <rtems_bdbuf_configuration+0x24>,%d0
4a49e: 6226 bhis 4a4c6 <rtems_bdbuf_obtain_disk.part.7+0xa6><== NEVER TAKEN
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
4a4a0: 5380 subql #1,%d0
4a4a2: 41f9 0005 ea0c lea 5ea0c <rtems_bdbuf_configuration+0x20>,%a0
4a4a8: 4c50 0000 remul %a0@,%d0,%d0
4a4ac: 2200 movel %d0,%d1
4a4ae: 5281 addql #1,%d1
for (bds_per_size = 1;
4a4b0: 7001 moveq #1,%d0
4a4b2: 6002 bras 4a4b6 <rtems_bdbuf_obtain_disk.part.7+0x96>
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
4a4b4: d080 addl %d0,%d0
if (size > bdbuf_config.buffer_max)
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
for (bds_per_size = 1;
4a4b6: b280 cmpl %d0,%d1
4a4b8: 62fa bhis 4a4b4 <rtems_bdbuf_obtain_disk.part.7+0x94>
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
;
return bdbuf_cache.max_bds_per_group / bds_per_size;
4a4ba: 2439 0006 1702 movel 61702 <bdbuf_cache+0x1e>,%d2
4a4c0: 4c40 2002 remul %d0,%d2,%d2
if (bds_per_group_ptr != NULL)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
if (bds_per_group == 0)
4a4c4: 660e bnes 4a4d4 <rtems_bdbuf_obtain_disk.part.7+0xb4><== ALWAYS TAKEN
{
rtems_disk_release (dd);
4a4c6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4a4c8: 4eb9 0004 297a jsr 4297a <rtems_disk_release> <== NOT EXECUTED
4a4ce: 588f addql #4,%sp <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
4a4d0: 700a moveq #10,%d0 <== NOT EXECUTED
4a4d2: 600a bras 4a4de <rtems_bdbuf_obtain_disk.part.7+0xbe><== NOT EXECUTED
}
*bds_per_group_ptr = bds_per_group;
4a4d4: 2682 movel %d2,%a3@
4a4d6: 6004 bras 4a4dc <rtems_bdbuf_obtain_disk.part.7+0xbc>
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
if (dd == NULL)
return RTEMS_INVALID_ID;
4a4d8: 7004 moveq #4,%d0 <== NOT EXECUTED
4a4da: 6002 bras 4a4de <rtems_bdbuf_obtain_disk.part.7+0xbe><== NOT EXECUTED
}
*bds_per_group_ptr = bds_per_group;
}
return RTEMS_SUCCESSFUL;
4a4dc: 4280 clrl %d0
}
4a4de: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4a4e4: 4e5e unlk %fp <== NOT EXECUTED
0004a870 <rtems_bdbuf_purge>:
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
4a870: 4e56 ff50 linkw %fp,#-176
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4a874: 200e movel %fp,%d0
4a876: 5180 subql #8,%d0
4a878: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4a87c: 280e movel %fp,%d4
4a87e: 0684 ffff fff4 addil #-12,%d4
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
rtems_bdbuf_purge_compare compare,
dev_t dev)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
4a884: 47ee ff74 lea %fp@(-140),%a3
4a888: 2a3c 0004 721c movel #291356,%d5
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4a88e: 4bf9 0004 71e4 lea 471e4 <_Chain_Append>,%a5
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
4a894: 49fa fab0 lea %pc@(4a346 <rtems_bdbuf_wake>),%a4
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
4a898: 2c2e 0008 movel %fp@(8),%d6
4a89c: 2d40 fff4 movel %d0,%fp@(-12)
4a8a0: 242e 000c movel %fp@(12),%d2
4a8a4: 262e 0010 movel %fp@(16),%d3
head->previous = NULL;
4a8a8: 42ae fff8 clrl %fp@(-8)
tail->previous = head;
4a8ac: 2d44 fffc movel %d4,%fp@(-4)
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
4a8b0: 4eba f626 jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
rtems_bdbuf_purge_compare compare,
dev_t dev)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
4a8b4: 2479 0006 1720 moveal 61720 <bdbuf_cache+0x3c>,%a2
*prev = NULL;
4a8ba: 42ae ff74 clrl %fp@(-140)
4a8be: 6000 00b0 braw 4a970 <rtems_bdbuf_purge+0x100>
while (cur != NULL)
{
if ((*compare) (cur->dev, dev))
4a8c2: 2f03 movel %d3,%sp@-
4a8c4: 2046 moveal %d6,%a0
4a8c6: 2f02 movel %d2,%sp@-
4a8c8: 2f2a 0016 movel %a2@(22),%sp@-
4a8cc: 2f2a 0012 movel %a2@(18),%sp@-
4a8d0: 4e90 jsr %a0@
4a8d2: 4fef 0010 lea %sp@(16),%sp
4a8d6: 4a00 tstb %d0
4a8d8: 676a beqs 4a944 <rtems_bdbuf_purge+0xd4> <== NEVER TAKEN
{
switch (cur->state)
4a8da: 202a 0022 movel %a2@(34),%d0
4a8de: 720a moveq #10,%d1
4a8e0: b280 cmpl %d0,%d1
4a8e2: 6554 bcss 4a938 <rtems_bdbuf_purge+0xc8> <== NEVER TAKEN
4a8e4: 303b 0a08 movew %pc@(4a8ee <rtems_bdbuf_purge+0x7e>,%d0:l:2),%d0
4a8e8: 48c0 extl %d0
4a8ea: 4efb 0802 jmp %pc@(4a8ee <rtems_bdbuf_purge+0x7e>,%d0:l)
4a8ee: 0056 .short 0x0056 <== NOT EXECUTED
4a8f0: 0056 .short 0x0056 <== NOT EXECUTED
4a8f2: 0028 .short 0x0028 <== NOT EXECUTED
4a8f4: 0042 .short 0x0042 <== NOT EXECUTED
4a8f6: 0042 .short 0x0042 <== NOT EXECUTED
4a8f8: 0042 .short 0x0042 <== NOT EXECUTED
4a8fa: 0056 .short 0x0056 <== NOT EXECUTED
4a8fc: 0020 .short 0x0020 <== NOT EXECUTED
4a8fe: 0016 .short 0x0016 <== NOT EXECUTED
4a900: 003a .short 0x003a <== NOT EXECUTED
4a902: 0056 .short 0x0056 <== NOT EXECUTED
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
4a904: 4879 0006 1750 pea 61750 <bdbuf_cache+0x6c>
4a90a: 4e94 jsr %a4@
4a90c: 588f addql #4,%sp
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4a90e: 206a 002a moveal %a2@(42),%a0
4a912: 53a8 000c subql #1,%a0@(12)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4a916: 2f0a movel %a2,%sp@-
4a918: 2045 moveal %d5,%a0
4a91a: 4e90 jsr %a0@
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4a91c: 2f0a movel %a2,%sp@-
4a91e: 2f04 movel %d4,%sp@-
4a920: 4e95 jsr %a5@
4a922: 4fef 000c lea %sp@(12),%sp
4a926: 601c bras 4a944 <rtems_bdbuf_purge+0xd4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a928: 700a moveq #10,%d0
4a92a: 2540 0022 movel %d0,%a2@(34)
4a92e: 6014 bras 4a944 <rtems_bdbuf_purge+0xd4>
4a930: 7206 moveq #6,%d1
4a932: 2541 0022 movel %d1,%a2@(34)
4a936: 600c bras 4a944 <rtems_bdbuf_purge+0xd4>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_set_state (cur, RTEMS_BDBUF_STATE_ACCESS_PURGED);
break;
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
4a938: 2f3c 4200 0001 movel #1107296257,%sp@- <== NOT EXECUTED
4a93e: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
4a944: 206a 0008 moveal %a2@(8),%a0
4a948: 4a88 tstl %a0
4a94a: 6608 bnes 4a954 <rtems_bdbuf_purge+0xe4> <== NEVER TAKEN
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
4a94c: 206a 000c moveal %a2@(12),%a0
4a950: 4a88 tstl %a0
4a952: 670c beqs 4a960 <rtems_bdbuf_purge+0xf0> <== ALWAYS TAKEN
{
/* Right */
++prev;
*prev = cur;
4a954: 274a 0004 movel %a2,%a3@(4) <== NOT EXECUTED
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
4a958: 588b addql #4,%a3 <== NOT EXECUTED
4a95a: 6012 bras 4a96e <rtems_bdbuf_purge+0xfe> <== NOT EXECUTED
{
while (*prev != NULL && cur == (*prev)->avl.right)
{
/* Up */
cur = *prev;
--prev;
4a95c: 598b subql #4,%a3 <== NOT EXECUTED
4a95e: 2448 moveal %a0,%a2 <== NOT EXECUTED
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
4a960: 2053 moveal %a3@,%a0
4a962: 4a88 tstl %a0
4a964: 6708 beqs 4a96e <rtems_bdbuf_purge+0xfe> <== ALWAYS TAKEN
4a966: b5e8 000c cmpal %a0@(12),%a2 <== NOT EXECUTED
4a96a: 67f0 beqs 4a95c <rtems_bdbuf_purge+0xec> <== NOT EXECUTED
4a96c: 6078 bras 4a9e6 <rtems_bdbuf_purge+0x176> <== NOT EXECUTED
}
if (cur->avl.left != NULL)
{
/* Left */
++prev;
4a96e: 2448 moveal %a0,%a2
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
4a970: 4a8a tstl %a2
4a972: 6600 ff4e bnew 4a8c2 <rtems_bdbuf_purge+0x52>
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_gather_for_purge (&purge_list, compare, dev);
rtems_bdbuf_purge_list (&purge_list);
4a976: 260e movel %fp,%d3
4a978: 0683 ffff fff4 addil #-12,%d3
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4a97e: 49f9 0004 7244 lea 47244 <_Chain_Get>,%a4
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
{
rtems_bdbuf_remove_from_tree (bd);
4a984: 47fa fb62 lea %pc@(4a4e8 <rtems_bdbuf_remove_from_tree>),%a3
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4a988: 45f9 0004 e3cc lea 4e3cc <_Chain_Insert>,%a2
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
4a98e: 4202 clrb %d2
4a990: 602a bras 4a9bc <rtems_bdbuf_purge+0x14c>
while ((node = rtems_chain_get (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
4a992: 202d 0026 movel %a5@(38),%d0
4a996: 6602 bnes 4a99a <rtems_bdbuf_purge+0x12a>
wake_buffer_waiters = true;
4a998: 7401 moveq #1,%d2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a99a: 7001 moveq #1,%d0
4a99c: 2b40 0022 movel %d0,%a5@(34)
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4a9a0: 202d 0026 movel %a5@(38),%d0
4a9a4: 6616 bnes 4a9bc <rtems_bdbuf_purge+0x14c>
{
rtems_bdbuf_remove_from_tree (bd);
4a9a6: 2f0d movel %a5,%sp@-
4a9a8: 4e93 jsr %a3@
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a9aa: 42ad 0022 clrl %a5@(34)
4a9ae: 2f0d movel %a5,%sp@-
4a9b0: 4879 0006 1724 pea 61724 <bdbuf_cache+0x40>
4a9b6: 4e92 jsr %a2@
4a9b8: 4fef 000c lea %sp@(12),%sp
4a9bc: 2f03 movel %d3,%sp@-
4a9be: 4e94 jsr %a4@
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
rtems_chain_node *node = NULL;
while ((node = rtems_chain_get (purge_list)) != NULL)
4a9c0: 588f addql #4,%sp
4a9c2: 2a40 moveal %d0,%a5
4a9c4: 4a80 tstl %d0
4a9c6: 66ca bnes 4a992 <rtems_bdbuf_purge+0x122>
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
4a9c8: 4a02 tstb %d2
4a9ca: 670c beqs 4a9d8 <rtems_bdbuf_purge+0x168>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4a9cc: 4879 0006 1758 pea 61758 <bdbuf_cache+0x74>
4a9d2: 4eba f972 jsr %pc@(4a346 <rtems_bdbuf_wake>)
4a9d6: 588f addql #4,%sp
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_gather_for_purge (&purge_list, compare, dev);
rtems_bdbuf_purge_list (&purge_list);
rtems_bdbuf_unlock_cache ();
4a9d8: 4eba f6b2 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
}
4a9dc: 4cee 3c7c ff50 moveml %fp@(-176),%d2-%d6/%a2-%a5
4a9e2: 4e5e unlk %fp
4a9e4: 4e75 rts
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
4a9e6: 2068 000c moveal %a0@(12),%a0 <== NOT EXECUTED
4a9ea: 6082 bras 4a96e <rtems_bdbuf_purge+0xfe> <== NOT EXECUTED
00049ea2 <rtems_bdbuf_purge_compare_dev>:
rtems_bdbuf_unlock_cache ();
}
static bool
rtems_bdbuf_purge_compare_dev (dev_t a, dev_t b)
{
49ea2: 4e56 0000 linkw %fp,#0
49ea6: 2f02 movel %d2,%sp@-
return a == b;
49ea8: 222e 0010 movel %fp@(16),%d1
49eac: 242e 0014 movel %fp@(20),%d2
49eb0: b2ae 0008 cmpl %fp@(8),%d1
49eb4: 6604 bnes 49eba <rtems_bdbuf_purge_compare_dev+0x18><== NEVER TAKEN
49eb6: b4ae 000c cmpl %fp@(12),%d2
49eba: 57c0 seq %d0
}
49ebc: 241f movel %sp@+,%d2
49ebe: 4480 negl %d0
49ec0: 4e5e unlk %fp <== NOT EXECUTED
00049ec4 <rtems_bdbuf_purge_compare_major>:
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_dev, dev);
}
static bool
rtems_bdbuf_purge_compare_major (dev_t a, dev_t b)
{
49ec4: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b);
49ec8: 202e 0010 movel %fp@(16),%d0 <== NOT EXECUTED
49ecc: b0ae 0008 cmpl %fp@(8),%d0 <== NOT EXECUTED
49ed0: 57c0 seq %d0 <== NOT EXECUTED
}
49ed2: 4e5e unlk %fp <== NOT EXECUTED
49ed4: 4480 negl %d0 <== NOT EXECUTED
0004be4a <rtems_bdbuf_purge_major>:
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
temp.__overlay.minor = _minor;
4be4a: 4281 clrl %d1 <== NOT EXECUTED
return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b);
}
void
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
4be4c: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
4be50: 202e 0008 movel %fp@(8),%d0 <== NOT EXECUTED
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
4be54: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4be56: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4be58: 487a e06a pea %pc@(49ec4 <rtems_bdbuf_purge_compare_major>)<== NOT EXECUTED
4be5c: 4eba ea12 jsr %pc@(4a870 <rtems_bdbuf_purge>) <== NOT EXECUTED
4be60: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
4be64: 4e5e unlk %fp <== NOT EXECUTED
0004b948 <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4b948: 4e56 ffc4 linkw %fp,#-60
4b94c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
4b950: 42ae fff4 clrl %fp@(-12)
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
4b954: 42ae fff8 clrl %fp@(-8)
size_t bds_per_group = 0;
4b958: 42ae fffc clrl %fp@(-4)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4b95c: 4a39 0006 1768 tstb 61768 <bdbuf_cache+0x84>
4b962: 6700 01ea beqw 4bb4e <rtems_bdbuf_read+0x206>
4b966: 486e fffc pea %fp@(-4)
4b96a: 486e fff8 pea %fp@(-8)
4b96e: 486e fff4 pea %fp@(-12)
4b972: 2f2e 0010 movel %fp@(16),%sp@-
4b976: 2f2e 000c movel %fp@(12),%sp@-
4b97a: 2f2e 0008 movel %fp@(8),%sp@-
4b97e: 4eba eaa0 jsr %pc@(4a420 <rtems_bdbuf_obtain_disk.part.7>)
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
4b982: 4fef 0018 lea %sp@(24),%sp
4b986: 4a80 tstl %d0
4b988: 6600 01c6 bnew 4bb50 <rtems_bdbuf_read+0x208>
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
4b98c: 2839 0005 e9ec movel 5e9ec <rtems_bdbuf_configuration>,%d4
4b992: 5284 addql #1,%d4
4b994: 2004 movel %d4,%d0
4b996: 72fe moveq #-2,%d1
4b998: e988 lsll #4,%d0
4b99a: 0680 0000 001c addil #28,%d0
4b9a0: 9fc0 subal %d0,%sp
4b9a2: 45ef 0001 lea %sp@(1),%a2
4b9a6: 200a movel %a2,%d0
4b9a8: c081 andl %d1,%d0
4b9aa: 2440 moveal %d0,%a2
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
4b9ac: 4eba e52a jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
4b9b0: 206e fff4 moveal %fp@(-12),%a0
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
4b9b4: 2a28 0020 movel %a0@(32),%d5
4b9b8: 2e05 movel %d5,%d7
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
4b9ba: 2628 001c movel %a0@(28),%d3
4b9be: d6a8 0018 addl %a0@(24),%d3
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
4b9c2: 4c68 7007 0024 remul %a0@(36),%d7,%d7
dev_t dev = dd->dev;
4b9c8: 2010 movel %a0@,%d0
4b9ca: 2228 0004 movel %a0@(4),%d1
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
4b9ce: 242e fff8 movel %fp@(-8),%d2
dev_t dev = dd->dev;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
4b9d2: 9682 subl %d2,%d3
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
4b9d4: 2c2e fffc movel %fp@(-4),%d6
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
dev_t dev = dd->dev;
4b9d8: 2d40 ffec movel %d0,%fp@(-20)
4b9dc: 2d41 fff0 movel %d1,%fp@(-16)
4b9e0: b883 cmpl %d3,%d4
4b9e2: 6402 bccs 4b9e6 <rtems_bdbuf_read+0x9e>
4b9e4: 2604 movel %d4,%d3
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
4b9e6: 4292 clrl %a2@
req->req_done = rtems_bdbuf_transfer_done;
4b9e8: 223c 0004 a126 movel #303398,%d1
req->done_arg = req;
4b9ee: 254a 0008 movel %a2,%a2@(8)
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
4b9f2: 2541 0004 movel %d1,%a2@(4)
req->done_arg = req;
req->io_task = rtems_task_self ();
4b9f6: 4eb9 0004 e100 jsr 4e100 <rtems_task_self>
4b9fc: 2540 0014 movel %d0,%a2@(20)
req->status = RTEMS_RESOURCE_IN_USE;
4ba00: 700c moveq #12,%d0
req->bufnum = 0;
4ba02: 42aa 0010 clrl %a2@(16)
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
4ba06: 2540 000c movel %d0,%a2@(12)
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
4ba0a: 2f06 movel %d6,%sp@-
4ba0c: 2f02 movel %d2,%sp@-
4ba0e: 2f2e fff0 movel %fp@(-16),%sp@-
4ba12: 2f2e ffec movel %fp@(-20),%sp@-
4ba16: 4eba f8fc jsr %pc@(4b314 <rtems_bdbuf_get_buffer_for_access>)
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
4ba1a: 4fef 0010 lea %sp@(16),%sp
4ba1e: 7202 moveq #2,%d1
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
4ba20: 2640 moveal %d0,%a3
*bd_ptr = bd;
req->bufs [0].user = bd;
4ba22: 2540 0024 movel %d0,%a2@(36)
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
4ba26: 256b 001e 0020 movel %a3@(30),%a2@(32)
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
4ba2c: 202b 0022 movel %a3@(34),%d0
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
4ba30: 2542 0018 movel %d2,%a2@(24)
req->bufs [0].length = block_size;
4ba34: 2545 001c movel %d5,%a2@(28)
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
4ba38: b280 cmpl %d0,%d1
4ba3a: 6700 0096 beqw 4bad2 <rtems_bdbuf_read+0x18a>
4ba3e: 123c 0007 moveb #7,%d1
4ba42: b280 cmpl %d0,%d1
4ba44: 6700 008c beqw 4bad2 <rtems_bdbuf_read+0x18a>
4ba48: 123c 0001 moveb #1,%d1
4ba4c: b280 cmpl %d0,%d1
4ba4e: 6610 bnes 4ba60 <rtems_bdbuf_read+0x118> <== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4ba50: 7009 moveq #9,%d0
4ba52: 284a moveal %a2,%a4
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
dev_t dev = dd->dev;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
4ba54: 7801 moveq #1,%d4
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
4ba56: 4bfa e892 lea %pc@(4a2ea <rtems_bdbuf_avl_search.isra.1>),%a5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4ba5a: 2740 0022 movel %d0,%a3@(34)
4ba5e: 606a bras 4baca <rtems_bdbuf_read+0x182>
return;
case RTEMS_BDBUF_STATE_EMPTY:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
4ba60: 202b 0022 movel %a3@(34),%d0 <== NOT EXECUTED
4ba64: 2f3c 4200 001d movel #1107296285,%sp@- <== NOT EXECUTED
4ba6a: 6000 00c2 braw 4bb2e <rtems_bdbuf_read+0x1e6> <== NOT EXECUTED
break;
}
while (transfer_index < transfer_count)
{
media_block += media_block_count;
4ba6e: d487 addl %d7,%d2
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
4ba70: 2f02 movel %d2,%sp@-
4ba72: 2f2e fff0 movel %fp@(-16),%sp@-
4ba76: 2f2e ffec movel %fp@(-20),%sp@-
4ba7a: 2f39 0006 1720 movel 61720 <bdbuf_cache+0x3c>,%sp@-
4ba80: 4e95 jsr %a5@
4ba82: 4fef 0010 lea %sp@(16),%sp
if (bd == NULL)
4ba86: 4a80 tstl %d0
4ba88: 6644 bnes 4bace <rtems_bdbuf_read+0x186> <== NEVER TAKEN
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
4ba8a: 2f06 movel %d6,%sp@-
4ba8c: 49ec 0010 lea %a4@(16),%a4
4ba90: 2f02 movel %d2,%sp@-
4ba92: 2f2e fff0 movel %fp@(-16),%sp@-
4ba96: 2f2e ffec movel %fp@(-20),%sp@-
4ba9a: 4eba f55c jsr %pc@(4aff8 <rtems_bdbuf_get_buffer_from_lru_list>)
if (bd != NULL)
4ba9e: 4fef 0010 lea %sp@(16),%sp
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
if (bd == NULL)
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
4baa2: 2040 moveal %d0,%a0
if (bd != NULL)
4baa4: 4a80 tstl %d0
4baa6: 6726 beqs 4bace <rtems_bdbuf_read+0x186> <== ALWAYS TAKEN
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4baa8: 2268 002a moveal %a0@(42),%a1 <== NOT EXECUTED
4baac: 52a9 000c addql #1,%a1@(12) <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4bab0: 7209 moveq #9,%d1 <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
4bab2: 5284 addql #1,%d4 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4bab4: 2141 0022 movel %d1,%a0@(34) <== NOT EXECUTED
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
4bab8: 2940 0024 movel %d0,%a4@(36) <== NOT EXECUTED
req->bufs [transfer_index].block = media_block;
4babc: 2942 0018 movel %d2,%a4@(24) <== NOT EXECUTED
req->bufs [transfer_index].length = block_size;
4bac0: 2945 001c movel %d5,%a4@(28) <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
4bac4: 2968 001e 0020 movel %a0@(30),%a4@(32) <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
4baca: b684 cmpl %d4,%d3
4bacc: 62a0 bhis 4ba6e <rtems_bdbuf_read+0x126>
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
}
req->bufnum = transfer_index;
4bace: 2544 0010 movel %d4,%a2@(16)
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
4bad2: 4aaa 0010 tstl %a2@(16)
4bad6: 6728 beqs 4bb00 <rtems_bdbuf_read+0x1b8>
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
4bad8: 4878 0001 pea 1 <ADD>
4badc: 2f0a movel %a2,%sp@-
4bade: 2f2e fff4 movel %fp@(-12),%sp@-
4bae2: 4eba ef08 jsr %pc@(4a9ec <rtems_bdbuf_execute_transfer_request>)
if (sc == RTEMS_SUCCESSFUL)
4bae6: 4fef 000c lea %sp@(12),%sp
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
4baea: 2400 movel %d0,%d2
if (sc == RTEMS_SUCCESSFUL)
4baec: 666c bnes 4bb5a <rtems_bdbuf_read+0x212>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4baee: 2f0b movel %a3,%sp@-
4baf0: 4eb9 0004 721c jsr 4721c <_Chain_Extract>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4baf6: 206b 002a moveal %a3@(42),%a0
4bafa: 588f addql #4,%sp
4bafc: 52a8 000c addql #1,%a0@(12)
}
}
if (sc == RTEMS_SUCCESSFUL)
{
switch (bd->state)
4bb00: 202b 0022 movel %a3@(34),%d0
4bb04: 7202 moveq #2,%d1
4bb06: b280 cmpl %d0,%d1
4bb08: 670a beqs 4bb14 <rtems_bdbuf_read+0x1cc>
4bb0a: 123c 0007 moveb #7,%d1
4bb0e: b280 cmpl %d0,%d1
4bb10: 6612 bnes 4bb24 <rtems_bdbuf_read+0x1dc> <== NEVER TAKEN
4bb12: 6008 bras 4bb1c <rtems_bdbuf_read+0x1d4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4bb14: 7003 moveq #3,%d0
4bb16: 2740 0022 movel %d0,%a3@(34)
4bb1a: 6018 bras 4bb34 <rtems_bdbuf_read+0x1ec>
4bb1c: 7204 moveq #4,%d1
4bb1e: 2741 0022 movel %d1,%a3@(34)
4bb22: 6010 bras 4bb34 <rtems_bdbuf_read+0x1ec>
break;
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_4);
4bb24: 202b 0022 movel %a3@(34),%d0 <== NOT EXECUTED
4bb28: 2f3c 4200 0002 movel #1107296258,%sp@- <== NOT EXECUTED
4bb2e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bb30: 4eba e3fe jsr %pc@(49f30 <rtems_bdbuf_fatal>) <== NOT EXECUTED
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
4bb34: 206e 0014 moveal %fp@(20),%a0
4bb38: 4282 clrl %d2
4bb3a: 208b movel %a3,%a0@
}
else
*bd_ptr = NULL;
rtems_bdbuf_unlock_cache ();
4bb3c: 4eba e54e jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
rtems_bdbuf_release_disk (dd);
4bb40: 2f2e fff4 movel %fp@(-12),%sp@-
4bb44: 4eba e592 jsr %pc@(4a0d8 <rtems_bdbuf_release_disk>)
return sc;
4bb48: 588f addql #4,%sp
4bb4a: 2002 movel %d2,%d0
4bb4c: 6002 bras 4bb50 <rtems_bdbuf_read+0x208>
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4bb4e: 7016 moveq #22,%d0 <== NOT EXECUTED
rtems_bdbuf_unlock_cache ();
rtems_bdbuf_release_disk (dd);
return sc;
}
4bb50: 4cee 3cfc ffc4 moveml %fp@(-60),%d2-%d7/%a2-%a5
4bb56: 4e5e unlk %fp
4bb58: 4e75 rts
}
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
4bb5a: 206e 0014 moveal %fp@(20),%a0
4bb5e: 4290 clrl %a0@
4bb60: 60da bras 4bb3c <rtems_bdbuf_read+0x1f4>
0004bb62 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
4bb62: 4e56 0000 linkw %fp,#0
4bb66: 2f0a movel %a2,%sp@-
4bb68: 246e 0008 moveal %fp@(8),%a2
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
4bb6c: 4a39 0006 1768 tstb 61768 <bdbuf_cache+0x84>
4bb72: 6726 beqs 4bb9a <rtems_bdbuf_release+0x38> <== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
4bb74: 4a8a tstl %a2
4bb76: 6726 beqs 4bb9e <rtems_bdbuf_release+0x3c> <== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
4bb78: 4eba e35e jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4bb7c: 202a 0022 movel %a2@(34),%d0
4bb80: 7204 moveq #4,%d1
4bb82: b280 cmpl %d0,%d1
4bb84: 6766 beqs 4bbec <rtems_bdbuf_release+0x8a>
4bb86: 650a bcss 4bb92 <rtems_bdbuf_release+0x30>
4bb88: 123c 0003 moveb #3,%d1
4bb8c: b280 cmpl %d0,%d1
4bb8e: 6664 bnes 4bbf4 <rtems_bdbuf_release+0x92> <== NEVER TAKEN
4bb90: 6010 bras 4bba2 <rtems_bdbuf_release+0x40>
4bb92: 7206 moveq #6,%d1
4bb94: b280 cmpl %d0,%d1
4bb96: 655c bcss 4bbf4 <rtems_bdbuf_release+0x92> <== NEVER TAKEN
4bb98: 6042 bras 4bbdc <rtems_bdbuf_release+0x7a>
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4bb9a: 7016 moveq #22,%d0 <== NOT EXECUTED
4bb9c: 6066 bras 4bc04 <rtems_bdbuf_release+0xa2> <== NOT EXECUTED
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
4bb9e: 7009 moveq #9,%d0 <== NOT EXECUTED
4bba0: 6062 bras 4bc04 <rtems_bdbuf_release+0xa2> <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4bba2: 206a 002a moveal %a2@(42),%a0
4bba6: 53a8 000c subql #1,%a0@(12)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4bbaa: 7002 moveq #2,%d0
4bbac: 2540 0022 movel %d0,%a2@(34)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4bbb0: 2f0a movel %a2,%sp@-
4bbb2: 4879 0006 1724 pea 61724 <bdbuf_cache+0x40>
4bbb8: 4eb9 0004 71e4 jsr 471e4 <_Chain_Append>
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
4bbbe: 202a 0026 movel %a2@(38),%d0
4bbc2: 508f addql #8,%sp
4bbc4: 41fa e780 lea %pc@(4a346 <rtems_bdbuf_wake>),%a0
4bbc8: 6708 beqs 4bbd2 <rtems_bdbuf_release+0x70>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4bbca: 4879 0006 1748 pea 61748 <bdbuf_cache+0x64>
4bbd0: 6006 bras 4bbd8 <rtems_bdbuf_release+0x76>
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4bbd2: 4879 0006 1758 pea 61758 <bdbuf_cache+0x74>
4bbd8: 4e90 jsr %a0@
4bbda: 6006 bras 4bbe2 <rtems_bdbuf_release+0x80>
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4bbdc: 2f0a movel %a2,%sp@-
4bbde: 4eba ec34 jsr %pc@(4a814 <rtems_bdbuf_discard_buffer_after_access>)
break;
4bbe2: 588f addql #4,%sp
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4bbe4: 4eba e4a6 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
return RTEMS_SUCCESSFUL;
4bbe8: 4280 clrl %d0
4bbea: 6018 bras 4bc04 <rtems_bdbuf_release+0xa2>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
4bbec: 2f0a movel %a2,%sp@-
4bbee: 4eba e782 jsr %pc@(4a372 <rtems_bdbuf_add_to_modified_list_after_access>)
4bbf2: 60ee bras 4bbe2 <rtems_bdbuf_release+0x80>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
4bbf4: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4bbf8: 2f3c 4200 001c movel #1107296284,%sp@- <== NOT EXECUTED
4bbfe: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bc00: 4eba e32e jsr %pc@(49f30 <rtems_bdbuf_fatal>) <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
4bc04: 246e fffc moveal %fp@(-4),%a2
4bc08: 4e5e unlk %fp <== NOT EXECUTED
0004a0d8 <rtems_bdbuf_release_disk>:
return RTEMS_SUCCESSFUL;
}
static void
rtems_bdbuf_release_disk (rtems_disk_device *dd)
{
4a0d8: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_disk_release (dd);
4a0dc: 2f2e 0008 movel %fp@(8),%sp@-
4a0e0: 4eb9 0004 297a jsr 4297a <rtems_disk_release>
if (sc != RTEMS_SUCCESSFUL)
4a0e6: 588f addql #4,%sp
4a0e8: 4a80 tstl %d0
4a0ea: 670c beqs 4a0f8 <rtems_bdbuf_release_disk+0x20> <== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_DISK_REL);
4a0ec: 2f3c 4200 001f movel #1107296287,%sp@- <== NOT EXECUTED
4a0f2: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
4a0f8: 4e5e unlk %fp <== NOT EXECUTED
0004bc0c <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
4bc0c: 4e56 0000 linkw %fp,#0
4bc10: 2f0a movel %a2,%sp@-
4bc12: 246e 0008 moveal %fp@(8),%a2
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
4bc16: 4a39 0006 1768 tstb 61768 <bdbuf_cache+0x84>
4bc1c: 6724 beqs 4bc42 <rtems_bdbuf_release_modified+0x36><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
4bc1e: 4a8a tstl %a2
4bc20: 6724 beqs 4bc46 <rtems_bdbuf_release_modified+0x3a><== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
4bc22: 4eba e2b4 jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4bc26: 202a 0022 movel %a2@(34),%d0
4bc2a: 7203 moveq #3,%d1
4bc2c: b280 cmpl %d0,%d1
4bc2e: 6232 bhis 4bc62 <rtems_bdbuf_release_modified+0x56><== NEVER TAKEN
4bc30: 123c 0005 moveb #5,%d1
4bc34: b280 cmpl %d0,%d1
4bc36: 6412 bccs 4bc4a <rtems_bdbuf_release_modified+0x3e>
4bc38: 123c 0006 moveb #6,%d1
4bc3c: b280 cmpl %d0,%d1
4bc3e: 6622 bnes 4bc62 <rtems_bdbuf_release_modified+0x56><== NEVER TAKEN
4bc40: 6010 bras 4bc52 <rtems_bdbuf_release_modified+0x46>
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4bc42: 7016 moveq #22,%d0 <== NOT EXECUTED
4bc44: 602c bras 4bc72 <rtems_bdbuf_release_modified+0x66><== NOT EXECUTED
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
4bc46: 7009 moveq #9,%d0 <== NOT EXECUTED
4bc48: 6028 bras 4bc72 <rtems_bdbuf_release_modified+0x66><== NOT EXECUTED
switch (bd->state)
{
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
4bc4a: 2f0a movel %a2,%sp@-
4bc4c: 4eba e724 jsr %pc@(4a372 <rtems_bdbuf_add_to_modified_list_after_access>)
4bc50: 6006 bras 4bc58 <rtems_bdbuf_release_modified+0x4c>
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4bc52: 2f0a movel %a2,%sp@-
4bc54: 4eba ebbe jsr %pc@(4a814 <rtems_bdbuf_discard_buffer_after_access>)
break;
4bc58: 588f addql #4,%sp
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4bc5a: 4eba e430 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
return RTEMS_SUCCESSFUL;
4bc5e: 4280 clrl %d0
4bc60: 6010 bras 4bc72 <rtems_bdbuf_release_modified+0x66>
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
4bc62: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4bc66: 2f3c 4200 0004 movel #1107296260,%sp@- <== NOT EXECUTED
4bc6c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bc6e: 4eba e2c0 jsr %pc@(49f30 <rtems_bdbuf_fatal>) <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
4bc72: 246e fffc moveal %fp@(-4),%a2
4bc76: 4e5e unlk %fp <== NOT EXECUTED
0004a4e8 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
4a4e8: 4e56 ff58 linkw %fp,#-168
4a4ec: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4a4f0: 266e 0008 moveal %fp@(8),%a3
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
4a4f4: 280e movel %fp,%d4
4a4f6: 0684 ffff ff80 addil #-128,%d4
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
4a4fc: 2a2b 001a movel %a3@(26),%d5
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
4a500: 242b 0012 movel %a3@(18),%d2
4a504: 262b 0016 movel %a3@(22),%d3
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
4a508: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
4a50c: 2479 0006 1720 moveal 61720 <bdbuf_cache+0x3c>,%a2
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
4a512: 42a7 clrl %sp@-
4a514: 2f04 movel %d4,%sp@-
4a516: 4eb9 0005 0c00 jsr 50c00 <memset>
4a51c: 4fef 000c lea %sp@(12),%sp
rtems_bdbuf_buffer* r;
rtems_bdbuf_buffer* s;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
4a520: 2244 moveal %d4,%a1
4a522: 6040 bras 4a564 <rtems_bdbuf_remove_from_tree+0x7c>
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4a524: 22ca movel %a2,%a1@+
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
4a526: 202a 0012 movel %a2@(18),%d0
4a52a: 222a 0016 movel %a2@(22),%d1
4a52e: 2c00 movel %d0,%d6
4a530: 2e01 movel %d1,%d7
4a532: 9e83 subl %d3,%d7
4a534: 9d82 subxl %d2,%d6
4a536: 6512 bcss 4a54a <rtems_bdbuf_remove_from_tree+0x62><== NEVER TAKEN
4a538: 2c00 movel %d0,%d6
4a53a: 2e01 movel %d1,%d7
4a53c: 9e83 subl %d3,%d7
4a53e: 9d82 subxl %d2,%d6
4a540: 6618 bnes 4a55a <rtems_bdbuf_remove_from_tree+0x72><== NEVER TAKEN
4a542: 202a 001a movel %a2@(26),%d0
4a546: ba80 cmpl %d0,%d5
4a548: 630c blss 4a556 <rtems_bdbuf_remove_from_tree+0x6e>
{
p->avl.cache = 1;
4a54a: 7e01 moveq #1,%d7
4a54c: 1547 0010 moveb %d7,%a2@(16)
p = p->avl.right;
4a550: 246a 000c moveal %a2@(12),%a2
4a554: 600e bras 4a564 <rtems_bdbuf_remove_from_tree+0x7c>
}
else if ((p->dev != dev) || (p->block != block))
4a556: ba80 cmpl %d0,%d5
4a558: 6714 beqs 4a56e <rtems_bdbuf_remove_from_tree+0x86>
{
p->avl.cache = -1;
4a55a: 50c0 st %d0
4a55c: 1540 0010 moveb %d0,%a2@(16)
p = p->avl.left;
4a560: 246a 0008 moveal %a2@(8),%a2
4a564: 2809 movel %a1,%d4
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
4a566: 4a8a tstl %a2
4a568: 66ba bnes 4a524 <rtems_bdbuf_remove_from_tree+0x3c><== ALWAYS TAKEN
4a56a: 6000 024e braw 4a7ba <rtems_bdbuf_remove_from_tree+0x2d2><== NOT EXECUTED
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
4a56e: 200e movel %fp,%d0
4a570: 0680 ffff ff80 addil #-128,%d0
4a576: b084 cmpl %d4,%d0
4a578: 6406 bccs 4a580 <rtems_bdbuf_remove_from_tree+0x98>
{
p = *(buf_prev - 1);
4a57a: 2429 fff8 movel %a1@(-8),%d2
4a57e: 6002 bras 4a582 <rtems_bdbuf_remove_from_tree+0x9a>
}
else
{
p = NULL;
4a580: 4282 clrl %d2
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
4a582: 206a 000c moveal %a2@(12),%a0
4a586: 4a88 tstl %a0
4a588: 6610 bnes 4a59a <rtems_bdbuf_remove_from_tree+0xb2>
{
r = q->avl.left;
4a58a: 206a 0008 moveal %a2@(8),%a0
if (r != NULL)
4a58e: 4a88 tstl %a0
4a590: 676c beqs 4a5fe <rtems_bdbuf_remove_from_tree+0x116>
{
r->avl.bal = 0;
4a592: 4201 clrb %d1
4a594: 1141 0011 moveb %d1,%a0@(17)
4a598: 6064 bras 4a5fe <rtems_bdbuf_remove_from_tree+0x116>
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
4a59a: 4aa8 0008 tstl %a0@(8)
4a59e: 6708 beqs 4a5a8 <rtems_bdbuf_remove_from_tree+0xc0>
4a5a0: 2648 moveal %a0,%a3
4a5a2: 2008 movel %a0,%d0
4a5a4: 2809 movel %a1,%d4
4a5a6: 602a bras 4a5d2 <rtems_bdbuf_remove_from_tree+0xea>
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
4a5a8: 2348 fffc movel %a0,%a1@(-4)
4a5ac: 2809 movel %a1,%d4
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
4a5ae: 216a 0008 0008 movel %a2@(8),%a0@(8)
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
4a5b4: 7601 moveq #1,%d3
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
4a5b6: 116a 0011 0011 moveb %a2@(17),%a0@(17)
r->avl.cache = 1;
4a5bc: 1143 0010 moveb %d3,%a0@(16)
4a5c0: 603c bras 4a5fe <rtems_bdbuf_remove_from_tree+0x116>
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
4a5c2: 2844 moveal %d4,%a4
4a5c4: 5884 addql #4,%d4
s = r->avl.left;
r->avl.cache = -1;
4a5c6: 50c0 st %d0
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
4a5c8: 28cb movel %a3,%a4@+
s = r->avl.left;
r->avl.cache = -1;
4a5ca: 1740 0010 moveb %d0,%a3@(16)
4a5ce: 200b movel %a3,%d0
4a5d0: 2641 moveal %d1,%a3
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
4a5d2: 222b 0008 movel %a3@(8),%d1
4a5d6: 66ea bnes 4a5c2 <rtems_bdbuf_remove_from_tree+0xda>
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
4a5d8: 2840 moveal %d0,%a4
4a5da: 4beb 000c lea %a3@(12),%a5
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
4a5de: 276a 0008 0008 movel %a2@(8),%a3@(8)
r->avl.left = s->avl.right;
4a5e4: 2955 0008 movel %a5@,%a4@(8)
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
4a5e8: 7001 moveq #1,%d0
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
4a5ea: 176a 0011 0011 moveb %a2@(17),%a3@(17)
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
4a5f0: 2748 000c movel %a0,%a3@(12)
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
*t = q = s;
4a5f4: 204b moveal %a3,%a0
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
4a5f6: 1740 0010 moveb %d0,%a3@(16)
*t = q = s;
4a5fa: 234b fffc movel %a3,%a1@(-4)
}
}
if (p != NULL)
4a5fe: 4a82 tstl %d2
4a600: 672a beqs 4a62c <rtems_bdbuf_remove_from_tree+0x144>
{
if (p->avl.cache == -1)
4a602: 2242 moveal %d2,%a1
4a604: 72ff moveq #-1,%d1
4a606: 1029 0010 moveb %a1@(16),%d0
4a60a: 49c0 extbl %d0
4a60c: b280 cmpl %d0,%d1
4a60e: 6614 bnes 4a624 <rtems_bdbuf_remove_from_tree+0x13c>
{
p->avl.left = q;
4a610: 2348 0008 movel %a0,%a1@(8)
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
4a614: 200e movel %fp,%d0
4a616: 0680 ffff ff80 addil #-128,%d0
4a61c: b084 cmpl %d4,%d0
4a61e: 6514 bcss 4a634 <rtems_bdbuf_remove_from_tree+0x14c>
4a620: 6000 01a8 braw 4a7ca <rtems_bdbuf_remove_from_tree+0x2e2>
{
p->avl.left = q;
}
else
{
p->avl.right = q;
4a624: 2242 moveal %d2,%a1
4a626: 2348 000c movel %a0,%a1@(12)
4a62a: 60e8 bras 4a614 <rtems_bdbuf_remove_from_tree+0x12c>
}
}
else
{
*root = q;
4a62c: 23c8 0006 1720 movel %a0,61720 <bdbuf_cache+0x3c>
4a632: 60e0 bras 4a614 <rtems_bdbuf_remove_from_tree+0x12c>
4a634: 2844 moveal %d4,%a4
default:
break;
}
}
if (buf_prev > buf_stack)
4a636: 2400 movel %d0,%d2
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
4a638: 206c fffc moveal %a4@(-4),%a0
else
{
break;
}
if (p->avl.cache == -1)
4a63c: 76ff moveq #-1,%d3
4a63e: 1228 0010 moveb %a0@(16),%d1
4a642: 1028 0011 moveb %a0@(17),%d0
4a646: 49c1 extbl %d1
4a648: b681 cmpl %d1,%d3
4a64a: 6600 009e bnew 4a6ea <rtems_bdbuf_remove_from_tree+0x202>
{
/* rebalance left branch */
switch (p->avl.bal)
4a64e: 4a00 tstb %d0
4a650: 6718 beqs 4a66a <rtems_bdbuf_remove_from_tree+0x182>
4a652: 49c0 extbl %d0
4a654: 7c01 moveq #1,%d6
4a656: bc80 cmpl %d0,%d6
4a658: 6718 beqs 4a672 <rtems_bdbuf_remove_from_tree+0x18a>
4a65a: b680 cmpl %d0,%d3
4a65c: 6600 0124 bnew 4a782 <rtems_bdbuf_remove_from_tree+0x29a>
{
case -1:
p->avl.bal = 0;
4a660: 4207 clrb %d7
4a662: 1147 0011 moveb %d7,%a0@(17)
4a666: 6000 011a braw 4a782 <rtems_bdbuf_remove_from_tree+0x29a>
break;
case 0:
p->avl.bal = 1;
4a66a: 7001 moveq #1,%d0
4a66c: 1140 0011 moveb %d0,%a0@(17)
4a670: 6020 bras 4a692 <rtems_bdbuf_remove_from_tree+0x1aa>
modified = false;
break;
case +1:
p1 = p->avl.right;
4a672: 2268 000c moveal %a0@(12),%a1
if (p1->avl.bal >= 0) /* simple RR-turn */
4a676: 1229 0011 moveb %a1@(17),%d1
4a67a: 6d2a blts 4a6a6 <rtems_bdbuf_remove_from_tree+0x1be>
{
p->avl.right = p1->avl.left;
4a67c: 2169 0008 000c movel %a1@(8),%a0@(12)
p1->avl.left = p;
4a682: 2348 0008 movel %a0,%a1@(8)
if (p1->avl.bal == 0)
4a686: 4a01 tstb %d1
4a688: 660e bnes 4a698 <rtems_bdbuf_remove_from_tree+0x1b0>
{
p1->avl.bal = -1;
4a68a: 50c1 st %d1
4a68c: 1341 0011 moveb %d1,%a1@(17)
4a690: 2049 moveal %a1,%a0
modified = false;
4a692: 4200 clrb %d0
4a694: 6000 00ee braw 4a784 <rtems_bdbuf_remove_from_tree+0x29c>
}
else
{
p->avl.bal = 0;
4a698: 4203 clrb %d3
4a69a: 1143 0011 moveb %d3,%a0@(17)
p1->avl.bal = 0;
4a69e: 1343 0011 moveb %d3,%a1@(17)
4a6a2: 6000 0098 braw 4a73c <rtems_bdbuf_remove_from_tree+0x254>
}
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
4a6a6: 2469 0008 moveal %a1@(8),%a2
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4a6aa: 7c01 moveq #1,%d6
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4a6ac: 7eff moveq #-1,%d7
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4a6ae: 102a 0011 moveb %a2@(17),%d0
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4a6b2: 236a 000c 0008 movel %a2@(12),%a1@(8)
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4a6b8: 49c0 extbl %d0
4a6ba: bc80 cmpl %d0,%d6
4a6bc: 57c0 seq %d0
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
4a6be: 2549 000c movel %a1,%a2@(12)
p->avl.right = p2->avl.left;
4a6c2: 216a 0008 000c movel %a2@(8),%a0@(12)
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4a6c8: 1140 0011 moveb %d0,%a0@(17)
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
4a6cc: 2548 0008 movel %a0,%a2@(8)
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4a6d0: 102a 0011 moveb %a2@(17),%d0
4a6d4: 49c0 extbl %d0
4a6d6: be80 cmpl %d0,%d7
4a6d8: 56c0 sne %d0
4a6da: 5280 addql #1,%d0
4a6dc: 1340 0011 moveb %d0,%a1@(17)
p = p2;
p2->avl.bal = 0;
4a6e0: 4200 clrb %d0
4a6e2: 1540 0011 moveb %d0,%a2@(17)
4a6e6: 6000 0098 braw 4a780 <rtems_bdbuf_remove_from_tree+0x298>
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4a6ea: 4a00 tstb %d0
4a6ec: 671a beqs 4a708 <rtems_bdbuf_remove_from_tree+0x220>
4a6ee: 49c0 extbl %d0
4a6f0: 7201 moveq #1,%d1
4a6f2: b280 cmpl %d0,%d1
4a6f4: 670a beqs 4a700 <rtems_bdbuf_remove_from_tree+0x218>
4a6f6: 76ff moveq #-1,%d3
4a6f8: b680 cmpl %d0,%d3
4a6fa: 6600 0086 bnew 4a782 <rtems_bdbuf_remove_from_tree+0x29a>
4a6fe: 6010 bras 4a710 <rtems_bdbuf_remove_from_tree+0x228>
{
case +1:
p->avl.bal = 0;
4a700: 4206 clrb %d6
4a702: 1146 0011 moveb %d6,%a0@(17)
4a706: 607a bras 4a782 <rtems_bdbuf_remove_from_tree+0x29a>
break;
case 0:
p->avl.bal = -1;
4a708: 50c7 st %d7
4a70a: 1147 0011 moveb %d7,%a0@(17)
4a70e: 6082 bras 4a692 <rtems_bdbuf_remove_from_tree+0x1aa>
modified = false;
break;
case -1:
p1 = p->avl.left;
4a710: 2268 0008 moveal %a0@(8),%a1
if (p1->avl.bal <= 0) /* simple LL-turn */
4a714: 1229 0011 moveb %a1@(17),%d1
4a718: 6e26 bgts 4a740 <rtems_bdbuf_remove_from_tree+0x258>
{
p->avl.left = p1->avl.right;
4a71a: 2169 000c 0008 movel %a1@(12),%a0@(8)
p1->avl.right = p;
4a720: 2348 000c movel %a0,%a1@(12)
if (p1->avl.bal == 0)
4a724: 4a01 tstb %d1
4a726: 660a bnes 4a732 <rtems_bdbuf_remove_from_tree+0x24a>
{
p1->avl.bal = 1;
4a728: 7001 moveq #1,%d0
4a72a: 1340 0011 moveb %d0,%a1@(17)
4a72e: 6000 ff60 braw 4a690 <rtems_bdbuf_remove_from_tree+0x1a8>
modified = false;
}
else
{
p->avl.bal = 0;
4a732: 4201 clrb %d1
4a734: 1141 0011 moveb %d1,%a0@(17)
p1->avl.bal = 0;
4a738: 1341 0011 moveb %d1,%a1@(17)
4a73c: 2049 moveal %a1,%a0
4a73e: 6042 bras 4a782 <rtems_bdbuf_remove_from_tree+0x29a>
}
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
4a740: 2469 000c moveal %a1@(12),%a2
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4a744: 76ff moveq #-1,%d3
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4a746: 7c01 moveq #1,%d6
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4a748: 102a 0011 moveb %a2@(17),%d0
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4a74c: 236a 0008 000c movel %a2@(8),%a1@(12)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4a752: 49c0 extbl %d0
4a754: b680 cmpl %d0,%d3
4a756: 56c0 sne %d0
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
4a758: 2549 0008 movel %a1,%a2@(8)
p->avl.left = p2->avl.right;
4a75c: 216a 000c 0008 movel %a2@(12),%a0@(8)
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4a762: 5280 addql #1,%d0
4a764: 1140 0011 moveb %d0,%a0@(17)
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
4a768: 2548 000c movel %a0,%a2@(12)
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4a76c: 102a 0011 moveb %a2@(17),%d0
p = p2;
p2->avl.bal = 0;
4a770: 4207 clrb %d7
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4a772: 49c0 extbl %d0
4a774: bc80 cmpl %d0,%d6
4a776: 57c0 seq %d0
4a778: 1340 0011 moveb %d0,%a1@(17)
p = p2;
p2->avl.bal = 0;
4a77c: 1547 0011 moveb %d7,%a2@(17)
4a780: 204a moveal %a2,%a0
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4a782: 7001 moveq #1,%d0
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
4a784: 220c movel %a4,%d1
4a786: 5981 subql #4,%d1
default:
break;
}
}
if (buf_prev > buf_stack)
4a788: b481 cmpl %d1,%d2
4a78a: 641c bccs 4a7a8 <rtems_bdbuf_remove_from_tree+0x2c0>
{
q = *(buf_prev - 1);
4a78c: 226c fff8 moveal %a4@(-8),%a1
if (q->avl.cache == -1)
4a790: 76ff moveq #-1,%d3
4a792: 1229 0010 moveb %a1@(16),%d1
4a796: 49c1 extbl %d1
4a798: b681 cmpl %d1,%d3
4a79a: 6606 bnes 4a7a2 <rtems_bdbuf_remove_from_tree+0x2ba>
{
q->avl.left = p;
4a79c: 2348 0008 movel %a0,%a1@(8)
4a7a0: 600e bras 4a7b0 <rtems_bdbuf_remove_from_tree+0x2c8>
}
else
{
q->avl.right = p;
4a7a2: 2348 000c movel %a0,%a1@(12)
4a7a6: 6008 bras 4a7b0 <rtems_bdbuf_remove_from_tree+0x2c8>
}
}
else
{
*root = p;
4a7a8: 23c8 0006 1720 movel %a0,61720 <bdbuf_cache+0x3c>
4a7ae: 601a bras 4a7ca <rtems_bdbuf_remove_from_tree+0x2e2>
4a7b0: 598c subql #4,%a4
*root = q;
}
modified = true;
while (modified)
4a7b2: 4a00 tstb %d0
4a7b4: 6600 fe82 bnew 4a638 <rtems_bdbuf_remove_from_tree+0x150>
4a7b8: 6010 bras 4a7ca <rtems_bdbuf_remove_from_tree+0x2e2>
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
4a7ba: 202b 0022 movel %a3@(34),%d0 <== NOT EXECUTED
4a7be: 2f3c 4200 0009 movel #1107296265,%sp@- <== NOT EXECUTED
4a7c4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4a7c6: 4eba f768 jsr %pc@(49f30 <rtems_bdbuf_fatal>) <== NOT EXECUTED
}
4a7ca: 4cee 3cfc ff58 moveml %fp@(-168),%d2-%d7/%a2-%a5
4a7d0: 4e5e unlk %fp <== NOT EXECUTED
0004a7d4 <rtems_bdbuf_remove_from_tree_and_lru_list>:
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
4a7d4: 4e56 0000 linkw %fp,#0
4a7d8: 2f0a movel %a2,%sp@-
4a7da: 246e 0008 moveal %fp@(8),%a2
switch (bd->state)
4a7de: 202a 0022 movel %a2@(34),%d0
4a7e2: 6720 beqs 4a804 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
4a7e4: 7202 moveq #2,%d1
4a7e6: b280 cmpl %d0,%d1
4a7e8: 660a bnes 4a7f4 <rtems_bdbuf_remove_from_tree_and_lru_list+0x20><== NEVER TAKEN
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
4a7ea: 2f0a movel %a2,%sp@-
4a7ec: 4eba fcfa jsr %pc@(4a4e8 <rtems_bdbuf_remove_from_tree>)
break;
4a7f0: 588f addql #4,%sp
4a7f2: 6010 bras 4a804 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
4a7f4: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4a7f8: 2f3c 4200 0008 movel #1107296264,%sp@- <== NOT EXECUTED
4a7fe: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4a800: 4eba f72e jsr %pc@(49f30 <rtems_bdbuf_fatal>) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4a804: 2d4a 0008 movel %a2,%fp@(8)
}
rtems_chain_extract (&bd->link);
}
4a808: 246e fffc moveal %fp@(-4),%a2
4a80c: 4e5e unlk %fp
4a80e: 4ef9 0004 721c jmp 4721c <_Chain_Extract>
0004a1ba <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4a1ba: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
4a1be: 486e 0008 pea %fp@(8)
4a1c2: 2f3c 0000 ffff movel #65535,%sp@-
4a1c8: 2f2e 0008 movel %fp@(8),%sp@-
4a1cc: 4eb9 0004 dfd4 jsr 4dfd4 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
4a1d2: 4fef 000c lea %sp@(12),%sp
4a1d6: 4a80 tstl %d0
4a1d8: 670c beqs 4a1e6 <rtems_bdbuf_restore_preemption+0x2c><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
4a1da: 2f3c 4200 0011 movel #1107296273,%sp@- <== NOT EXECUTED
4a1e0: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
4a1e6: 4e5e unlk %fp <== NOT EXECUTED
00049f48 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
49f48: 4e56 ffcc linkw %fp,#-52
49f4c: 202e 000c movel %fp@(12),%d0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
49f50: 2040 moveal %d0,%a0
49f52: 122e 0017 moveb %fp@(23),%d1
49f56: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
49f5a: 266e 0008 moveal %fp@(8),%a3
49f5e: 286e 0010 moveal %fp@(16),%a4
49f62: 2a2e 001c movel %fp@(28),%d5
49f66: 1d41 fff7 moveb %d1,%fp@(-9)
49f6a: 2458 moveal %a0@+,%a2
49f6c: 1e2e 001b moveb %fp@(27),%d7
if (!rtems_chain_is_empty (chain))
49f70: b1ca cmpal %a2,%a0
49f72: 6700 010e beqw 4a082 <rtems_bdbuf_swapout_modified_processing+0x13a>
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dev == BDBUF_INVALID_DEV))
49f76: 4a01 tstb %d1
49f78: 6718 beqs 49f92 <rtems_bdbuf_swapout_modified_processing+0x4a>
* @param update_timers If true update the timers.
* @param timer_delta It update_timers is true update the timers by this
* amount.
*/
static void
rtems_bdbuf_swapout_modified_processing (dev_t* dev,
49f7a: 2213 movel %a3@,%d1
49f7c: 74ff moveq #-1,%d2
49f7e: c2ab 0004 andl %a3@(4),%d1
49f82: b481 cmpl %d1,%d2
49f84: 57c3 seq %d3
49f86: 2803 movel %d3,%d4
49f88: 4484 negl %d4
49f8a: 1d44 fffb moveb %d4,%fp@(-5)
49f8e: 6000 00ca braw 4a05a <rtems_bdbuf_swapout_modified_processing+0x112>
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dev == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
49f92: 4201 clrb %d1
49f94: 1d41 fffb moveb %d1,%fp@(-5)
49f98: 6000 00c0 braw 4a05a <rtems_bdbuf_swapout_modified_processing+0x112>
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
49f9c: 4a2e fffb tstb %fp@(-5)
49fa0: 6622 bnes 49fc4 <rtems_bdbuf_swapout_modified_processing+0x7c>
49fa2: 4a2e fff7 tstb %fp@(-9)
49fa6: 6714 beqs 49fbc <rtems_bdbuf_swapout_modified_processing+0x74>
49fa8: 2413 movel %a3@,%d2
49faa: 262b 0004 movel %a3@(4),%d3
49fae: 202a 0012 movel %a2@(18),%d0
49fb2: 222a 0016 movel %a2@(22),%d1
49fb6: 9681 subl %d1,%d3
49fb8: 9580 subxl %d0,%d2
49fba: 6708 beqs 49fc4 <rtems_bdbuf_swapout_modified_processing+0x7c>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
49fbc: 2039 0006 1758 movel 61758 <bdbuf_cache+0x74>,%d0
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
|| rtems_bdbuf_has_buffer_waiters ())
49fc2: 6704 beqs 49fc8 <rtems_bdbuf_swapout_modified_processing+0x80>
bd->hold_timer = 0;
49fc4: 42aa 002e clrl %a2@(46)
if (bd->hold_timer)
49fc8: 202a 002e movel %a2@(46),%d0
49fcc: 6726 beqs 49ff4 <rtems_bdbuf_swapout_modified_processing+0xac>
{
if (update_timers)
49fce: 4a07 tstb %d7
49fd0: 6718 beqs 49fea <rtems_bdbuf_swapout_modified_processing+0xa2>
{
if (bd->hold_timer > timer_delta)
49fd2: 202a 002e movel %a2@(46),%d0
49fd6: ba80 cmpl %d0,%d5
49fd8: 640c bccs 49fe6 <rtems_bdbuf_swapout_modified_processing+0x9e>
bd->hold_timer -= timer_delta;
49fda: 202a 002e movel %a2@(46),%d0
49fde: 9085 subl %d5,%d0
49fe0: 2540 002e movel %d0,%a2@(46)
49fe4: 6004 bras 49fea <rtems_bdbuf_swapout_modified_processing+0xa2>
else
bd->hold_timer = 0;
49fe6: 42aa 002e clrl %a2@(46)
}
if (bd->hold_timer)
49fea: 202a 002e movel %a2@(46),%d0
49fee: 6704 beqs 49ff4 <rtems_bdbuf_swapout_modified_processing+0xac>
{
node = node->next;
49ff0: 2452 moveal %a2@,%a2
continue;
49ff2: 6078 bras 4a06c <rtems_bdbuf_swapout_modified_processing+0x124>
/*
* This assumes we can set dev_t to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dev == BDBUF_INVALID_DEV)
49ff4: 2213 movel %a3@,%d1
49ff6: 242b 0004 movel %a3@(4),%d2
49ffa: 76ff moveq #-1,%d3
49ffc: 78ff moveq #-1,%d4
49ffe: 9484 subl %d4,%d2
4a000: 9383 subxl %d3,%d1
4a002: 660e bnes 4a012 <rtems_bdbuf_swapout_modified_processing+0xca>
*dev = bd->dev;
4a004: 202a 0012 movel %a2@(18),%d0
4a008: 222a 0016 movel %a2@(22),%d1
4a00c: 2680 movel %d0,%a3@
4a00e: 2741 0004 movel %d1,%a3@(4)
4a012: 2412 movel %a2@,%d2
if (bd->dev == *dev)
4a014: 262a 0012 movel %a2@(18),%d3
4a018: 282a 0016 movel %a2@(22),%d4
4a01c: 2013 movel %a3@,%d0
4a01e: 222b 0004 movel %a3@(4),%d1
4a022: 9881 subl %d1,%d4
4a024: 9780 subxl %d0,%d3
4a026: 6656 bnes 4a07e <rtems_bdbuf_swapout_modified_processing+0x136><== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a028: 7209 moveq #9,%d1
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4a02a: 2046 moveal %d6,%a0
4a02c: 2541 0022 movel %d1,%a2@(34)
4a030: 2f0a movel %a2,%sp@-
4a032: 4e90 jsr %a0@
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract (node);
tnode = tnode->previous;
4a034: 206c 0008 moveal %a4@(8),%a0
while (node && !rtems_chain_is_head (transfer, tnode))
4a038: 588f addql #4,%sp
4a03a: 6014 bras 4a050 <rtems_bdbuf_swapout_modified_processing+0x108>
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
4a03c: 2028 001a movel %a0@(26),%d0
4a040: b0aa 001a cmpl %a2@(26),%d0
4a044: 6406 bccs 4a04c <rtems_bdbuf_swapout_modified_processing+0x104>
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
4a046: 2f0a movel %a2,%sp@-
4a048: 2f08 movel %a0,%sp@-
4a04a: 602e bras 4a07a <rtems_bdbuf_swapout_modified_processing+0x132>
{
rtems_chain_insert (tnode, node);
node = NULL;
}
else
tnode = tnode->previous;
4a04c: 2068 0004 moveal %a0@(4),%a0
rtems_chain_extract (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
4a050: 4a8a tstl %a2
4a052: 672a beqs 4a07e <rtems_bdbuf_swapout_modified_processing+0x136><== NEVER TAKEN
4a054: b9c8 cmpal %a0,%a4
4a056: 66e4 bnes 4a03c <rtems_bdbuf_swapout_modified_processing+0xf4>
4a058: 601c bras 4a076 <rtems_bdbuf_swapout_modified_processing+0x12e>
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
4a05a: 5880 addql #4,%d0
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4a05c: 2c3c 0004 721c movel #291356,%d6
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4a062: 4bf9 0004 e3cc lea 4e3cc <_Chain_Insert>,%a5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
4a068: 2d40 fffc movel %d0,%fp@(-4)
if (sync_active && (*dev == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
4a06c: b5ee fffc cmpal %fp@(-4),%a2
4a070: 6600 ff2a bnew 49f9c <rtems_bdbuf_swapout_modified_processing+0x54>
4a074: 600c bras 4a082 <rtems_bdbuf_swapout_modified_processing+0x13a>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4a076: 2f0a movel %a2,%sp@-
4a078: 2f0c movel %a4,%sp@-
4a07a: 4e95 jsr %a5@
4a07c: 508f addql #8,%sp
}
if (node)
rtems_chain_prepend (transfer, node);
node = next_node;
4a07e: 2442 moveal %d2,%a2
4a080: 60ea bras 4a06c <rtems_bdbuf_swapout_modified_processing+0x124>
{
node = node->next;
}
}
}
}
4a082: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5
4a088: 4e5e unlk %fp <== NOT EXECUTED
0004ac48 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
4ac48: 4e56 ffac linkw %fp,#-84
4ac4c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
4ac50: 2639 0005 e9f8 movel 5e9f8 <rtems_bdbuf_configuration+0xc>,%d3
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4ac56: 45fa f63e lea %pc@(4a296 <rtems_bdbuf_swapout_writereq_alloc>),%a2
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4ac5a: 243c 0000 03e8 movel #1000,%d2
4ac60: 4c03 2800 mulsl %d3,%d2
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4ac64: 4284 clrl %d4
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4ac66: 2e3c 0004 391c movel #276764,%d7
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4ac6c: 2c3c 0004 71e4 movel #291300,%d6
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4ac72: 2a4a moveal %a2,%a5
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ac74: 49f9 0004 6880 lea 46880 <rtems_task_create>,%a4
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
sc = rtems_task_start (worker->id,
4ac7a: 47f9 0004 6ab4 lea 46ab4 <rtems_task_start>,%a3
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4ac80: 4e92 jsr %a2@
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4ac82: 41ee ffe2 lea %fp@(-30),%a0
4ac86: 2d40 fff4 movel %d0,%fp@(-12)
rtems_chain_initialize_empty (&transfer.bds);
transfer.dev = BDBUF_INVALID_DEV;
4ac8a: 70ff moveq #-1,%d0
4ac8c: 72ff moveq #-1,%d1
4ac8e: 2d48 ffde movel %a0,%fp@(-34)
head->previous = NULL;
tail->previous = head;
4ac92: 41ee ffde lea %fp@(-34),%a0
4ac96: 2d40 ffea movel %d0,%fp@(-22)
4ac9a: 2d41 ffee movel %d1,%fp@(-18)
4ac9e: 2d48 ffe6 movel %a0,%fp@(-26)
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4aca2: 41f9 0006 0528 lea 60528 <Configuration+0xc>,%a0
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&transfer.bds);
transfer.dev = BDBUF_INVALID_DEV;
transfer.syncing = false;
4aca8: 4201 clrb %d1
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4acaa: 42ae ffe2 clrl %fp@(-30)
4acae: 1d41 fff2 moveb %d1,%fp@(-14)
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4acb2: 4c50 2002 remul %a0@,%d2,%d2
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
4acb6: 4eba f220 jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
(bdbuf_config.swapout_priority ?
4acba: 2a39 0005 e9f4 movel 5e9f4 <rtems_bdbuf_configuration+0x8>,%d5
4acc0: 6000 00b2 braw 4ad74 <rtems_bdbuf_swapout_task+0x12c>
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4acc4: 4878 002c pea 2c <OPER2+0x18> <== NOT EXECUTED
4acc8: 2047 moveal %d7,%a0 <== NOT EXECUTED
4acca: 4e90 jsr %a0@ <== NOT EXECUTED
if (!worker)
4accc: 588f addql #4,%sp <== NOT EXECUTED
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4acce: 2440 moveal %d0,%a2 <== NOT EXECUTED
if (!worker)
4acd0: 4a80 tstl %d0 <== NOT EXECUTED
4acd2: 6608 bnes 4acdc <rtems_bdbuf_swapout_task+0x94> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
4acd4: 2f3c 4200 0015 movel #1107296277,%sp@- <== NOT EXECUTED
4acda: 6074 bras 4ad50 <rtems_bdbuf_swapout_task+0x108> <== NOT EXECUTED
4acdc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4acde: 4879 0006 16ea pea 616ea <bdbuf_cache+0x6> <== NOT EXECUTED
4ace4: 2046 moveal %d6,%a0 <== NOT EXECUTED
4ace6: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
4ace8: 7001 moveq #1,%d0 <== NOT EXECUTED
4acea: 1540 000c moveb %d0,%a2@(12) <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4acee: 4e95 jsr %a5@ <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4acf0: 508f addql #8,%sp <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4acf2: 41ea 0012 lea %a2@(18),%a0 <== NOT EXECUTED
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4acf6: 2540 0024 movel %d0,%a2@(36) <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
4acfa: 70ff moveq #-1,%d0 <== NOT EXECUTED
4acfc: 72ff moveq #-1,%d1 <== NOT EXECUTED
4acfe: 2548 000e movel %a0,%a2@(14) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4ad02: 41ea 000e lea %a2@(14),%a0 <== NOT EXECUTED
4ad06: 2540 001a movel %d0,%a2@(26) <== NOT EXECUTED
4ad0a: 2541 001e movel %d1,%a2@(30) <== NOT EXECUTED
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ad0e: 220a movel %a2,%d1 <== NOT EXECUTED
4ad10: 5081 addql #8,%d1 <== NOT EXECUTED
(bdbuf_config.swapout_priority ?
4ad12: 2005 movel %d5,%d0 <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4ad14: 42aa 0012 clrl %a2@(18) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4ad18: 2548 0016 movel %a0,%a2@(22) <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ad1c: 4a85 tstl %d5 <== NOT EXECUTED
4ad1e: 6602 bnes 4ad22 <rtems_bdbuf_swapout_task+0xda> <== NOT EXECUTED
4ad20: 700f moveq #15,%d0 <== NOT EXECUTED
4ad22: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4ad24: 42a7 clrl %sp@- <== NOT EXECUTED
4ad26: 4878 0400 pea 400 <D_BIAS+0x2> <== NOT EXECUTED
4ad2a: 4878 2000 pea 2000 <D_MAX_EXP+0x1801> <== NOT EXECUTED
4ad2e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
4ad30: 2004 movel %d4,%d0 <== NOT EXECUTED
4ad32: 0680 0000 0061 addil #97,%d0 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ad38: 0080 4244 6f00 oril #1111781120,%d0 <== NOT EXECUTED
4ad3e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ad40: 4e94 jsr %a4@ <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT),
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
4ad42: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4ad46: 4a80 tstl %d0 <== NOT EXECUTED
4ad48: 670c beqs 4ad56 <rtems_bdbuf_swapout_task+0x10e> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
4ad4a: 2f3c 4200 0016 movel #1107296278,%sp@- <== NOT EXECUTED
4ad50: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
sc = rtems_task_start (worker->id,
4ad56: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ad58: 487a 0208 pea %pc@(4af62 <rtems_bdbuf_swapout_worker_task>)<== NOT EXECUTED
4ad5c: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4ad60: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
4ad62: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4ad66: 4a80 tstl %d0 <== NOT EXECUTED
4ad68: 6708 beqs 4ad72 <rtems_bdbuf_swapout_task+0x12a> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
4ad6a: 2f3c 4200 0017 movel #1107296279,%sp@- <== NOT EXECUTED
4ad70: 60de bras 4ad50 <rtems_bdbuf_swapout_task+0x108> <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4ad72: 5284 addql #1,%d4 <== NOT EXECUTED
4ad74: b8b9 0005 ea00 cmpl 5ea00 <rtems_bdbuf_configuration+0x14>,%d4
4ad7a: 6500 ff48 bcsw 4acc4 <rtems_bdbuf_swapout_task+0x7c>
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
4ad7e: 45fa f30c lea %pc@(4a08c <rtems_bdbuf_unlock_cache>),%a2
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
4ad82: 49fa f154 lea %pc@(49ed8 <rtems_bdbuf_lock_cache>),%a4
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4ad86: 4bf9 0004 7244 lea 47244 <_Chain_Get>,%a5
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
4ad8c: 47fa f1ba lea %pc@(49f48 <rtems_bdbuf_swapout_modified_processing>),%a3
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
4ad90: 4e92 jsr %a2@
4ad92: 6000 0176 braw 4af0a <rtems_bdbuf_swapout_task+0x2c2>
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4ad96: 4206 clrb %d6
4ad98: 6002 bras 4ad9c <rtems_bdbuf_swapout_task+0x154>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4ad9a: 7c01 moveq #1,%d6
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
4ad9c: 4e94 jsr %a4@
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
4ad9e: 1039 0006 1712 moveb 61712 <bdbuf_cache+0x2e>,%d0
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4ada4: 0286 0000 00ff andil #255,%d6
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
4adaa: 4a00 tstb %d0
4adac: 6618 bnes 4adc6 <rtems_bdbuf_swapout_task+0x17e>
4adae: 4879 0006 16ea pea 616ea <bdbuf_cache+0x6>
4adb4: 4e95 jsr %a5@
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
if (worker)
4adb6: 588f addql #4,%sp
4adb8: 4a80 tstl %d0
4adba: 670c beqs 4adc8 <rtems_bdbuf_swapout_task+0x180> <== ALWAYS TAKEN
transfer = &worker->transfer;
4adbc: 2e00 movel %d0,%d7 <== NOT EXECUTED
4adbe: 0687 0000 000e addil #14,%d7 <== NOT EXECUTED
4adc4: 600a bras 4add0 <rtems_bdbuf_swapout_task+0x188> <== NOT EXECUTED
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
worker = NULL;
4adc6: 4280 clrl %d0
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4adc8: 2e0e movel %fp,%d7
4adca: 0687 ffff ffde addil #-34,%d7
Chain_Node *tail = _Chain_Tail( the_chain );
4add0: 2207 movel %d7,%d1
4add2: 2047 moveal %d7,%a0
4add4: 5881 addql #4,%d1
4add6: 2081 movel %d1,%a0@
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
4add8: 1239 0006 1712 moveb 61712 <bdbuf_cache+0x2e>,%d1
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
4adde: 78ff moveq #-1,%d4
4ade0: 7aff moveq #-1,%d5
head->next = tail;
head->previous = NULL;
4ade2: 42a8 0004 clrl %a0@(4)
transfer->syncing = bdbuf_cache.sync_active;
4ade6: 1141 0014 moveb %d1,%a0@(20)
/*
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
4adea: 1239 0006 1712 moveb 61712 <bdbuf_cache+0x2e>,%d1
tail->previous = head;
4adf0: 2147 0008 movel %d7,%a0@(8)
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
4adf4: 2144 000c movel %d4,%a0@(12)
4adf8: 2145 0010 movel %d5,%a0@(16)
/*
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
4adfc: 4a01 tstb %d1
4adfe: 6714 beqs 4ae14 <rtems_bdbuf_swapout_task+0x1cc>
transfer->dev = bdbuf_cache.sync_device;
4ae00: 2839 0006 1718 movel 61718 <bdbuf_cache+0x34>,%d4
4ae06: 2a39 0006 171c movel 6171c <bdbuf_cache+0x38>,%d5
4ae0c: 2144 000c movel %d4,%a0@(12)
4ae10: 2145 0010 movel %d5,%a0@(16)
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
4ae14: 2f03 movel %d3,%sp@-
4ae16: 2207 movel %d7,%d1
4ae18: 0681 0000 000c addil #12,%d1
4ae1e: 42a7 clrl %sp@-
4ae20: 4878 0001 pea 1 <ADD>
4ae24: 2f07 movel %d7,%sp@-
4ae26: 4879 0006 173c pea 6173c <bdbuf_cache+0x58>
4ae2c: 2d40 ffd8 movel %d0,%fp@(-40)
4ae30: 2f01 movel %d1,%sp@-
4ae32: 2d41 ffd4 movel %d1,%fp@(-44)
4ae36: 4e93 jsr %a3@
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
4ae38: 222e ffd4 movel %fp@(-44),%d1
4ae3c: 2f03 movel %d3,%sp@-
&bdbuf_cache.modified,
&transfer->bds,
bdbuf_cache.sync_active,
4ae3e: 1839 0006 1712 moveb 61712 <bdbuf_cache+0x2e>,%d4
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
4ae44: 2f06 movel %d6,%sp@-
4ae46: 4286 clrl %d6
4ae48: 1c04 moveb %d4,%d6
4ae4a: 2f06 movel %d6,%sp@-
4ae4c: 2f07 movel %d7,%sp@-
4ae4e: 4879 0006 1730 pea 61730 <bdbuf_cache+0x4c>
4ae54: 2f01 movel %d1,%sp@-
4ae56: 4e93 jsr %a3@
/*
* We have all the buffers that have been modified for this device so the
* cache can be unlocked because the state of each buffer has been set to
* TRANSFER.
*/
rtems_bdbuf_unlock_cache ();
4ae58: 4fef 0030 lea %sp@(48),%sp
4ae5c: 4e92 jsr %a2@
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4ae5e: 202e ffd8 movel %fp@(-40),%d0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4ae62: 2207 movel %d7,%d1
4ae64: 5881 addql #4,%d1
4ae66: 2047 moveal %d7,%a0
4ae68: b290 cmpl %a0@,%d1
4ae6a: 672e beqs 4ae9a <rtems_bdbuf_swapout_task+0x252>
{
if (worker)
4ae6c: 4a80 tstl %d0
4ae6e: 6720 beqs 4ae90 <rtems_bdbuf_swapout_task+0x248> <== ALWAYS TAKEN
{
rtems_status_code sc = rtems_event_send (worker->id,
4ae70: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4ae74: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ae76: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
4ae7a: 4eb9 0004 626c jsr 4626c <rtems_event_send> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4ae80: 508f addql #8,%sp <== NOT EXECUTED
4ae82: 4a80 tstl %d0 <== NOT EXECUTED
4ae84: 6718 beqs 4ae9e <rtems_bdbuf_swapout_task+0x256> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
4ae86: 2f3c 4200 0014 movel #1107296276,%sp@- <== NOT EXECUTED
4ae8c: 6000 fec2 braw 4ad50 <rtems_bdbuf_swapout_task+0x108> <== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
4ae90: 2f07 movel %d7,%sp@-
4ae92: 4eba fc64 jsr %pc@(4aaf8 <rtems_bdbuf_swapout_write>)
4ae96: 588f addql #4,%sp
4ae98: 6004 bras 4ae9e <rtems_bdbuf_swapout_task+0x256>
rtems_bdbuf_swapout_processing (unsigned long timer_delta,
bool update_timers,
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
4ae9a: 4200 clrb %d0
4ae9c: 6002 bras 4aea0 <rtems_bdbuf_swapout_task+0x258>
else
{
rtems_bdbuf_swapout_write (transfer);
}
transfered_buffers = true;
4ae9e: 7001 moveq #1,%d0
}
if (bdbuf_cache.sync_active && !transfered_buffers)
4aea0: 1239 0006 1712 moveb 61712 <bdbuf_cache+0x2e>,%d1
4aea6: 6732 beqs 4aeda <rtems_bdbuf_swapout_task+0x292>
4aea8: 4a00 tstb %d0
4aeaa: 6600 feea bnew 4ad96 <rtems_bdbuf_swapout_task+0x14e>
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
4aeae: 4e94 jsr %a4@
sync_requester = bdbuf_cache.sync_requester;
4aeb0: 2a39 0006 1714 movel 61714 <bdbuf_cache+0x30>,%d5
bdbuf_cache.sync_active = false;
4aeb6: 4200 clrb %d0
4aeb8: 13c0 0006 1712 moveb %d0,61712 <bdbuf_cache+0x2e>
bdbuf_cache.sync_requester = 0;
4aebe: 42b9 0006 1714 clrl 61714 <bdbuf_cache+0x30>
rtems_bdbuf_unlock_cache ();
4aec4: 4e92 jsr %a2@
if (sync_requester)
4aec6: 4a85 tstl %d5
4aec8: 6716 beqs 4aee0 <rtems_bdbuf_swapout_task+0x298> <== NEVER TAKEN
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
4aeca: 4878 0002 pea 2 <DOUBLE_FLOAT>
4aece: 2f05 movel %d5,%sp@-
4aed0: 4eb9 0004 626c jsr 4626c <rtems_event_send>
4aed6: 508f addql #8,%sp
4aed8: 6006 bras 4aee0 <rtems_bdbuf_swapout_task+0x298>
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4aeda: 4a00 tstb %d0
4aedc: 6600 feb8 bnew 4ad96 <rtems_bdbuf_swapout_task+0x14e>
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
4aee0: 486e fffc pea %fp@(-4)
4aee4: 2f02 movel %d2,%sp@-
4aee6: 42a7 clrl %sp@-
4aee8: 4878 0004 pea 4 <CONTEXT_ARG>
4aeec: 4eb9 0004 6104 jsr 46104 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
4aef2: 4fef 0010 lea %sp@(16),%sp
4aef6: 4a80 tstl %d0
4aef8: 6710 beqs 4af0a <rtems_bdbuf_swapout_task+0x2c2>
4aefa: 7206 moveq #6,%d1
4aefc: b280 cmpl %d0,%d1
4aefe: 670a beqs 4af0a <rtems_bdbuf_swapout_task+0x2c2> <== ALWAYS TAKEN
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
4af00: 2f3c 4200 0018 movel #1107296280,%sp@- <== NOT EXECUTED
4af06: 6000 fe48 braw 4ad50 <rtems_bdbuf_swapout_task+0x108> <== NOT EXECUTED
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4af0a: 1039 0006 16e8 moveb 616e8 <bdbuf_cache+0x4>,%d0
4af10: 6600 fe88 bnew 4ad9a <rtems_bdbuf_swapout_task+0x152>
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
4af14: 4eba efc2 jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4af18: 2479 0006 16ea moveal 616ea <bdbuf_cache+0x6>,%a2 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4af1e: 47f9 0004 626c lea 4626c <rtems_event_send>,%a3 <== NOT EXECUTED
4af24: 6014 bras 4af3a <rtems_bdbuf_swapout_task+0x2f2> <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
4af26: 4204 clrb %d4 <== NOT EXECUTED
4af28: 1544 000c moveb %d4,%a2@(12) <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4af2c: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4af30: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4af34: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
}
4af36: 2452 moveal %a2@,%a2 <== NOT EXECUTED
4af38: 508f addql #8,%sp <== NOT EXECUTED
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
4af3a: b5fc 0006 16ee cmpal #399086,%a2 <== NOT EXECUTED
4af40: 66e4 bnes 4af26 <rtems_bdbuf_swapout_task+0x2de> <== NOT EXECUTED
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
4af42: 4eba f148 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>) <== NOT EXECUTED
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
4af46: 2f2e fff4 movel %fp@(-12),%sp@- <== NOT EXECUTED
4af4a: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4af50: 42a7 clrl %sp@- <== NOT EXECUTED
4af52: 4eb9 0004 69a4 jsr 469a4 <rtems_task_delete> <== NOT EXECUTED
}
4af58: 4cee 3cfc ffac moveml %fp@(-84),%d2-%d7/%a2-%a5 <== NOT EXECUTED
4af5e: 4e5e unlk %fp <== NOT EXECUTED
0004af62 <rtems_bdbuf_swapout_worker_task>:
* @param arg A pointer to the worker thread's private data.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
4af62: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
4af66: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@ <== NOT EXECUTED
4af6a: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
4af6e: 283c 0004 a148 movel #303432,%d4 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
4af74: 47ea 000e lea %a2@(14),%a3 <== NOT EXECUTED
4af78: 263c 0004 aaf8 movel #305912,%d3 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4af7e: 243c 0004 9ed8 movel #302808,%d2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4af84: 4bf9 0004 71e4 lea 471e4 <_Chain_Append>,%a5 <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
4af8a: 49fa f100 lea %pc@(4a08c <rtems_bdbuf_unlock_cache>),%a4<== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4af8e: 603e bras 4afce <rtems_bdbuf_swapout_worker_task+0x6c><== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
4af90: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4af94: 2044 moveal %d4,%a0 <== NOT EXECUTED
4af96: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
4af98: 2043 moveal %d3,%a0 <== NOT EXECUTED
4af9a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4af9c: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4af9e: 2042 moveal %d2,%a0 <== NOT EXECUTED
4afa0: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
4afa2: 70ff moveq #-1,%d0 <== NOT EXECUTED
4afa4: 72ff moveq #-1,%d1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4afa6: 41ea 0012 lea %a2@(18),%a0 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
4afaa: 42aa 0012 clrl %a2@(18) <== NOT EXECUTED
4afae: 2540 001a movel %d0,%a2@(26) <== NOT EXECUTED
4afb2: 2541 001e movel %d1,%a2@(30) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4afb6: 2548 000e movel %a0,%a2@(14) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4afba: 254b 0016 movel %a3,%a2@(22) <== NOT EXECUTED
4afbe: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4afc0: 4879 0006 16ea pea 616ea <bdbuf_cache+0x6> <== NOT EXECUTED
4afc6: 4e95 jsr %a5@ <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
4afc8: 4e94 jsr %a4@ <== NOT EXECUTED
4afca: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4afce: 102a 000c moveb %a2@(12),%d0 <== NOT EXECUTED
4afd2: 66bc bnes 4af90 <rtems_bdbuf_swapout_worker_task+0x2e><== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
4afd4: 2f2a 0024 movel %a2@(36),%sp@- <== NOT EXECUTED
4afd8: 47f9 0004 3630 lea 43630 <free>,%a3 <== NOT EXECUTED
4afde: 4e93 jsr %a3@ <== NOT EXECUTED
free (worker);
4afe0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4afe2: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4afe4: 508f addql #8,%sp <== NOT EXECUTED
4afe6: 42ae 0008 clrl %fp@(8) <== NOT EXECUTED
}
4afea: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5 <== NOT EXECUTED
4aff0: 4e5e unlk %fp <== NOT EXECUTED
}
free (worker->transfer.write_req);
free (worker);
rtems_task_delete (RTEMS_SELF);
4aff2: 4ef9 0004 69a4 jmp 469a4 <rtems_task_delete> <== NOT EXECUTED
0004aaf8 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
4aaf8: 4e56 ffdc linkw %fp,#-36
4aafc: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4ab00: 246e 0008 moveal %fp@(8),%a2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4ab04: 260a movel %a2,%d3
4ab06: 5883 addql #4,%d3
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4ab08: b692 cmpl %a2@,%d3
4ab0a: 6700 0132 beqw 4ac3e <rtems_bdbuf_swapout_write+0x146>
/*
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
4ab0e: 2f2a 0010 movel %a2@(16),%sp@-
4ab12: 2f2a 000c movel %a2@(12),%sp@-
4ab16: 4eb9 0004 2912 jsr 42912 <rtems_disk_obtain>
if (dd == NULL)
4ab1c: 508f addql #8,%sp
/*
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
4ab1e: 2640 moveal %d0,%a3
if (dd == NULL)
4ab20: 4a80 tstl %d0
4ab22: 6606 bnes 4ab2a <rtems_bdbuf_swapout_write+0x32>
dd = &null_disk;
4ab24: 47f9 0006 0770 lea 60770 <null_disk.6986>,%a3
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
4ab2a: 2a2b 0020 movel %a3@(32),%d5
4ab2e: 41f9 0005 ea0c lea 5ea0c <rtems_bdbuf_configuration+0x20>,%a0
{
/*
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
4ab34: 4282 clrl %d2
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4ab36: 283c 0004 7244 movel #291396,%d4
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4ab3c: 4bf9 0004 e3cc lea 4e3cc <_Chain_Insert>,%a5
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
if (dd == NULL)
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
4ab42: 4c50 5005 remul %a0@,%d5,%d5
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4ab46: 206a 0016 moveal %a2@(22),%a0
4ab4a: 700c moveq #12,%d0
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
4ab4c: 2c3c 0004 a9ec movel #305644,%d6
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4ab52: 2140 000c movel %d0,%a0@(12)
transfer->write_req->bufnum = 0;
4ab56: 42a8 0010 clrl %a0@(16)
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
4ab5a: 6000 0094 braw 4abf0 <rtems_bdbuf_swapout_write+0xf8>
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
4ab5e: 226b 0008 moveal %a3@(8),%a1
4ab62: 7201 moveq #1,%d1
4ab64: c2a9 000c andl %a1@(12),%d1
4ab68: 202a 0016 movel %a2@(22),%d0
4ab6c: 4a81 tstl %d1
4ab6e: 671e beqs 4ab8e <rtems_bdbuf_swapout_write+0x96> <== ALWAYS TAKEN
4ab70: 2240 moveal %d0,%a1 <== NOT EXECUTED
4ab72: 4aa9 0010 tstl %a1@(16) <== NOT EXECUTED
4ab76: 6716 beqs 4ab8e <rtems_bdbuf_swapout_write+0x96> <== NOT EXECUTED
transfer->write_req->bufnum &&
(bd->block != (last_block + bufs_per_bd)))
4ab78: 2202 movel %d2,%d1 <== NOT EXECUTED
4ab7a: d285 addl %d5,%d1 <== NOT EXECUTED
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
transfer->write_req->bufnum &&
4ab7c: b2a8 001a cmpl %a0@(26),%d1 <== NOT EXECUTED
4ab80: 670c beqs 4ab8e <rtems_bdbuf_swapout_write+0x96> <== NOT EXECUTED
4ab82: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4ab84: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ab86: 4e95 jsr %a5@ <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
{
rtems_chain_prepend (&transfer->bds, &bd->link);
write = true;
4ab88: 508f addql #8,%sp <== NOT EXECUTED
4ab8a: 7001 moveq #1,%d0 <== NOT EXECUTED
4ab8c: 602c bras 4abba <rtems_bdbuf_swapout_write+0xc2> <== NOT EXECUTED
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4ab8e: 2840 moveal %d0,%a4
4ab90: 222c 0010 movel %a4@(16),%d1
4ab94: 2401 movel %d1,%d2
transfer->write_req->bufnum++;
4ab96: 5281 addql #1,%d1
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4ab98: e98a lsll #4,%d2
transfer->write_req->bufnum++;
4ab9a: 2941 0010 movel %d1,%a4@(16)
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4ab9e: 43f4 2818 lea %a4@(00000018,%d2:l),%a1
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4aba2: 2428 001a movel %a0@(26),%d2
buf->length = dd->block_size;
4aba6: 236b 0020 0004 movel %a3@(32),%a1@(4)
buf->buffer = bd->buffer;
4abac: 2368 001e 0008 movel %a0@(30),%a1@(8)
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
4abb2: 4200 clrb %d0
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
4abb4: 2348 000c movel %a0,%a1@(12)
buf->block = bd->block;
4abb8: 2282 movel %d2,%a1@
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
4abba: b692 cmpl %a2@,%d3
4abbc: 6714 beqs 4abd2 <rtems_bdbuf_swapout_write+0xda>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
4abbe: 206a 0016 moveal %a2@(22),%a0
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
4abc2: 2239 0005 e9f0 movel 5e9f0 <rtems_bdbuf_configuration+0x4>,%d1
4abc8: b2a8 0010 cmpl %a0@(16),%d1
4abcc: 6304 blss 4abd2 <rtems_bdbuf_swapout_write+0xda>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
4abce: 4a00 tstb %d0
4abd0: 671e beqs 4abf0 <rtems_bdbuf_swapout_write+0xf8> <== ALWAYS TAKEN
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
4abd2: 42a7 clrl %sp@-
4abd4: 2f2a 0016 movel %a2@(22),%sp@-
4abd8: 2046 moveal %d6,%a0
4abda: 2f0b movel %a3,%sp@-
4abdc: 4e90 jsr %a0@
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4abde: 206a 0016 moveal %a2@(22),%a0
4abe2: 700c moveq #12,%d0
transfer->write_req->bufnum = 0;
4abe4: 4fef 000c lea %sp@(12),%sp
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4abe8: 2140 000c movel %d0,%a0@(12)
transfer->write_req->bufnum = 0;
4abec: 42a8 0010 clrl %a0@(16)
4abf0: 2f0a movel %a2,%sp@-
4abf2: 2044 moveal %d4,%a0
4abf4: 4e90 jsr %a0@
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
4abf6: 588f addql #4,%sp
4abf8: 2040 moveal %d0,%a0
4abfa: 4a80 tstl %d0
4abfc: 6600 ff60 bnew 4ab5e <rtems_bdbuf_swapout_write+0x66>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
}
}
if (dd != &null_disk)
4ac00: b7fc 0006 0770 cmpal #395120,%a3
4ac06: 6736 beqs 4ac3e <rtems_bdbuf_swapout_write+0x146><== NEVER TAKEN
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
4ac08: 4a2a 0014 tstb %a2@(20)
4ac0c: 671e beqs 4ac2c <rtems_bdbuf_swapout_write+0x134>
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
4ac0e: 206b 0008 moveal %a3@(8),%a0
4ac12: 7002 moveq #2,%d0
4ac14: c0a8 000c andl %a0@(12),%d0
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
4ac18: 6712 beqs 4ac2c <rtems_bdbuf_swapout_write+0x134><== ALWAYS TAKEN
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
4ac1a: 42a7 clrl %sp@- <== NOT EXECUTED
4ac1c: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
4ac20: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4ac22: 206b 0028 moveal %a3@(40),%a0 <== NOT EXECUTED
4ac26: 4e90 jsr %a0@ <== NOT EXECUTED
4ac28: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
/* How should the error be handled ? */
}
rtems_disk_release (dd);
4ac2c: 2d4b 0008 movel %a3,%fp@(8)
}
}
}
4ac30: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
4ac36: 4e5e unlk %fp
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
/* How should the error be handled ? */
}
rtems_disk_release (dd);
4ac38: 4ef9 0004 297a jmp 4297a <rtems_disk_release>
}
}
}
4ac3e: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5 <== NOT EXECUTED
4ac44: 4e5e unlk %fp <== NOT EXECUTED
0004a296 <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
4a296: 4e56 0000 linkw %fp,#0
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
4a29a: 2039 0005 e9f0 movel 5e9f0 <rtems_bdbuf_configuration+0x4>,%d0
4a2a0: e988 lsll #4,%d0
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
4a2a2: 2f0a movel %a2,%sp@-
* @note chrisj The rtems_blkdev_request and the array at the end is a hack.
* I am disappointment at finding code like this in RTEMS. The request should
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
4a2a4: 2040 moveal %d0,%a0
4a2a6: 4868 0018 pea %a0@(24)
4a2aa: 4eb9 0004 391c jsr 4391c <malloc>
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
4a2b0: 588f addql #4,%sp
* @note chrisj The rtems_blkdev_request and the array at the end is a hack.
* I am disappointment at finding code like this in RTEMS. The request should
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
4a2b2: 2440 moveal %d0,%a2
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
4a2b4: 4a80 tstl %d0
4a2b6: 660c bnes 4a2c4 <rtems_bdbuf_swapout_writereq_alloc+0x2e><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
4a2b8: 2f3c 4200 0015 movel #1107296277,%sp@- <== NOT EXECUTED
4a2be: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
4a2c4: 7001 moveq #1,%d0
4a2c6: 2480 movel %d0,%a2@
write_req->req_done = rtems_bdbuf_transfer_done;
4a2c8: 203c 0004 a126 movel #303398,%d0
write_req->done_arg = write_req;
4a2ce: 254a 0008 movel %a2,%a2@(8)
if (!write_req)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
write_req->req_done = rtems_bdbuf_transfer_done;
4a2d2: 2540 0004 movel %d0,%a2@(4)
write_req->done_arg = write_req;
write_req->io_task = rtems_task_self ();
4a2d6: 4eb9 0004 e100 jsr 4e100 <rtems_task_self>
4a2dc: 2540 0014 movel %d0,%a2@(20)
return write_req;
}
4a2e0: 200a movel %a2,%d0
4a2e2: 246e fffc moveal %fp@(-4),%a2
4a2e6: 4e5e unlk %fp <== NOT EXECUTED
0004bc7a <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
4bc7a: 4e56 0000 linkw %fp,#0
4bc7e: 2f0b movel %a3,%sp@-
4bc80: 2f0a movel %a2,%sp@-
4bc82: 246e 0008 moveal %fp@(8),%a2
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
4bc86: 4a39 0006 1768 tstb 61768 <bdbuf_cache+0x84>
4bc8c: 672a beqs 4bcb8 <rtems_bdbuf_sync+0x3e> <== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
4bc8e: 4a8a tstl %a2
4bc90: 672c beqs 4bcbe <rtems_bdbuf_sync+0x44> <== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
4bc92: 4eba e244 jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4bc96: 202a 0022 movel %a2@(34),%d0
4bc9a: 7203 moveq #3,%d1
4bc9c: b280 cmpl %d0,%d1
4bc9e: 6200 00e0 bhiw 4bd80 <rtems_bdbuf_sync+0x106>
4bca2: 123c 0005 moveb #5,%d1
4bca6: b280 cmpl %d0,%d1
4bca8: 641a bccs 4bcc4 <rtems_bdbuf_sync+0x4a>
4bcaa: 123c 0006 moveb #6,%d1
4bcae: b280 cmpl %d0,%d1
4bcb0: 6600 00ce bnew 4bd80 <rtems_bdbuf_sync+0x106>
4bcb4: 6000 00c0 braw 4bd76 <rtems_bdbuf_sync+0xfc>
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4bcb8: 7016 moveq #22,%d0 <== NOT EXECUTED
4bcba: 6000 00da braw 4bd96 <rtems_bdbuf_sync+0x11c> <== NOT EXECUTED
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
4bcbe: 7009 moveq #9,%d0 <== NOT EXECUTED
4bcc0: 6000 00d4 braw 4bd96 <rtems_bdbuf_sync+0x11c> <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4bcc4: 7008 moveq #8,%d0
4bcc6: 2540 0022 movel %d0,%a2@(34)
4bcca: 2f0a movel %a2,%sp@-
4bccc: 4879 0006 173c pea 6173c <bdbuf_cache+0x58>
4bcd2: 4eb9 0004 71e4 jsr 471e4 <_Chain_Append>
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
4bcd8: 202a 0026 movel %a2@(38),%d0
4bcdc: 508f addql #8,%sp
4bcde: 670c beqs 4bcec <rtems_bdbuf_sync+0x72>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4bce0: 4879 0006 1748 pea 61748 <bdbuf_cache+0x64>
4bce6: 4eba e65e jsr %pc@(4a346 <rtems_bdbuf_wake>)
4bcea: 588f addql #4,%sp
rtems_bdbuf_wake_swapper ();
4bcec: 4eba e40e jsr %pc@(4a0fc <rtems_bdbuf_wake_swapper>)
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4bcf0: 47fa e564 lea %pc@(4a256 <rtems_bdbuf_wait>),%a3
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4bcf4: 202a 0022 movel %a2@(34),%d0
4bcf8: 7201 moveq #1,%d1
4bcfa: b280 cmpl %d0,%d1
4bcfc: 621e bhis 4bd1c <rtems_bdbuf_sync+0xa2> <== NEVER TAKEN
4bcfe: 123c 0007 moveb #7,%d1
4bd02: b280 cmpl %d0,%d1
4bd04: 6422 bccs 4bd28 <rtems_bdbuf_sync+0xae>
4bd06: 123c 000a moveb #10,%d1
4bd0a: b280 cmpl %d0,%d1
4bd0c: 650e bcss 4bd1c <rtems_bdbuf_sync+0xa2> <== NEVER TAKEN
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4bd0e: 4879 0006 1750 pea 61750 <bdbuf_cache+0x6c>
4bd14: 2f0a movel %a2,%sp@-
4bd16: 4e93 jsr %a3@
4bd18: 508f addql #8,%sp
4bd1a: 60d8 bras 4bcf4 <rtems_bdbuf_sync+0x7a>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_9);
4bd1c: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4bd20: 2f3c 4200 0007 movel #1107296263,%sp@- <== NOT EXECUTED
4bd26: 6062 bras 4bd8a <rtems_bdbuf_sync+0x110> <== NOT EXECUTED
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
4bd28: 202a 0026 movel %a2@(38),%d0
4bd2c: 6662 bnes 4bd90 <rtems_bdbuf_sync+0x116>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
4bd2e: 202a 0022 movel %a2@(34),%d0
4bd32: 7202 moveq #2,%d1
4bd34: b280 cmpl %d0,%d1
4bd36: 670c beqs 4bd44 <rtems_bdbuf_sync+0xca>
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
4bd38: 202a 0022 movel %a2@(34),%d0
4bd3c: 123c 0001 moveb #1,%d1
4bd40: b280 cmpl %d0,%d1
4bd42: 664c bnes 4bd90 <rtems_bdbuf_sync+0x116> <== NEVER TAKEN
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
4bd44: 202a 0022 movel %a2@(34),%d0
4bd48: 7201 moveq #1,%d1
4bd4a: b280 cmpl %d0,%d1
4bd4c: 661c bnes 4bd6a <rtems_bdbuf_sync+0xf0>
{
rtems_bdbuf_remove_from_tree (bd);
4bd4e: 2f0a movel %a2,%sp@-
4bd50: 4eba e796 jsr %pc@(4a4e8 <rtems_bdbuf_remove_from_tree>)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4bd54: 42aa 0022 clrl %a2@(34)
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4bd58: 2f0a movel %a2,%sp@-
4bd5a: 4879 0006 1724 pea 61724 <bdbuf_cache+0x40>
4bd60: 4eb9 0004 e3cc jsr 4e3cc <_Chain_Insert>
4bd66: 4fef 000c lea %sp@(12),%sp
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4bd6a: 4879 0006 1758 pea 61758 <bdbuf_cache+0x74>
4bd70: 4eba e5d4 jsr %pc@(4a346 <rtems_bdbuf_wake>)
4bd74: 6006 bras 4bd7c <rtems_bdbuf_sync+0x102>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_sync_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4bd76: 2f0a movel %a2,%sp@-
4bd78: 4eba ea9a jsr %pc@(4a814 <rtems_bdbuf_discard_buffer_after_access>)
break;
4bd7c: 588f addql #4,%sp
4bd7e: 6010 bras 4bd90 <rtems_bdbuf_sync+0x116>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
4bd80: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4bd84: 2f3c 4200 0003 movel #1107296259,%sp@- <== NOT EXECUTED
4bd8a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bd8c: 4eba e1a2 jsr %pc@(49f30 <rtems_bdbuf_fatal>) <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4bd90: 4eba e2fa jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
return RTEMS_SUCCESSFUL;
4bd94: 4280 clrl %d0
}
4bd96: 246e fff8 moveal %fp@(-8),%a2
4bd9a: 266e fffc moveal %fp@(-4),%a3
4bd9e: 4e5e unlk %fp <== NOT EXECUTED
0004bda2 <rtems_bdbuf_syncdev>:
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
4bda2: 4e56 fff0 linkw %fp,#-16
4bda6: 48d7 001c moveml %d2-%d4,%sp@
4bdaa: 242e 0008 movel %fp@(8),%d2
4bdae: 262e 000c movel %fp@(12),%d3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
4bdb2: 42ae fffc clrl %fp@(-4)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4bdb6: 4a39 0006 1768 tstb 61768 <bdbuf_cache+0x84>
4bdbc: 6762 beqs 4be20 <rtems_bdbuf_syncdev+0x7e> <== NEVER TAKEN
4bdbe: 42a7 clrl %sp@-
4bdc0: 42a7 clrl %sp@-
4bdc2: 486e fffc pea %fp@(-4)
4bdc6: 42a7 clrl %sp@-
4bdc8: 2f03 movel %d3,%sp@-
4bdca: 2f02 movel %d2,%sp@-
4bdcc: 4eba e652 jsr %pc@(4a420 <rtems_bdbuf_obtain_disk.part.7>)
if (rtems_bdbuf_tracer)
printf ("bdbuf:syncdev: %08x\n", (unsigned) dev);
sc = rtems_bdbuf_obtain_disk (dev, 0, &dd, NULL, NULL);
if (sc != RTEMS_SUCCESSFUL)
4bdd0: 4fef 0018 lea %sp@(24),%sp
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4bdd4: 2800 movel %d0,%d4
if (rtems_bdbuf_tracer)
printf ("bdbuf:syncdev: %08x\n", (unsigned) dev);
sc = rtems_bdbuf_obtain_disk (dev, 0, &dd, NULL, NULL);
if (sc != RTEMS_SUCCESSFUL)
4bdd6: 664a bnes 4be22 <rtems_bdbuf_syncdev+0x80> <== NEVER TAKEN
* Take the sync lock before locking the cache. Once we have the sync lock we
* can lock the cache. If another thread has the sync lock it will cause this
* thread to block until it owns the sync lock then it can own the cache. The
* sync lock can only be obtained with the cache unlocked.
*/
rtems_bdbuf_lock_sync ();
4bdd8: 4eba e12a jsr %pc@(49f04 <rtems_bdbuf_lock_sync>)
rtems_bdbuf_lock_cache ();
4bddc: 4eba e0fa jsr %pc@(49ed8 <rtems_bdbuf_lock_cache>)
* out task know the id of the requester to wake when done.
*
* The swap out task will negate the sync active flag when no more buffers
* for the device are held on the "modified for sync" queues.
*/
bdbuf_cache.sync_active = true;
4bde0: 7001 moveq #1,%d0
4bde2: 13c0 0006 1712 moveb %d0,61712 <bdbuf_cache+0x2e>
bdbuf_cache.sync_requester = rtems_task_self ();
4bde8: 4eb9 0004 e100 jsr 4e100 <rtems_task_self>
4bdee: 23c0 0006 1714 movel %d0,61714 <bdbuf_cache+0x30>
bdbuf_cache.sync_device = dev;
4bdf4: 23c2 0006 1718 movel %d2,61718 <bdbuf_cache+0x34>
4bdfa: 23c3 0006 171c movel %d3,6171c <bdbuf_cache+0x38>
rtems_bdbuf_wake_swapper ();
4be00: 4eba e2fa jsr %pc@(4a0fc <rtems_bdbuf_wake_swapper>)
rtems_bdbuf_unlock_cache ();
4be04: 4eba e286 jsr %pc@(4a08c <rtems_bdbuf_unlock_cache>)
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
4be08: 4878 0002 pea 2 <DOUBLE_FLOAT>
4be0c: 4eba e33a jsr %pc@(4a148 <rtems_bdbuf_wait_for_event>)
rtems_bdbuf_unlock_sync ();
4be10: 4eba e2a0 jsr %pc@(4a0b2 <rtems_bdbuf_unlock_sync>)
rtems_bdbuf_release_disk (dd);
4be14: 2f2e fffc movel %fp@(-4),%sp@-
4be18: 4eba e2be jsr %pc@(4a0d8 <rtems_bdbuf_release_disk>)
return RTEMS_SUCCESSFUL;
4be1c: 508f addql #8,%sp
4be1e: 6002 bras 4be22 <rtems_bdbuf_syncdev+0x80>
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4be20: 7816 moveq #22,%d4 <== NOT EXECUTED
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
rtems_bdbuf_unlock_sync ();
rtems_bdbuf_release_disk (dd);
return RTEMS_SUCCESSFUL;
}
4be22: 2004 movel %d4,%d0
4be24: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
4be2a: 4e5e unlk %fp <== NOT EXECUTED
0004a08c <rtems_bdbuf_unlock_cache>:
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
4a08c: 4e56 0000 linkw %fp,#0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
4a090: 2f39 0006 170a movel 6170a <bdbuf_cache+0x26>,%sp@-
4a096: 4eb9 0004 67d4 jsr 467d4 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
4a09c: 588f addql #4,%sp
4a09e: 4a80 tstl %d0
4a0a0: 670c beqs 4a0ae <rtems_bdbuf_unlock_cache+0x22> <== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
4a0a2: 2f3c 4200 000e movel #1107296270,%sp@- <== NOT EXECUTED
4a0a8: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_unlock_cache (void)
{
rtems_bdbuf_unlock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_UNLOCK);
}
4a0ae: 4e5e unlk %fp <== NOT EXECUTED
0004a0b2 <rtems_bdbuf_unlock_sync>:
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
4a0b2: 4e56 0000 linkw %fp,#0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
4a0b6: 2f39 0006 170e movel 6170e <bdbuf_cache+0x2a>,%sp@-
4a0bc: 4eb9 0004 67d4 jsr 467d4 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
4a0c2: 588f addql #4,%sp
4a0c4: 4a80 tstl %d0
4a0c6: 670c beqs 4a0d4 <rtems_bdbuf_unlock_sync+0x22> <== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
4a0c8: 2f3c 4200 000c movel #1107296268,%sp@- <== NOT EXECUTED
4a0ce: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
static void
rtems_bdbuf_unlock_sync (void)
{
rtems_bdbuf_unlock (bdbuf_cache.sync_lock,
RTEMS_BLKDEV_FATAL_BDBUF_SYNC_UNLOCK);
}
4a0d4: 4e5e unlk %fp <== NOT EXECUTED
0004a148 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
4a148: 4e56 fffc linkw %fp,#-4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
4a14c: 204e moveal %fp,%a0
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
4a14e: 2f02 movel %d2,%sp@-
4a150: 242e 0008 movel %fp@(8),%d2
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
4a154: 42a0 clrl %a0@-
sc = rtems_event_receive (event,
4a156: 2f08 movel %a0,%sp@-
4a158: 42a7 clrl %sp@-
4a15a: 42a7 clrl %sp@-
4a15c: 2f02 movel %d2,%sp@-
4a15e: 4eb9 0004 6104 jsr 46104 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
4a164: 4fef 0010 lea %sp@(16),%sp
4a168: 4a80 tstl %d0
4a16a: 6606 bnes 4a172 <rtems_bdbuf_wait_for_event+0x2a><== NEVER TAKEN
4a16c: b4ae fffc cmpl %fp@(-4),%d2
4a170: 670c beqs 4a17e <rtems_bdbuf_wait_for_event+0x36><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
4a172: 2f3c 4200 001a movel #1107296282,%sp@- <== NOT EXECUTED
4a178: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
4a17e: 242e fff8 movel %fp@(-8),%d2
4a182: 4e5e unlk %fp <== NOT EXECUTED
0004a346 <rtems_bdbuf_wake>:
* Wake a blocked resource. The resource has a counter that lets us know if
* there are any waiters.
*/
static void
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)
{
4a346: 4e56 0000 linkw %fp,#0
4a34a: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
4a34e: 2010 movel %a0@,%d0
4a350: 671c beqs 4a36e <rtems_bdbuf_wake+0x28>
{
sc = rtems_semaphore_flush (waiters->sema);
4a352: 2f28 0004 movel %a0@(4),%sp@-
4a356: 4eb9 0004 df38 jsr 4df38 <rtems_semaphore_flush>
if (sc != RTEMS_SUCCESSFUL)
4a35c: 588f addql #4,%sp
4a35e: 4a80 tstl %d0
4a360: 670c beqs 4a36e <rtems_bdbuf_wake+0x28> <== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
4a362: 2f3c 4200 0013 movel #1107296275,%sp@- <== NOT EXECUTED
4a368: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
4a36e: 4e5e unlk %fp <== NOT EXECUTED
0004a0fc <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
4a0fc: 4e56 0000 linkw %fp,#0
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4a100: 4878 0004 pea 4 <CONTEXT_ARG>
4a104: 2f39 0006 16e4 movel 616e4 <bdbuf_cache>,%sp@-
4a10a: 4eb9 0004 626c jsr 4626c <rtems_event_send>
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4a110: 508f addql #8,%sp
4a112: 4a80 tstl %d0
4a114: 670c beqs 4a122 <rtems_bdbuf_wake_swapper+0x26> <== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
4a116: 2f3c 4200 0014 movel #1107296276,%sp@- <== NOT EXECUTED
4a11c: 4eb9 0004 6d40 jsr 46d40 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
4a122: 4e5e unlk %fp <== NOT EXECUTED
0004c088 <rtems_blkdev_generic_ioctl>:
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
4c088: 4e56 0000 linkw %fp,#0
4c08c: 2f0a movel %a2,%sp@-
4c08e: 246e 0010 moveal %fp@(16),%a2
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
4c092: 2052 moveal %a2@,%a0
int rc;
switch (args->command)
4c094: 202a 0004 movel %a2@(4),%d0
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
4c098: 2068 0034 moveal %a0@(52),%a0
int rc;
switch (args->command)
4c09c: 0c80 4004 4203 cmpil #1074020867,%d0
4c0a2: 6738 beqs 4c0dc <rtems_blkdev_generic_ioctl+0x54><== NEVER TAKEN
4c0a4: 6212 bhis 4c0b8 <rtems_blkdev_generic_ioctl+0x30><== ALWAYS TAKEN
4c0a6: 0c80 2000 4206 cmpil #536887814,%d0 <== NOT EXECUTED
4c0ac: 6750 beqs 4c0fe <rtems_blkdev_generic_ioctl+0x76><== NOT EXECUTED
4c0ae: 0c80 4004 4202 cmpil #1074020866,%d0 <== NOT EXECUTED
4c0b4: 6666 bnes 4c11c <rtems_blkdev_generic_ioctl+0x94><== NOT EXECUTED
4c0b6: 601a bras 4c0d2 <rtems_blkdev_generic_ioctl+0x4a><== NOT EXECUTED
4c0b8: 0c80 8004 4204 cmpil #-2147204604,%d0
4c0be: 672a beqs 4c0ea <rtems_blkdev_generic_ioctl+0x62><== ALWAYS TAKEN
4c0c0: 0c80 c018 4201 cmpil #-1072152063,%d0 <== NOT EXECUTED
4c0c6: 674c beqs 4c114 <rtems_blkdev_generic_ioctl+0x8c><== NOT EXECUTED
4c0c8: 0c80 4004 4205 cmpil #1074020869,%d0 <== NOT EXECUTED
4c0ce: 664c bnes 4c11c <rtems_blkdev_generic_ioctl+0x94><== NOT EXECUTED
4c0d0: 6022 bras 4c0f4 <rtems_blkdev_generic_ioctl+0x6c><== NOT EXECUTED
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*((uint32_t *) args->buffer) = dd->media_block_size;
4c0d2: 226a 0008 moveal %a2@(8),%a1 <== NOT EXECUTED
4c0d6: 22a8 0024 movel %a0@(36),%a1@ <== NOT EXECUTED
4c0da: 6008 bras 4c0e4 <rtems_blkdev_generic_ioctl+0x5c><== NOT EXECUTED
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*((uint32_t *) args->buffer) = dd->block_size;
4c0dc: 226a 0008 moveal %a2@(8),%a1 <== NOT EXECUTED
4c0e0: 22a8 0020 movel %a0@(32),%a1@ <== NOT EXECUTED
args->ioctl_return = 0;
4c0e4: 42aa 000c clrl %a2@(12)
break;
4c0e8: 604a bras 4c134 <rtems_blkdev_generic_ioctl+0xac>
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *((uint32_t *) args->buffer);
4c0ea: 226a 0008 moveal %a2@(8),%a1
4c0ee: 2151 0020 movel %a1@,%a0@(32)
4c0f2: 60f0 bras 4c0e4 <rtems_blkdev_generic_ioctl+0x5c>
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETSIZE:
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
4c0f4: 226a 0008 moveal %a2@(8),%a1 <== NOT EXECUTED
4c0f8: 22a8 001c movel %a0@(28),%a1@ <== NOT EXECUTED
4c0fc: 60e6 bras 4c0e4 <rtems_blkdev_generic_ioctl+0x5c><== NOT EXECUTED
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SYNCDEV:
rc = rtems_bdbuf_syncdev(dd->dev);
4c0fe: 2f28 0004 movel %a0@(4),%sp@- <== NOT EXECUTED
4c102: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4c104: 4eb9 0004 bda2 jsr 4bda2 <rtems_bdbuf_syncdev> <== NOT EXECUTED
args->ioctl_return = (uint32_t) (rc == RTEMS_SUCCESSFUL ? 0 : -1);
4c10a: 508f addql #8,%sp <== NOT EXECUTED
4c10c: 4a80 tstl %d0 <== NOT EXECUTED
4c10e: 56c0 sne %d0 <== NOT EXECUTED
4c110: 49c0 extbl %d0 <== NOT EXECUTED
4c112: 6002 bras 4c116 <rtems_blkdev_generic_ioctl+0x8e><== NOT EXECUTED
case RTEMS_BLKIO_REQUEST:
/*
* It is not allowed to directly access the driver circumventing
* the cache.
*/
args->ioctl_return = (uint32_t) -1;
4c114: 70ff moveq #-1,%d0 <== NOT EXECUTED
4c116: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
break;
4c11a: 6018 bras 4c134 <rtems_blkdev_generic_ioctl+0xac><== NOT EXECUTED
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
4c11c: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4c120: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c122: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
4c126: 2068 0028 moveal %a0@(40),%a0 <== NOT EXECUTED
4c12a: 4e90 jsr %a0@ <== NOT EXECUTED
args->command,
args->buffer);
break;
4c12c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
*/
args->ioctl_return = (uint32_t) -1;
break;
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
4c130: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
4c134: 246e fffc moveal %fp@(-4),%a2
4c138: 4280 clrl %d0
4c13a: 4e5e unlk %fp <== NOT EXECUTED
0004c03a <rtems_blkdev_generic_open>:
rtems_device_driver
rtems_blkdev_generic_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg)
{
4c03a: 4e56 0000 linkw %fp,#0
rtems_libio_open_close_args_t *oc = arg;
rtems_libio_t *iop = oc->iop;
4c03e: 206e 0010 moveal %fp@(16),%a0
rtems_device_driver
rtems_blkdev_generic_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg)
{
4c042: 2f0a movel %a2,%sp@-
rtems_libio_open_close_args_t *oc = arg;
rtems_libio_t *iop = oc->iop;
4c044: 2450 moveal %a0@,%a2
temp.__overlay.minor = _minor;
4c046: 222e 000c movel %fp@(12),%d1
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
4c04a: 202e 0008 movel %fp@(8),%d0
dev_t dev = rtems_filesystem_make_dev_t(major, minor);
rtems_disk_device *dd = rtems_disk_obtain(dev);
4c04e: 2f01 movel %d1,%sp@-
4c050: 2f00 movel %d0,%sp@-
4c052: 4eb9 0004 2912 jsr 42912 <rtems_disk_obtain>
iop->data1 = dd;
if (dd != NULL)
4c058: 508f addql #8,%sp
rtems_libio_open_close_args_t *oc = arg;
rtems_libio_t *iop = oc->iop;
dev_t dev = rtems_filesystem_make_dev_t(major, minor);
rtems_disk_device *dd = rtems_disk_obtain(dev);
iop->data1 = dd;
4c05a: 2540 0034 movel %d0,%a2@(52)
if (dd != NULL)
4c05e: 6704 beqs 4c064 <rtems_blkdev_generic_open+0x2a> <== NEVER TAKEN
return RTEMS_SUCCESSFUL;
4c060: 4280 clrl %d0
4c062: 6002 bras 4c066 <rtems_blkdev_generic_open+0x2c>
else
return RTEMS_UNSATISFIED;
4c064: 700d moveq #13,%d0 <== NOT EXECUTED
}
4c066: 246e fffc moveal %fp@(-4),%a2
4c06a: 4e5e unlk %fp <== NOT EXECUTED
0004be68 <rtems_blkdev_generic_read>:
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
4be68: 4e56 ffc8 linkw %fp,#-56
4be6c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4be70: 246e 0010 moveal %fp@(16),%a2
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);
4be74: 4286 clrl %d6
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
4be76: 2052 moveal %a2@,%a0
4be78: 2668 0034 moveal %a0@(52),%a3
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
4be7c: 262a 000c movel %a2@(12),%d3
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
4be80: 282b 0020 movel %a3@(32),%d4
char *buf = args->buffer;
uint32_t count = args->count;
4be84: 242a 0010 movel %a2@(16),%d2
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4be88: 286a 0004 moveal %a2@(4),%a4
4be8c: 2a6a 0008 moveal %a2@(8),%a5
4be90: 2f04 movel %d4,%sp@-
4be92: 2f06 movel %d6,%sp@-
4be94: 2f0d movel %a5,%sp@-
4be96: 2f0c movel %a4,%sp@-
4be98: 4eb9 0005 c904 jsr 5c904 <__divdi3>
4be9e: 4fef 0010 lea %sp@(16),%sp
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4bea2: 2f04 movel %d4,%sp@-
4bea4: 2f06 movel %d6,%sp@-
4bea6: 2f0d movel %a5,%sp@-
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
4bea8: 4bf9 0004 b948 lea 4b948 <rtems_bdbuf_read>,%a5
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4beae: 2f0c movel %a4,%sp@-
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
4beb0: 49f9 0005 0b90 lea 50b90 <memcpy>,%a4
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);
4beb6: 2d41 fff8 movel %d1,%fp@(-8)
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4beba: 4eb9 0005 cd4c jsr 5cd4c <__moddi3>
4bec0: 4fef 0010 lea %sp@(16),%sp
4bec4: 2e01 movel %d1,%d7
dev_t dev = dd->dev;
4bec6: 2013 movel %a3@,%d0
4bec8: 222b 0004 movel %a3@(4),%d1
args->bytes_moved = 0;
4becc: 42aa 0018 clrl %a2@(24)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
4bed0: 47f9 0004 bb62 lea 4bb62 <rtems_bdbuf_release>,%a3
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
4bed6: 2d40 fff0 movel %d0,%fp@(-16)
4beda: 2d41 fff4 movel %d1,%fp@(-12)
args->bytes_moved = 0;
while (count > 0)
4bede: 604c bras 4bf2c <rtems_blkdev_generic_read+0xc4>
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
4bee0: 486e fffc pea %fp@(-4)
4bee4: 2f00 movel %d0,%sp@-
4bee6: 2f2e fff4 movel %fp@(-12),%sp@-
4beea: 2f2e fff0 movel %fp@(-16),%sp@-
4beee: 4e95 jsr %a5@
if (rc != RTEMS_SUCCESSFUL)
4bef0: 4fef 0010 lea %sp@(16),%sp
4bef4: 4a80 tstl %d0
4bef6: 6640 bnes 4bf38 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
break;
copy = block_size - blkofs;
4bef8: 2a04 movel %d4,%d5
4befa: 9a87 subl %d7,%d5
4befc: b485 cmpl %d5,%d2
4befe: 6402 bccs 4bf02 <rtems_blkdev_generic_read+0x9a> <== ALWAYS TAKEN
4bf00: 2a02 movel %d2,%d5 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
4bf02: 206e fffc moveal %fp@(-4),%a0
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
4bf06: 5286 addql #1,%d6
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
4bf08: 2f05 movel %d5,%sp@-
4bf0a: dea8 001e addl %a0@(30),%d7
4bf0e: 2f07 movel %d7,%sp@-
4bf10: 2f03 movel %d3,%sp@-
4bf12: 4e94 jsr %a4@
rc = rtems_bdbuf_release(diskbuf);
4bf14: 2f2e fffc movel %fp@(-4),%sp@-
4bf18: 4e93 jsr %a3@
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
4bf1a: 4fef 0010 lea %sp@(16),%sp
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
4bf1e: dbaa 0018 addl %d5,%a2@(24)
if (rc != RTEMS_SUCCESSFUL)
4bf22: 4a80 tstl %d0
4bf24: 6612 bnes 4bf38 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
break;
count -= copy;
4bf26: 9485 subl %d5,%d2
buf += copy;
4bf28: d685 addl %d5,%d3
blkofs = 0;
4bf2a: 4287 clrl %d7
/* rtems_blkdev_generic_read --
* Generic block device read primitive. Implemented using block device
* buffer management primitives.
*/
rtems_device_driver
rtems_blkdev_generic_read(
4bf2c: 202e fff8 movel %fp@(-8),%d0
4bf30: d086 addl %d6,%d0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
4bf32: 4a82 tstl %d2
4bf34: 66aa bnes 4bee0 <rtems_blkdev_generic_read+0x78>
4bf36: 4280 clrl %d0
blkofs = 0;
block++;
}
return rc;
}
4bf38: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4bf3e: 4e5e unlk %fp <== NOT EXECUTED
0004bf42 <rtems_blkdev_generic_write>:
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
4bf42: 4e56 ffc8 linkw %fp,#-56
4bf46: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4bf4a: 246e 0010 moveal %fp@(16),%a2
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);
4bf4e: 4286 clrl %d6
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
4bf50: 4287 clrl %d7
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
4bf52: 2052 moveal %a2@,%a0
4bf54: 2668 0034 moveal %a0@(52),%a3
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
4bf58: 282a 000c movel %a2@(12),%d4
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
4bf5c: 262b 0020 movel %a3@(32),%d3
char *buf = args->buffer;
uint32_t count = args->count;
4bf60: 242a 0010 movel %a2@(16),%d2
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4bf64: 286a 0004 moveal %a2@(4),%a4
4bf68: 2a6a 0008 moveal %a2@(8),%a5
4bf6c: 2f03 movel %d3,%sp@-
4bf6e: 2f06 movel %d6,%sp@-
4bf70: 2f0d movel %a5,%sp@-
4bf72: 2f0c movel %a4,%sp@-
4bf74: 4eb9 0005 c904 jsr 5c904 <__divdi3>
4bf7a: 4fef 0010 lea %sp@(16),%sp
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4bf7e: 2f03 movel %d3,%sp@-
4bf80: 2f06 movel %d6,%sp@-
4bf82: 2f0d movel %a5,%sp@-
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dev, block, &diskbuf);
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
4bf84: 4bf9 0004 b948 lea 4b948 <rtems_bdbuf_read>,%a5
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4bf8a: 2f0c movel %a4,%sp@-
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dev, block, &diskbuf);
4bf8c: 49f9 0004 b884 lea 4b884 <rtems_bdbuf_get>,%a4
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);
4bf92: 2d41 fff0 movel %d1,%fp@(-16)
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4bf96: 4eb9 0005 cd4c jsr 5cd4c <__moddi3>
4bf9c: 4fef 0010 lea %sp@(16),%sp
4bfa0: 2c01 movel %d1,%d6
dev_t dev = dd->dev;
4bfa2: 2013 movel %a3@,%d0
4bfa4: 222b 0004 movel %a3@(4),%d1
args->bytes_moved = 0;
4bfa8: 42aa 0018 clrl %a2@(24)
4bfac: 47ee fffc lea %fp@(-4),%a3
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
4bfb0: 2d40 fff4 movel %d0,%fp@(-12)
4bfb4: 2d41 fff8 movel %d1,%fp@(-8)
args->bytes_moved = 0;
while (count > 0)
4bfb8: 606a bras 4c024 <rtems_blkdev_generic_write+0xe2>
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
4bfba: 4a86 tstl %d6
4bfbc: 6614 bnes 4bfd2 <rtems_blkdev_generic_write+0x90><== NEVER TAKEN
4bfbe: b682 cmpl %d2,%d3
4bfc0: 6210 bhis 4bfd2 <rtems_blkdev_generic_write+0x90><== NEVER TAKEN
rc = rtems_bdbuf_get(dev, block, &diskbuf);
4bfc2: 2f0b movel %a3,%sp@-
4bfc4: 2f00 movel %d0,%sp@-
4bfc6: 2f2e fff8 movel %fp@(-8),%sp@-
4bfca: 2f2e fff4 movel %fp@(-12),%sp@-
4bfce: 4e94 jsr %a4@
4bfd0: 600e bras 4bfe0 <rtems_blkdev_generic_write+0x9e>
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
4bfd2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4bfd4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bfd6: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4bfda: 2f2e fff4 movel %fp@(-12),%sp@- <== NOT EXECUTED
4bfde: 4e95 jsr %a5@ <== NOT EXECUTED
4bfe0: 4fef 0010 lea %sp@(16),%sp
if (rc != RTEMS_SUCCESSFUL)
4bfe4: 4a80 tstl %d0
4bfe6: 6648 bnes 4c030 <rtems_blkdev_generic_write+0xee><== NEVER TAKEN
break;
copy = block_size - blkofs;
4bfe8: 2a03 movel %d3,%d5
4bfea: 9a86 subl %d6,%d5
4bfec: b485 cmpl %d5,%d2
4bfee: 6402 bccs 4bff2 <rtems_blkdev_generic_write+0xb0><== ALWAYS TAKEN
4bff0: 2a02 movel %d2,%d5 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
4bff2: 2f05 movel %d5,%sp@-
4bff4: 206e fffc moveal %fp@(-4),%a0
args->bytes_moved += copy;
rc = rtems_bdbuf_release_modified(diskbuf);
4bff8: 5287 addql #1,%d7
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
4bffa: 2f04 movel %d4,%sp@-
4bffc: dca8 001e addl %a0@(30),%d6
4c000: 2f06 movel %d6,%sp@-
4c002: 4eb9 0005 0b90 jsr 50b90 <memcpy>
args->bytes_moved += copy;
4c008: dbaa 0018 addl %d5,%a2@(24)
rc = rtems_bdbuf_release_modified(diskbuf);
4c00c: 2f2e fffc movel %fp@(-4),%sp@-
4c010: 4eb9 0004 bc0c jsr 4bc0c <rtems_bdbuf_release_modified>
if (rc != RTEMS_SUCCESSFUL)
4c016: 4fef 0010 lea %sp@(16),%sp
4c01a: 4a80 tstl %d0
4c01c: 6612 bnes 4c030 <rtems_blkdev_generic_write+0xee><== NEVER TAKEN
break;
count -= copy;
4c01e: 9485 subl %d5,%d2
buf += copy;
4c020: d885 addl %d5,%d4
blkofs = 0;
4c022: 4286 clrl %d6
/* rtems_blkdev_generic_write --
* Generic block device write primitive. Implemented using block device
* buffer management primitives.
*/
rtems_device_driver
rtems_blkdev_generic_write(
4c024: 202e fff0 movel %fp@(-16),%d0
4c028: d087 addl %d7,%d0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
4c02a: 4a82 tstl %d2
4c02c: 668c bnes 4bfba <rtems_blkdev_generic_write+0x78>
4c02e: 4280 clrl %d0
blkofs = 0;
block++;
}
return rc;
}
4c030: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4c036: 4e5e unlk %fp <== NOT EXECUTED
0004c13e <rtems_blkdev_ioctl>:
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4c13e: 4e56 0000 linkw %fp,#0
4c142: 226e 0008 moveal %fp@(8),%a1
4c146: 202e 000c movel %fp@(12),%d0
4c14a: 206e 0010 moveal %fp@(16),%a0
size_t *arg_size = argp;
int rc = 0;
switch (req)
4c14e: 0c80 4004 4203 cmpil #1074020867,%d0
4c154: 6724 beqs 4c17a <rtems_blkdev_ioctl+0x3c> <== NEVER TAKEN
4c156: 620a bhis 4c162 <rtems_blkdev_ioctl+0x24>
4c158: 0c80 4004 4202 cmpil #1074020866,%d0
4c15e: 662e bnes 4c18e <rtems_blkdev_ioctl+0x50> <== ALWAYS TAKEN
4c160: 6012 bras 4c174 <rtems_blkdev_ioctl+0x36> <== NOT EXECUTED
4c162: 0c80 4004 4205 cmpil #1074020869,%d0
4c168: 671e beqs 4c188 <rtems_blkdev_ioctl+0x4a> <== NEVER TAKEN
4c16a: 0c80 8004 4204 cmpil #-2147204604,%d0
4c170: 661c bnes 4c18e <rtems_blkdev_ioctl+0x50> <== NEVER TAKEN
4c172: 600e bras 4c182 <rtems_blkdev_ioctl+0x44>
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
4c174: 20a9 0024 movel %a1@(36),%a0@ <== NOT EXECUTED
4c178: 6004 bras 4c17e <rtems_blkdev_ioctl+0x40> <== NOT EXECUTED
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
4c17a: 20a9 0020 movel %a1@(32),%a0@ <== NOT EXECUTED
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
4c17e: 4280 clrl %d0
*arg_size = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
break;
4c180: 601a bras 4c19c <rtems_blkdev_ioctl+0x5e>
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
4c182: 2350 0020 movel %a0@,%a1@(32)
4c186: 60f6 bras 4c17e <rtems_blkdev_ioctl+0x40>
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
4c188: 20a9 001c movel %a1@(28),%a0@ <== NOT EXECUTED
4c18c: 60f0 bras 4c17e <rtems_blkdev_ioctl+0x40> <== NOT EXECUTED
break;
default:
errno = EINVAL;
4c18e: 4eb9 0005 0370 jsr 50370 <__errno>
4c194: 2040 moveal %d0,%a0
4c196: 7016 moveq #22,%d0
4c198: 2080 movel %d0,%a0@
rc = -1;
4c19a: 70ff moveq #-1,%d0
break;
}
return rc;
}
4c19c: 4e5e unlk %fp <== NOT EXECUTED
000423c4 <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
423c4: 4e56 ffec linkw %fp,#-20
423c8: 202e 0008 movel %fp@(8),%d0
423cc: 48d7 043c moveml %d2-%d5/%a2,%sp@
423d0: 246e 000c moveal %fp@(12),%a2
423d4: 242e 0010 movel %fp@(16),%d2
const char *p;
if ( !name )
423d8: 4a80 tstl %d0
423da: 674e beqs 4242a <rtems_bsp_cmdline_get_param+0x66><== NEVER TAKEN
return NULL;
if ( !value )
423dc: 4a8a tstl %a2
423de: 674c beqs 4242c <rtems_bsp_cmdline_get_param+0x68><== NEVER TAKEN
return NULL;
if ( !length )
423e0: 4a82 tstl %d2
423e2: 6746 beqs 4242a <rtems_bsp_cmdline_get_param+0x66><== NEVER TAKEN
return NULL;
value[0] = '\0';
423e4: 4212 clrb %a2@
p = rtems_bsp_cmdline_get_param_raw( name );
423e6: 2f00 movel %d0,%sp@-
423e8: 4eb9 0004 2438 jsr 42438 <rtems_bsp_cmdline_get_param_raw>
if ( !p )
423ee: 588f addql #4,%sp
423f0: 4a80 tstl %d0
423f2: 6736 beqs 4242a <rtems_bsp_cmdline_get_param+0x66><== NEVER TAKEN
423f4: 2240 moveal %d0,%a1
423f6: 204a moveal %a2,%a0
423f8: 4283 clrl %d3
423fa: 4281 clrl %d1
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
423fc: 5382 subql #1,%d2
423fe: 6020 bras 42420 <rtems_bsp_cmdline_get_param+0x5c>
if ( *p == '\"' ) {
42400: 7a22 moveq #34,%d5
42402: 1004 moveb %d4,%d0
42404: 49c0 extbl %d0
42406: ba80 cmpl %d0,%d5
42408: 6604 bnes 4240e <rtems_bsp_cmdline_get_param+0x4a>
quotes++;
4240a: 5283 addql #1,%d3
4240c: 600c bras 4241a <rtems_bsp_cmdline_get_param+0x56>
} else if ( ((quotes % 2) == 0) && *p == ' ' )
4240e: 0803 0000 btst #0,%d3
42412: 6606 bnes 4241a <rtems_bsp_cmdline_get_param+0x56>
42414: 7a20 moveq #32,%d5
42416: ba80 cmpl %d0,%d5
42418: 6712 beqs 4242c <rtems_bsp_cmdline_get_param+0x68>
break;
value[i++] = *p++;
4241a: 5281 addql #1,%d1
4241c: 10c4 moveb %d4,%a0@+
value[i] = '\0';
4241e: 4210 clrb %a0@
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
42420: 1819 moveb %a1@+,%d4
42422: 6708 beqs 4242c <rtems_bsp_cmdline_get_param+0x68>
42424: b481 cmpl %d1,%d2
42426: 62d8 bhis 42400 <rtems_bsp_cmdline_get_param+0x3c>
42428: 6002 bras 4242c <rtems_bsp_cmdline_get_param+0x68>
value[0] = '\0';
p = rtems_bsp_cmdline_get_param_raw( name );
if ( !p )
return NULL;
4242a: 95ca subal %a2,%a2
copy_string( p, value, length );
return value;
}
4242c: 200a movel %a2,%d0
4242e: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
42434: 4e5e unlk %fp <== NOT EXECUTED
000463cc <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
463cc: 4e56 0000 linkw %fp,#0
463d0: 2f03 movel %d3,%sp@-
463d2: 262e 0010 movel %fp@(16),%d3
463d6: 2f02 movel %d2,%sp@-
RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node **node
)
{
return _Chain_Get_with_empty_check( chain, node );
463d8: 2f2e 0014 movel %fp@(20),%sp@-
463dc: 2f2e 0008 movel %fp@(8),%sp@-
463e0: 242e 000c movel %fp@(12),%d2
463e4: 4eb9 0004 69c8 jsr 469c8 <_Chain_Get_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
463ea: 508f addql #8,%sp
463ec: 4a00 tstb %d0
463ee: 6718 beqs 46408 <rtems_chain_get_with_notification+0x3c><== NEVER TAKEN
sc = rtems_event_send( task, events );
463f0: 2d43 000c movel %d3,%fp@(12)
}
return sc;
}
463f4: 262e fffc movel %fp@(-4),%d3
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
463f8: 2d42 0008 movel %d2,%fp@(8)
}
return sc;
}
463fc: 242e fff8 movel %fp@(-8),%d2
46400: 4e5e unlk %fp
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
46402: 4ef9 0004 59f8 jmp 459f8 <rtems_event_send>
}
return sc;
}
46408: 242e fff8 movel %fp@(-8),%d2
4640c: 4280 clrl %d0
4640e: 262e fffc movel %fp@(-4),%d3
46412: 4e5e unlk %fp
...
00046418 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
46418: 4e56 ffe0 linkw %fp,#-32
4641c: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
46420: 260e movel %fp,%d3
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
46422: 47f9 0004 6a10 lea 46a10 <_Chain_Get>,%a3
46428: 5983 subql #4,%d3
4642a: 45f9 0004 5890 lea 45890 <rtems_event_receive>,%a2
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
46430: 2c2e 0008 movel %fp@(8),%d6
46434: 2a2e 000c movel %fp@(12),%d5
46438: 282e 0010 movel %fp@(16),%d4
4643c: 6012 bras 46450 <rtems_chain_get_with_wait+0x38>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
4643e: 2f03 movel %d3,%sp@-
46440: 2f04 movel %d4,%sp@-
46442: 42a7 clrl %sp@-
46444: 2f05 movel %d5,%sp@-
46446: 4e92 jsr %a2@
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
46448: 4fef 0010 lea %sp@(16),%sp
4644c: 4a80 tstl %d0
4644e: 660c bnes 4645c <rtems_chain_get_with_wait+0x44> <== ALWAYS TAKEN
46450: 2f06 movel %d6,%sp@-
46452: 4e93 jsr %a3@
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
46454: 588f addql #4,%sp
46456: 2400 movel %d0,%d2
46458: 67e4 beqs 4643e <rtems_chain_get_with_wait+0x26>
4645a: 4280 clrl %d0
timeout,
&out
);
}
*node_ptr = node;
4645c: 206e 0014 moveal %fp@(20),%a0
46460: 2082 movel %d2,%a0@
return sc;
}
46462: 4cee 0c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a3
46468: 4e5e unlk %fp <== NOT EXECUTED
00042a88 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
42a88: 4e56 ff90 linkw %fp,#-112
42a8c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
42a90: 242e 0008 movel %fp@(8),%d2
42a94: 246e 000c moveal %fp@(12),%a2
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
42a98: 4a8a tstl %a2
42a9a: 6700 017e beqw 42c1a <rtems_cpu_usage_report_with_plugin+0x192>
}
}
}
#endif
(*print)(
42a9e: 4879 0005 d7d1 pea 5d7d1 <map.6435+0x11>
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
42aa4: 2c0e movel %fp,%d6
42aa6: 260e movel %fp,%d3
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
42aa8: 2a0e movel %fp,%d5
}
}
}
#endif
(*print)(
42aaa: 49f9 0006 0d38 lea 60d38 <_Objects_Information_table+0x4>,%a4
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
42ab0: 0686 ffff ffbb addil #-69,%d6
42ab6: 0683 ffff ffc8 addil #-56,%d3
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
42abc: 0685 ffff ffd0 addil #-48,%d5
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
42ac2: 2039 0006 1250 movel 61250 <CPU_usage_Uptime_at_last_reset>,%d0
42ac8: 2239 0006 1254 movel 61254 <CPU_usage_Uptime_at_last_reset+0x4>,%d1
}
}
}
#endif
(*print)(
42ace: 2f02 movel %d2,%sp@-
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
42ad0: 2d40 ffe0 movel %d0,%fp@(-32)
42ad4: 2d41 ffe4 movel %d1,%fp@(-28)
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
42ad8: 42ae ffd0 clrl %fp@(-48)
42adc: 42ae ffd4 clrl %fp@(-44)
}
}
}
#endif
(*print)(
42ae0: 4e92 jsr %a2@
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
42ae2: 508f addql #8,%sp
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
42ae4: 205c moveal %a4@+,%a0
42ae6: 2a68 0004 moveal %a0@(4),%a5
if ( information ) {
42aea: 4a8d tstl %a5
42aec: 6600 00f2 bnew 42be0 <rtems_cpu_usage_report_with_plugin+0x158>
42af0: 6000 00fc braw 42bee <rtems_cpu_usage_report_with_plugin+0x166><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
42af4: 206d 0018 moveal %a5@(24),%a0
42af8: 2670 4c00 moveal %a0@(00000000,%d4:l:4),%a3
if ( !the_thread )
42afc: 4a8b tstl %a3
42afe: 6700 00dc beqw 42bdc <rtems_cpu_usage_report_with_plugin+0x154>
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
42b02: 2f06 movel %d6,%sp@-
42b04: 4878 000d pea d <OPER1+0x1>
42b08: 2f2b 0008 movel %a3@(8),%sp@-
42b0c: 4eb9 0004 65e8 jsr 465e8 <rtems_object_get_name>
(*print)(
42b12: 2f06 movel %d6,%sp@-
42b14: 2f2b 0008 movel %a3@(8),%sp@-
42b18: 4879 0005 d943 pea 5d943 <map.6435+0x183>
42b1e: 2f02 movel %d2,%sp@-
42b20: 4e92 jsr %a2@
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
42b22: 2079 0006 1214 moveal 61214 <_Per_CPU_Information+0xc>,%a0
42b28: 4fef 001c lea %sp@(28),%sp
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
42b2c: 202b 0082 movel %a3@(130),%d0
42b30: 222b 0086 movel %a3@(134),%d1
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
42b34: 266b 0008 moveal %a3@(8),%a3
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
42b38: 2d40 ffd8 movel %d0,%fp@(-40)
42b3c: 2d41 ffdc movel %d1,%fp@(-36)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
42b40: b7e8 0008 cmpal %a0@(8),%a3
42b44: 6640 bnes 42b86 <rtems_cpu_usage_report_with_plugin+0xfe>
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
42b46: 2f03 movel %d3,%sp@-
_Timestamp_Subtract( &last, &uptime, &used );
42b48: 47ee fff0 lea %fp@(-16),%a3
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
*time_of_context_switch = _Thread_Time_of_last_context_switch;
42b4c: 2039 0006 1222 movel 61222 <_Per_CPU_Information+0x1a>,%d0
42b52: 2239 0006 1226 movel 61226 <_Per_CPU_Information+0x1e>,%d1
42b58: 2d40 ffe8 movel %d0,%fp@(-24)
42b5c: 2d41 ffec movel %d1,%fp@(-20)
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
42b60: 4eb9 0004 7820 jsr 47820 <_TOD_Get_uptime>
_Timestamp_Subtract( &last, &uptime, &used );
42b66: 2f0b movel %a3,%sp@-
42b68: 2f03 movel %d3,%sp@-
42b6a: 486e ffe8 pea %fp@(-24)
42b6e: 4eb9 0004 9964 jsr 49964 <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
42b74: 2f0b movel %a3,%sp@-
42b76: 486e ffd8 pea %fp@(-40)
42b7a: 4eb9 0004 9850 jsr 49850 <_Timespec_Add_to>
42b80: 4fef 0018 lea %sp@(24),%sp
42b84: 600a bras 42b90 <rtems_cpu_usage_report_with_plugin+0x108>
} else {
_TOD_Get_uptime( &uptime );
42b86: 2f03 movel %d3,%sp@-
42b88: 4eb9 0004 7820 jsr 47820 <_TOD_Get_uptime>
42b8e: 588f addql #4,%sp
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
42b90: 2f05 movel %d5,%sp@-
42b92: 2f03 movel %d3,%sp@-
42b94: 486e ffe0 pea %fp@(-32)
42b98: 4eb9 0004 9964 jsr 49964 <_Timespec_Subtract>
_Timestamp_Divide( &ran, &total, &ival, &fval );
42b9e: 486e fffc pea %fp@(-4)
42ba2: 486e fff8 pea %fp@(-8)
42ba6: 2f05 movel %d5,%sp@-
42ba8: 486e ffd8 pea %fp@(-40)
42bac: 4eb9 0004 9888 jsr 49888 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
42bb2: 2f2e fffc movel %fp@(-4),%sp@-
42bb6: 223c 0000 03e8 movel #1000,%d1
42bbc: 202e ffdc movel %fp@(-36),%d0
42bc0: 2f2e fff8 movel %fp@(-8),%sp@-
42bc4: 4c41 0000 remul %d1,%d0,%d0
42bc8: 2f00 movel %d0,%sp@-
42bca: 2f2e ffd8 movel %fp@(-40),%sp@-
42bce: 4879 0005 d956 pea 5d956 <map.6435+0x196>
42bd4: 2f02 movel %d2,%sp@-
42bd6: 4e92 jsr %a2@
42bd8: 4fef 0034 lea %sp@(52),%sp
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
42bdc: 5284 addql #1,%d4
42bde: 6002 bras 42be2 <rtems_cpu_usage_report_with_plugin+0x15a>
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
42be0: 7801 moveq #1,%d4
for ( i=1 ; i <= information->maximum ; i++ ) {
42be2: 4280 clrl %d0
42be4: 302d 000e movew %a5@(14),%d0
42be8: b084 cmpl %d4,%d0
42bea: 6400 ff08 bccw 42af4 <rtems_cpu_usage_report_with_plugin+0x6c>
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
42bee: b9fc 0006 0d44 cmpal #396612,%a4
42bf4: 6600 feee bnew 42ae4 <rtems_cpu_usage_report_with_plugin+0x5c>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
42bf8: 202e ffd4 movel %fp@(-44),%d0
42bfc: 263c 0000 03e8 movel #1000,%d3
42c02: 4c43 0000 remul %d3,%d0,%d0
42c06: 2f00 movel %d0,%sp@-
42c08: 2f2e ffd0 movel %fp@(-48),%sp@-
42c0c: 4879 0005 d96e pea 5d96e <map.6435+0x1ae>
42c12: 2f02 movel %d2,%sp@-
42c14: 4e92 jsr %a2@
42c16: 4fef 0010 lea %sp@(16),%sp
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
42c1a: 4cee 3cfc ff90 moveml %fp@(-112),%d2-%d7/%a2-%a5
42c20: 4e5e unlk %fp <== NOT EXECUTED
0004cca4 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
4cca4: 4e56 0000 linkw %fp,#0
4cca8: 202e 0008 movel %fp@(8),%d0
4ccac: 2f02 movel %d2,%sp@-
if (sc == RTEMS_SUCCESSFUL) {
4ccae: 4a80 tstl %d0
4ccb0: 6722 beqs 4ccd4 <rtems_deviceio_errno+0x30>
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
4ccb2: 721c moveq #28,%d1
4ccb4: b280 cmpl %d0,%d1
4ccb6: 650c bcss 4ccc4 <rtems_deviceio_errno+0x20> <== NEVER TAKEN
eno = status_code_to_errno [sc];
4ccb8: 41f9 0005 c878 lea 5c878 <status_code_to_errno>,%a0
4ccbe: 2430 0c00 movel %a0@(00000000,%d0:l:4),%d2
4ccc2: 6002 bras 4ccc6 <rtems_deviceio_errno+0x22>
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
4ccc4: 7416 moveq #22,%d2 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
4ccc6: 4eb9 0004 cd68 jsr 4cd68 <__errno>
4cccc: 2040 moveal %d0,%a0
return -1;
4ccce: 70ff moveq #-1,%d0
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
4ccd0: 2082 movel %d2,%a0@
return -1;
4ccd2: 6002 bras 4ccd6 <rtems_deviceio_errno+0x32>
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
4ccd4: 4280 clrl %d0
errno = eno;
return -1;
}
}
4ccd6: 242e fffc movel %fp@(-4),%d2
4ccda: 4e5e unlk %fp
...
00042742 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
42742: 4e56 ffec linkw %fp,#-20
42746: 48d7 041c moveml %d2-%d4/%a2,%sp@
4274a: 242e 0018 movel %fp@(24),%d2
4274e: 262e 001c movel %fp@(28),%d3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
42752: 42ae fffc clrl %fp@(-4)
rtems_blkdev_bnum end_block = begin_block + block_count;
sc = disk_lock();
42756: 4eba fd80 jsr %pc@(424d8 <disk_lock>)
4275a: 2800 movel %d0,%d4
if (sc != RTEMS_SUCCESSFUL) {
4275c: 6600 0094 bnew 427f2 <rtems_disk_create_log+0xb0>
return sc;
}
physical_disk = get_disk_entry(phys, true);
42760: 4878 0001 pea 1 <ADD>
42764: 2f2e 0014 movel %fp@(20),%sp@-
42768: 2f2e 0010 movel %fp@(16),%sp@-
4276c: 4eba fcc2 jsr %pc@(42430 <get_disk_entry>)
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
42770: 4fef 000c lea %sp@(12),%sp
42774: 4a80 tstl %d0
42776: 670a beqs 42782 <rtems_disk_create_log+0x40>
}
static bool
is_physical_disk(const rtems_disk_device *dd)
{
return dd->phys_dev == dd;
42778: 2040 moveal %d0,%a0
4277a: 2468 0008 moveal %a0@(8),%a2
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
physical_disk = get_disk_entry(phys, true);
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
4277e: b08a cmpl %a2,%d0
42780: 6708 beqs 4278a <rtems_disk_create_log+0x48>
disk_unlock();
42782: 4eba fd82 jsr %pc@(42506 <disk_unlock>)
return RTEMS_INVALID_ID;
42786: 7804 moveq #4,%d4
42788: 6068 bras 427f2 <rtems_disk_create_log+0xb0>
}
if (
begin_block >= physical_disk->size
4278a: 202a 001c movel %a2@(28),%d0
disk_unlock();
return RTEMS_INVALID_ID;
}
if (
4278e: b082 cmpl %d2,%d0
42790: 630c blss 4279e <rtems_disk_create_log+0x5c>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
rtems_blkdev_bnum end_block = begin_block + block_count;
42792: 2203 movel %d3,%d1
42794: d282 addl %d2,%d1
return RTEMS_INVALID_ID;
}
if (
begin_block >= physical_disk->size
|| end_block <= begin_block
42796: b481 cmpl %d1,%d2
42798: 6404 bccs 4279e <rtems_disk_create_log+0x5c> <== NEVER TAKEN
|| end_block > physical_disk->size
4279a: b081 cmpl %d1,%d0
4279c: 6408 bccs 427a6 <rtems_disk_create_log+0x64>
) {
disk_unlock();
4279e: 4eba fd66 jsr %pc@(42506 <disk_unlock>)
return RTEMS_INVALID_NUMBER;
427a2: 780a moveq #10,%d4
427a4: 604c bras 427f2 <rtems_disk_create_log+0xb0>
}
sc = create_disk(dev, name, &dd);
427a6: 486e fffc pea %fp@(-4)
427aa: 2f2e 0020 movel %fp@(32),%sp@-
427ae: 2f2e 000c movel %fp@(12),%sp@-
427b2: 2f2e 0008 movel %fp@(8),%sp@-
427b6: 4eba fd7c jsr %pc@(42534 <create_disk>)
if (sc != RTEMS_SUCCESSFUL) {
427ba: 4fef 0010 lea %sp@(16),%sp
disk_unlock();
return RTEMS_INVALID_NUMBER;
}
sc = create_disk(dev, name, &dd);
427be: 2800 movel %d0,%d4
if (sc != RTEMS_SUCCESSFUL) {
427c0: 662c bnes 427ee <rtems_disk_create_log+0xac>
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
427c2: 206e fffc moveal %fp@(-4),%a0
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
dd->ioctl = physical_disk->ioctl;
dd->driver_data = physical_disk->driver_data;
++physical_disk->uses;
427c6: 52aa 0014 addql #1,%a2@(20)
}
dd->phys_dev = physical_disk;
dd->start = begin_block;
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
427ca: 202a 0020 movel %a2@(32),%d0
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
427ce: 214a 0008 movel %a2,%a0@(8)
dd->start = begin_block;
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
dd->ioctl = physical_disk->ioctl;
427d2: 216a 0028 0028 movel %a2@(40),%a0@(40)
dd->driver_data = physical_disk->driver_data;
427d8: 216a 002c 002c movel %a2@(44),%a0@(44)
return sc;
}
dd->phys_dev = physical_disk;
dd->start = begin_block;
427de: 2142 0018 movel %d2,%a0@(24)
dd->size = block_count;
427e2: 2143 001c movel %d3,%a0@(28)
dd->block_size = dd->media_block_size = physical_disk->block_size;
427e6: 2140 0024 movel %d0,%a0@(36)
427ea: 2140 0020 movel %d0,%a0@(32)
dd->ioctl = physical_disk->ioctl;
dd->driver_data = physical_disk->driver_data;
++physical_disk->uses;
disk_unlock();
427ee: 4eba fd16 jsr %pc@(42506 <disk_unlock>)
return RTEMS_SUCCESSFUL;
}
427f2: 2004 movel %d4,%d0
427f4: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
427fa: 4e5e unlk %fp <== NOT EXECUTED
000426a8 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
426a8: 4e56 fff0 linkw %fp,#-16
426ac: 48d7 040c moveml %d2-%d3/%a2,%sp@
426b0: 262e 0010 movel %fp@(16),%d3
426b4: 246e 0018 moveal %fp@(24),%a2
rtems_disk_device *dd = NULL;
426b8: 42ae fffc clrl %fp@(-4)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
426bc: 4a8a tstl %a2
426be: 6770 beqs 42730 <rtems_disk_create_phys+0x88>
return RTEMS_INVALID_ADDRESS;
}
if (block_size == 0) {
426c0: 4a83 tstl %d3
426c2: 6770 beqs 42734 <rtems_disk_create_phys+0x8c>
return RTEMS_INVALID_NUMBER;
}
sc = disk_lock();
426c4: 4eba fe12 jsr %pc@(424d8 <disk_lock>)
426c8: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
426ca: 666a bnes 42736 <rtems_disk_create_phys+0x8e> <== NEVER TAKEN
return sc;
}
sc = create_disk(dev, name, &dd);
426cc: 486e fffc pea %fp@(-4)
426d0: 2f2e 0020 movel %fp@(32),%sp@-
426d4: 2f2e 000c movel %fp@(12),%sp@-
426d8: 2f2e 0008 movel %fp@(8),%sp@-
426dc: 4eba fe56 jsr %pc@(42534 <create_disk>)
if (sc != RTEMS_SUCCESSFUL) {
426e0: 4fef 0010 lea %sp@(16),%sp
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
sc = create_disk(dev, name, &dd);
426e4: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
426e6: 6642 bnes 4272a <rtems_disk_create_phys+0x82>
disk_unlock();
return sc;
}
dd->phys_dev = dd;
426e8: 206e fffc moveal %fp@(-4),%a0
dd->start = 0;
dd->size = block_count;
426ec: 216e 0014 001c movel %fp@(20),%a0@(28)
dd->block_size = dd->media_block_size = block_size;
dd->ioctl = handler;
dd->driver_data = driver_data;
426f2: 216e 001c 002c movel %fp@(28),%a0@(44)
disk_unlock();
return sc;
}
dd->phys_dev = dd;
426f8: 2148 0008 movel %a0,%a0@(8)
dd->start = 0;
426fc: 42a8 0018 clrl %a0@(24)
dd->size = block_count;
dd->block_size = dd->media_block_size = block_size;
42700: 2143 0024 movel %d3,%a0@(36)
42704: 2143 0020 movel %d3,%a0@(32)
dd->ioctl = handler;
42708: 214a 0028 movel %a2,%a0@(40)
dd->driver_data = driver_data;
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
4270c: 4868 000c pea %a0@(12)
42710: 2f3c 2000 4208 movel #536887816,%sp@-
42716: 2f08 movel %a0,%sp@-
42718: 4e92 jsr %a2@
4271a: 4fef 000c lea %sp@(12),%sp
4271e: 4a80 tstl %d0
42720: 6c08 bges 4272a <rtems_disk_create_phys+0x82> <== NEVER TAKEN
dd->capabilities = 0;
42722: 206e fffc moveal %fp@(-4),%a0
42726: 42a8 000c clrl %a0@(12)
}
disk_unlock();
4272a: 4eba fdda jsr %pc@(42506 <disk_unlock>)
return RTEMS_SUCCESSFUL;
4272e: 6006 bras 42736 <rtems_disk_create_phys+0x8e>
{
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
42730: 7409 moveq #9,%d2
42732: 6002 bras 42736 <rtems_disk_create_phys+0x8e>
}
if (block_size == 0) {
return RTEMS_INVALID_NUMBER;
42734: 740a moveq #10,%d2
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
42736: 2002 movel %d2,%d0
42738: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
4273e: 4e5e unlk %fp <== NOT EXECUTED
000427fe <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
427fe: 4e56 ffd8 linkw %fp,#-40
42802: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
42806: 4eba fcd0 jsr %pc@(424d8 <disk_lock>)
4280a: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
4280c: 6600 00f8 bnew 42906 <rtems_disk_delete+0x108>
return sc;
}
dd = get_disk_entry(dev, true);
42810: 4878 0001 pea 1 <ADD>
42814: 2f2e 000c movel %fp@(12),%sp@-
42818: 2f2e 0008 movel %fp@(8),%sp@-
4281c: 4eba fc12 jsr %pc@(42430 <get_disk_entry>)
if (dd == NULL) {
42820: 4fef 000c lea %sp@(12),%sp
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
dd = get_disk_entry(dev, true);
42824: 2040 moveal %d0,%a0
if (dd == NULL) {
42826: 4a80 tstl %d0
42828: 660c bnes 42836 <rtems_disk_delete+0x38> <== ALWAYS TAKEN
disk_unlock();
4282a: 4eba fcda jsr %pc@(42506 <disk_unlock>) <== NOT EXECUTED
return RTEMS_INVALID_ID;
4282e: 143c 0004 moveb #4,%d2 <== NOT EXECUTED
42832: 6000 00d2 braw 42906 <rtems_disk_delete+0x108> <== NOT EXECUTED
}
static void
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
42836: 2468 0008 moveal %a0@(8),%a2
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
4283a: 7001 moveq #1,%d0
4283c: 1140 0030 moveb %d0,%a0@(48)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
42840: 4a2a 0030 tstb %a2@(48)
42844: 6700 0094 beqw 428da <rtems_disk_delete+0xdc>
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
42848: 4287 clrl %d7
for (major = 0; major < disktab_size; ++major) {
4284a: 4283 clrl %d3
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
4284c: 49fa fc3c lea %pc@(4248a <free_disk_device>),%a4
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
42850: 2812 movel %a2@,%d4
42852: 2a2a 0004 movel %a2@(4),%d5
42856: 6054 bras 428ac <rtems_disk_delete+0xae>
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
42858: 2003 movel %d3,%d0
for (minor = 0; minor < dtab->size; ++minor) {
4285a: 4286 clrl %d6
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
4285c: e788 lsll #3,%d0
4285e: 2679 0006 15ce moveal 615ce <disktab>,%a3
42864: d7c0 addal %d0,%a3
42866: 603c bras 428a4 <rtems_disk_delete+0xa6>
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
42868: 2006 movel %d6,%d0
4286a: e588 lsll #2,%d0
4286c: 2253 moveal %a3@,%a1
4286e: d3c0 addal %d0,%a1
42870: 2051 moveal %a1@,%a0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
42872: 4a88 tstl %a0
42874: 672c beqs 428a2 <rtems_disk_delete+0xa4>
42876: 2a68 0008 moveal %a0@(8),%a5
4287a: 2015 movel %a5@,%d0
4287c: 222d 0004 movel %a5@(4),%d1
42880: 9285 subl %d5,%d1
42882: 9184 subxl %d4,%d0
42884: 661c bnes 428a2 <rtems_disk_delete+0xa4> <== NEVER TAKEN
42886: b5c8 cmpal %a0,%a2
42888: 6718 beqs 428a2 <rtems_disk_delete+0xa4>
if (dd->uses == 0) {
4288a: 4aa8 0014 tstl %a0@(20)
4288e: 660c bnes 4289c <rtems_disk_delete+0x9e>
++deleted_count;
dtab->minor [minor] = NULL;
42890: 4291 clrl %a1@
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
42892: 5287 addql #1,%d7
dtab->minor [minor] = NULL;
free_disk_device(dd);
42894: 2f08 movel %a0,%sp@-
42896: 4e94 jsr %a4@
42898: 588f addql #4,%sp
4289a: 6006 bras 428a2 <rtems_disk_delete+0xa4>
} else {
dd->deleted = true;
4289c: 7201 moveq #1,%d1
4289e: 1141 0030 moveb %d1,%a0@(48)
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
428a2: 5286 addql #1,%d6
428a4: bcab 0004 cmpl %a3@(4),%d6
428a8: 65be bcss 42868 <rtems_disk_delete+0x6a>
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
428aa: 5283 addql #1,%d3
428ac: b6b9 0006 15ca cmpl 615ca <disktab_size>,%d3
428b2: 65a4 bcss 42858 <rtems_disk_delete+0x5a>
}
}
}
}
physical_disk->uses -= deleted_count;
428b4: 202a 0014 movel %a2@(20),%d0
428b8: 9087 subl %d7,%d0
428ba: 2540 0014 movel %d0,%a2@(20)
if (physical_disk->uses == 0) {
428be: 6642 bnes 42902 <rtems_disk_delete+0x104>
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
428c0: 2012 movel %a2@,%d0
disktab [major].minor [minor] = NULL;
428c2: 2079 0006 15ce moveal 615ce <disktab>,%a0
428c8: e788 lsll #3,%d0
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
428ca: 222a 0004 movel %a2@(4),%d1
disktab [major].minor [minor] = NULL;
428ce: 2070 0800 moveal %a0@(00000000,%d0:l),%a0
428d2: 42b0 1c00 clrl %a0@(00000000,%d1:l:4)
free_disk_device(physical_disk);
428d6: 2f0a movel %a2,%sp@-
428d8: 6022 bras 428fc <rtems_disk_delete+0xfe>
}
} else {
if (disk_to_remove->uses == 0) {
428da: 4aa8 0014 tstl %a0@(20)
428de: 6622 bnes 42902 <rtems_disk_delete+0x104> <== NEVER TAKEN
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
428e0: 2010 movel %a0@,%d0
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
428e2: 53aa 0014 subql #1,%a2@(20)
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
428e6: 2279 0006 15ce moveal 615ce <disktab>,%a1
428ec: e788 lsll #3,%d0
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
428ee: 2228 0004 movel %a0@(4),%d1
disktab [major].minor [minor] = NULL;
428f2: 2271 0800 moveal %a1@(00000000,%d0:l),%a1
428f6: 42b1 1c00 clrl %a1@(00000000,%d1:l:4)
free_disk_device(disk_to_remove);
428fa: 2f08 movel %a0,%sp@-
428fc: 4eba fb8c jsr %pc@(4248a <free_disk_device>)
42900: 588f addql #4,%sp
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
42902: 4eba fc02 jsr %pc@(42506 <disk_unlock>)
return RTEMS_SUCCESSFUL;
}
42906: 2002 movel %d2,%d0
42908: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5
4290e: 4e5e unlk %fp <== NOT EXECUTED
00042a74 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
42a74: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
42a78: 4ab9 0006 15ca tstl 615ca <disktab_size>
42a7e: 6600 008a bnew 42b0a <rtems_disk_io_initialize+0x96>
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
42a82: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
42a86: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
42a8a: 4eb9 0004 3294 jsr 43294 <calloc>
if (disktab == NULL) {
42a90: 508f addql #8,%sp
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
42a92: 23c0 0006 15ce movel %d0,615ce <disktab>
if (disktab == NULL) {
42a98: 6774 beqs 42b0e <rtems_disk_io_initialize+0x9a> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
42a9a: 4879 0006 15c6 pea 615c6 <diskdevs_mutex>
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
42aa0: 4200 clrb %d0
sc = rtems_semaphore_create(
42aa2: 42a7 clrl %sp@-
42aa4: 4878 0010 pea 10 <INVALID_OPERATION>
42aa8: 4878 0001 pea 1 <ADD>
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
42aac: 13c0 0006 15c4 moveb %d0,615c4 <diskdevs_protected>
sc = rtems_semaphore_create(
42ab2: 2f3c 4444 4556 movel #1145324886,%sp@-
42ab8: 4eb9 0004 648c jsr 4648c <rtems_semaphore_create>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
42abe: 4fef 0014 lea %sp@(20),%sp
42ac2: 4a80 tstl %d0
42ac4: 6710 beqs 42ad6 <rtems_disk_io_initialize+0x62> <== ALWAYS TAKEN
free(disktab);
42ac6: 2f39 0006 15ce movel 615ce <disktab>,%sp@- <== NOT EXECUTED
42acc: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
42ad2: 588f addql #4,%sp <== NOT EXECUTED
42ad4: 6038 bras 42b0e <rtems_disk_io_initialize+0x9a> <== NOT EXECUTED
}
sc = rtems_bdbuf_init();
42ad6: 4eb9 0004 b4ea jsr 4b4ea <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
42adc: 4a80 tstl %d0
42ade: 671e beqs 42afe <rtems_disk_io_initialize+0x8a> <== ALWAYS TAKEN
rtems_semaphore_delete(diskdevs_mutex);
42ae0: 2f39 0006 15c6 movel 615c6 <diskdevs_mutex>,%sp@- <== NOT EXECUTED
42ae6: 4eb9 0004 662c jsr 4662c <rtems_semaphore_delete> <== NOT EXECUTED
free(disktab);
42aec: 2f39 0006 15ce movel 615ce <disktab>,%sp@- <== NOT EXECUTED
42af2: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
42af8: 508f addql #8,%sp <== NOT EXECUTED
42afa: 700d moveq #13,%d0 <== NOT EXECUTED
42afc: 6012 bras 42b10 <rtems_disk_io_initialize+0x9c> <== NOT EXECUTED
}
disktab_size = size;
42afe: 7008 moveq #8,%d0
42b00: 23c0 0006 15ca movel %d0,615ca <disktab_size>
return RTEMS_SUCCESSFUL;
42b06: 4200 clrb %d0
42b08: 6006 bras 42b10 <rtems_disk_io_initialize+0x9c>
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
42b0a: 4280 clrl %d0 <== NOT EXECUTED
42b0c: 6002 bras 42b10 <rtems_disk_io_initialize+0x9c> <== NOT EXECUTED
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
42b0e: 701a moveq #26,%d0 <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
42b10: 4e5e unlk %fp <== NOT EXECUTED
000429ca <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
429ca: 4e56 fff0 linkw %fp,#-16
429ce: 202e 0008 movel %fp@(8),%d0
429d2: 222e 000c movel %fp@(12),%d1
429d6: 48d7 041c moveml %d2-%d4/%a2,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
429da: 74ff moveq #-1,%d2
429dc: 76ff moveq #-1,%d3
429de: 9681 subl %d1,%d3
429e0: 9580 subxl %d0,%d2
429e2: 6718 beqs 429fc <rtems_disk_next+0x32>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
429e4: 2601 movel %d1,%d3
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
429e6: 2040 moveal %d0,%a0
429e8: 5283 addql #1,%d3
429ea: 74ff moveq #-1,%d2
429ec: b481 cmpl %d1,%d2
429ee: 6212 bhis 42a02 <rtems_disk_next+0x38> <== ALWAYS TAKEN
/* If major wraps around */
if ((major + 1) < major) {
429f0: 2408 movel %a0,%d2 <== NOT EXECUTED
429f2: 5282 addql #1,%d2 <== NOT EXECUTED
429f4: b1c2 cmpal %d2,%a0 <== NOT EXECUTED
429f6: 6270 bhis 42a68 <rtems_disk_next+0x9e> <== NOT EXECUTED
return NULL;
}
++major;
minor = 0;
429f8: 4283 clrl %d3 <== NOT EXECUTED
429fa: 6008 bras 42a04 <rtems_disk_next+0x3a> <== NOT EXECUTED
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
429fc: 4283 clrl %d3
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
429fe: 4282 clrl %d2
42a00: 6002 bras 42a04 <rtems_disk_next+0x3a>
return temp.__overlay.major;
42a02: 2400 movel %d0,%d2
} else {
++minor;
}
}
sc = disk_lock();
42a04: 4eba fad2 jsr %pc@(424d8 <disk_lock>)
if (sc != RTEMS_SUCCESSFUL) {
42a08: 4a80 tstl %d0
42a0a: 665c bnes 42a68 <rtems_disk_next+0x9e> <== NEVER TAKEN
return NULL;
}
if (major >= disktab_size) {
42a0c: 2239 0006 15ca movel 615ca <disktab_size>,%d1
42a12: b282 cmpl %d2,%d1
42a14: 6320 blss 42a36 <rtems_disk_next+0x6c> <== NEVER TAKEN
disk_unlock();
return NULL;
}
dtab = disktab + major;
42a16: 2802 movel %d2,%d4
42a18: 2039 0006 15ce movel 615ce <disktab>,%d0
42a1e: 2440 moveal %d0,%a2
42a20: e78c lsll #3,%d4
42a22: d5c4 addal %d4,%a2
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
42a24: 2052 moveal %a2@,%a0
42a26: 4a88 tstl %a0
42a28: 6706 beqs 42a30 <rtems_disk_next+0x66>
42a2a: b6aa 0004 cmpl %a2@(4),%d3
42a2e: 6518 bcss 42a48 <rtems_disk_next+0x7e> <== NEVER TAKEN
minor = 0;
++major;
42a30: 5282 addql #1,%d2
if (major >= disktab_size) {
42a32: b282 cmpl %d2,%d1
42a34: 6206 bhis 42a3c <rtems_disk_next+0x72>
disk_unlock();
42a36: 4eba face jsr %pc@(42506 <disk_unlock>)
42a3a: 602c bras 42a68 <rtems_disk_next+0x9e>
return NULL;
}
dtab = disktab + major;
42a3c: 2602 movel %d2,%d3
42a3e: 2440 moveal %d0,%a2
42a40: e78b lsll #3,%d3
42a42: d5c3 addal %d3,%a2
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
42a44: 4283 clrl %d3
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
42a46: 60dc bras 42a24 <rtems_disk_next+0x5a>
} else if (dtab->minor [minor] == NULL) {
42a48: 2803 movel %d3,%d4
42a4a: e58c lsll #2,%d4
42a4c: 2070 4800 moveal %a0@(00000000,%d4:l),%a0
42a50: 4a88 tstl %a0
42a52: 6604 bnes 42a58 <rtems_disk_next+0x8e>
++minor;
42a54: 5283 addql #1,%d3
42a56: 60cc bras 42a24 <rtems_disk_next+0x5a>
} else {
++dtab->minor [minor]->uses;
42a58: 52a8 0014 addql #1,%a0@(20)
disk_unlock();
42a5c: 4eba faa8 jsr %pc@(42506 <disk_unlock>)
return dtab->minor [minor];
42a60: 2052 moveal %a2@,%a0
42a62: 2030 4800 movel %a0@(00000000,%d4:l),%d0
42a66: 6002 bras 42a6a <rtems_disk_next+0xa0>
}
}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
42a68: 4280 clrl %d0
disk_unlock();
return dtab->minor [minor];
}
}
}
42a6a: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
42a70: 4e5e unlk %fp <== NOT EXECUTED
00042912 <rtems_disk_obtain>:
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
rtems_interrupt_level level;
rtems_interrupt_disable(level);
42912: 203c 0000 0700 movel #1792,%d0
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
42918: 4e56 fff0 linkw %fp,#-16
4291c: 48d7 001c moveml %d2-%d4,%sp@
42920: 242e 0008 movel %fp@(8),%d2
42924: 262e 000c movel %fp@(12),%d3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
rtems_interrupt_level level;
rtems_interrupt_disable(level);
42928: 40c4 movew %sr,%d4
4292a: 8084 orl %d4,%d0
4292c: 46c0 movew %d0,%sr
if (!diskdevs_protected) {
4292e: 1039 0006 15c4 moveb 615c4 <diskdevs_protected>,%d0
42934: 6612 bnes 42948 <rtems_disk_obtain+0x36> <== NEVER TAKEN
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
42936: 42a7 clrl %sp@-
42938: 2f03 movel %d3,%sp@-
4293a: 2f02 movel %d2,%sp@-
4293c: 4eba faf2 jsr %pc@(42430 <get_disk_entry>)
rtems_interrupt_enable(level);
42940: 46c4 movew %d4,%sr
42942: 4fef 000c lea %sp@(12),%sp
42946: 6028 bras 42970 <rtems_disk_obtain+0x5e>
} else {
rtems_interrupt_enable(level);
42948: 46c4 movew %d4,%sr <== NOT EXECUTED
sc = disk_lock();
4294a: 4eba fb8c jsr %pc@(424d8 <disk_lock>) <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
4294e: 4a80 tstl %d0 <== NOT EXECUTED
42950: 661c bnes 4296e <rtems_disk_obtain+0x5c> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
42952: 42a7 clrl %sp@- <== NOT EXECUTED
42954: 2f03 movel %d3,%sp@- <== NOT EXECUTED
42956: 2f02 movel %d2,%sp@- <== NOT EXECUTED
42958: 4eba fad6 jsr %pc@(42430 <get_disk_entry>) <== NOT EXECUTED
disk_unlock();
4295c: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
42960: 4eba fba4 jsr %pc@(42506 <disk_unlock>) <== NOT EXECUTED
42964: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
42968: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4296c: 6002 bras 42970 <rtems_disk_obtain+0x5e> <== NOT EXECUTED
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
4296e: 4280 clrl %d0 <== NOT EXECUTED
disk_unlock();
}
}
return dd;
}
42970: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
42976: 4e5e unlk %fp <== NOT EXECUTED
00046ff0 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
46ff0: 4e56 fff4 linkw %fp,#-12
46ff4: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
46ff8: 242e 0008 movel %fp@(8),%d2
46ffc: 266e 0010 moveal %fp@(16),%a3
Extension_Control *the_extension;
if ( !id )
47000: 4a8b tstl %a3
47002: 6778 beqs 4707c <rtems_extension_create+0x8c> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
47004: 4a82 tstl %d2
47006: 6778 beqs 47080 <rtems_extension_create+0x90> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
47008: 2039 0006 0d78 movel 60d78 <_Thread_Dispatch_disable_level>,%d0
4700e: 5280 addql #1,%d0
47010: 23c0 0006 0d78 movel %d0,60d78 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47016: 2039 0006 0d78 movel 60d78 <_Thread_Dispatch_disable_level>,%d0
#ifndef __EXTENSION_MANAGER_inl
#define __EXTENSION_MANAGER_inl
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
4701c: 4879 0006 0ed8 pea 60ed8 <_Extension_Information>
47022: 4eb9 0004 7dd4 jsr 47dd4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
47028: 588f addql #4,%sp
4702a: 2440 moveal %d0,%a2
4702c: 4a80 tstl %d0
4702e: 660a bnes 4703a <rtems_extension_create+0x4a>
_Thread_Enable_dispatch();
47030: 4eb9 0004 8f2c jsr 48f2c <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
47036: 7005 moveq #5,%d0
47038: 6048 bras 47082 <rtems_extension_create+0x92>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
4703a: 4878 0020 pea 20 <OPER2+0xc>
4703e: 2f2e 000c movel %fp@(12),%sp@-
47042: 486a 0024 pea %a2@(36)
47046: 4eb9 0004 e71c jsr 4e71c <memcpy>
_User_extensions_Add_set( extension );
4704c: 486a 0010 pea %a2@(16)
47050: 4eb9 0004 99ac jsr 499ac <_User_extensions_Add_set>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
47056: 202a 0008 movel %a2@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4705a: 4281 clrl %d1
4705c: 2079 0006 0ef0 moveal 60ef0 <_Extension_Information+0x18>,%a0
47062: 3200 movew %d0,%d1
47064: 218a 1c00 movel %a2,%a0@(00000000,%d1:l:4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
47068: 2542 000c movel %d2,%a2@(12)
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
4706c: 2680 movel %d0,%a3@
_Thread_Enable_dispatch();
4706e: 4eb9 0004 8f2c jsr 48f2c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
47074: 4fef 0010 lea %sp@(16),%sp
47078: 4280 clrl %d0
4707a: 6006 bras 47082 <rtems_extension_create+0x92>
)
{
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
4707c: 7009 moveq #9,%d0
4707e: 6002 bras 47082 <rtems_extension_create+0x92>
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
47080: 7003 moveq #3,%d0
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
47082: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
47088: 4e5e unlk %fp <== NOT EXECUTED
0004a144 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4a144: 4e56 fff8 linkw %fp,#-8
4a148: 202e 0008 movel %fp@(8),%d0
find_arg fa = {
4a14c: 42ae fffc clrl %fp@(-4)
4a150: 2d40 fff8 movel %d0,%fp@(-8)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4a154: 6710 beqs 4a166 <rtems_filesystem_get_mount_handler+0x22><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
4a156: 486e fff8 pea %fp@(-8)
4a15a: 487a ff14 pea %pc@(4a070 <find_handler>)
4a15e: 4eb9 0004 a0da jsr 4a0da <rtems_filesystem_iterate>
4a164: 508f addql #8,%sp
}
return fa.mount_h;
}
4a166: 202e fffc movel %fp@(-4),%d0
4a16a: 4e5e unlk %fp <== NOT EXECUTED
000426d8 <rtems_filesystem_initialize>:
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
426d8: 7012 moveq #18,%d0
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
426da: 4e56 ffe0 linkw %fp,#-32
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
426de: 2079 0005 d420 moveal 5d420 <rtems_current_user_env>,%a0
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
426e4: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
426e8: 2140 002c movel %d0,%a0@(44)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
426ec: 4ab9 0005 b604 tstl 5b604 <rtems_filesystem_mount_table_size>
426f2: 6608 bnes 426fc <rtems_filesystem_initialize+0x24><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
426f4: 2f3c abcd 0001 movel #-1412628479,%sp@- <== NOT EXECUTED
426fa: 602c bras 42728 <rtems_filesystem_initialize+0x50><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
426fc: 2079 0005 d2da moveal 5d2da <rtems_filesystem_mount_table>,%a0
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
42702: 42a7 clrl %sp@-
42704: 2f28 0004 movel %a0@(4),%sp@-
42708: 2f10 movel %a0@,%sp@-
4270a: 2f28 000c movel %a0@(12),%sp@-
4270e: 2f28 0008 movel %a0@(8),%sp@-
42712: 4eb9 0004 3066 jsr 43066 <mount>
if ( status == -1 )
42718: 4fef 0014 lea %sp@(20),%sp
4271c: 72ff moveq #-1,%d1
4271e: b280 cmpl %d0,%d1
42720: 660c bnes 4272e <rtems_filesystem_initialize+0x56><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
42722: 2f3c abcd 0002 movel #-1412628478,%sp@- <== NOT EXECUTED
42728: 4eb9 0004 60a4 jsr 460a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_filesystem_link_counts = 0;
4272e: 2079 0005 d420 moveal 5d420 <rtems_current_user_env>,%a0
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
42734: 240e movel %fp,%d2
42736: 0682 ffff ffec addil #-20,%d2
4273c: 47f9 0004 2a88 lea 42a88 <rtems_filesystem_evaluate_path>,%a3
rtems_filesystem_root = loc;
42742: 45f9 0004 d588 lea 4d588 <memcpy>,%a2
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
42748: 4240 clrw %d0
4274a: 3140 0030 movew %d0,%a0@(48)
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
4274e: 42a7 clrl %sp@-
42750: 2f02 movel %d2,%sp@-
42752: 42a7 clrl %sp@-
42754: 4878 0001 pea 1 <ADD>
42758: 4879 0005 bdc8 pea 5bdc8 <IMFS_ops+0x48>
4275e: 4e93 jsr %a3@
rtems_filesystem_root = loc;
42760: 4878 0014 pea 14 <OPER2>
42764: 2079 0005 d420 moveal 5d420 <rtems_current_user_env>,%a0
4276a: 41e8 0018 lea %a0@(24),%a0
4276e: 2f02 movel %d2,%sp@-
42770: 2f08 movel %a0,%sp@-
42772: 4e92 jsr %a2@
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
42774: 4fef 001c lea %sp@(28),%sp
42778: 4297 clrl %sp@
4277a: 2f02 movel %d2,%sp@-
4277c: 42a7 clrl %sp@-
4277e: 4878 0001 pea 1 <ADD>
42782: 4879 0005 bdc8 pea 5bdc8 <IMFS_ops+0x48>
42788: 4e93 jsr %a3@
rtems_filesystem_current = loc;
4278a: 4878 0014 pea 14 <OPER2>
4278e: 2039 0005 d420 movel 5d420 <rtems_current_user_env>,%d0
42794: 5880 addql #4,%d0
42796: 2f02 movel %d2,%sp@-
42798: 2f00 movel %d0,%sp@-
4279a: 4e92 jsr %a2@
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
4279c: 4fef 0020 lea %sp@(32),%sp
427a0: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
427a4: 4879 0005 bdca pea 5bdca <IMFS_ops+0x4a>
427aa: 4eb9 0004 2f00 jsr 42f00 <mkdir>
if ( status != 0 )
427b0: 508f addql #8,%sp
427b2: 4a80 tstl %d0
427b4: 670a beqs 427c0 <rtems_filesystem_initialize+0xe8><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
427b6: 2f3c abcd 0003 movel #-1412628477,%sp@- <== NOT EXECUTED
427bc: 6000 ff6a braw 42728 <rtems_filesystem_initialize+0x50><== NOT EXECUTED
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
427c0: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3
427c6: 4e5e unlk %fp
...
0004a0da <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
4a0da: 4e56 fff0 linkw %fp,#-16
4a0de: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4a0e2: 266e 0008 moveal %fp@(8),%a3
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
4a0e6: 45f9 0005 b618 lea 5b618 <rtems_filesystem_table>,%a2
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
4a0ec: 242e 000c movel %fp@(12),%d2
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
4a0f0: 4203 clrb %d3
while ( table_entry->type && !stop ) {
4a0f2: 600c bras 4a100 <rtems_filesystem_iterate+0x26>
stop = (*routine)( table_entry, routine_arg );
4a0f4: 2f02 movel %d2,%sp@-
4a0f6: 2f0a movel %a2,%sp@-
++table_entry;
4a0f8: 508a addql #8,%a2
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
stop = (*routine)( table_entry, routine_arg );
4a0fa: 4e93 jsr %a3@
++table_entry;
4a0fc: 508f addql #8,%sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
stop = (*routine)( table_entry, routine_arg );
4a0fe: 1600 moveb %d0,%d3
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
4a100: 4a92 tstl %a2@
4a102: 6706 beqs 4a10a <rtems_filesystem_iterate+0x30>
4a104: 4a03 tstb %d3
4a106: 67ec beqs 4a0f4 <rtems_filesystem_iterate+0x1a>
4a108: 602e bras 4a138 <rtems_filesystem_iterate+0x5e>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
4a10a: 4a03 tstb %d3
4a10c: 662a bnes 4a138 <rtems_filesystem_iterate+0x5e>
rtems_libio_lock();
4a10e: 4eba ff98 jsr %pc@(4a0a8 <rtems_libio_lock>)
4a112: 2479 0005 d428 moveal 5d428 <filesystem_chain>,%a2
for (
4a118: 600e bras 4a128 <rtems_filesystem_iterate+0x4e>
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
4a11a: 2f02 movel %d2,%sp@-
4a11c: 486a 0008 pea %a2@(8)
4a120: 4e93 jsr %a3@
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
4a122: 2452 moveal %a2@,%a2
4a124: 508f addql #8,%sp
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
4a126: 1600 moveb %d0,%d3
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
4a128: b5fc 0005 d42c cmpal #381996,%a2
4a12e: 6704 beqs 4a134 <rtems_filesystem_iterate+0x5a>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
4a130: 4a03 tstb %d3
4a132: 67e6 beqs 4a11a <rtems_filesystem_iterate+0x40> <== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
4a134: 4eba ff8e jsr %pc@(4a0c4 <rtems_libio_unlock>)
}
return stop;
}
4a138: 1003 moveb %d3,%d0
4a13a: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4a140: 4e5e unlk %fp <== NOT EXECUTED
00043018 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
43018: 4e56 fff0 linkw %fp,#-16
4301c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
43020: 266e 0008 moveal %fp@(8),%a3
43024: 262e 000c movel %fp@(12),%d3
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
43028: 4eba ffd2 jsr %pc@(42ffc <rtems_libio_lock>)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4302c: 2479 0005 d304 moveal 5d304 <mount_chain>,%a2
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
43032: 4202 clrb %d2
rtems_libio_lock();
for (
43034: 600c bras 43042 <rtems_filesystem_mount_iterate+0x2a>
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
43036: 2f03 movel %d3,%sp@-
43038: 2f0a movel %a2,%sp@-
4303a: 4e93 jsr %a3@
}
rtems_libio_unlock();
return stop;
}
4303c: 2452 moveal %a2@,%a2
4303e: 508f addql #8,%sp
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
43040: 1400 moveb %d0,%d2
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
43042: b5fc 0005 d308 cmpal #381704,%a2
43048: 6704 beqs 4304e <rtems_filesystem_mount_iterate+0x36>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
4304a: 4a02 tstb %d2
4304c: 67e8 beqs 43036 <rtems_filesystem_mount_iterate+0x1e><== ALWAYS TAKEN
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4304e: 2f39 0005 ea4c movel 5ea4c <rtems_libio_semaphore>,%sp@-
43054: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
4305a: 1002 moveb %d2,%d0
4305c: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
43062: 4e5e unlk %fp <== NOT EXECUTED
0004324e <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
4324e: 4e56 0000 linkw %fp,#0
43252: 2f0a movel %a2,%sp@-
43254: 2f02 movel %d2,%sp@-
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
43256: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
4325a: 242e 000c movel %fp@(12),%d2
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
4325e: 4eb9 0004 3638 jsr 43638 <malloc>
*key = new_key;
43264: 206e 0008 moveal %fp@(8),%a0
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
43268: 2440 moveal %d0,%a2
*key = new_key;
4326a: 2080 movel %d0,%a0@
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
4326c: 2f02 movel %d2,%sp@-
4326e: 2f00 movel %d0,%sp@-
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
*key = new_key;
new_key->val = NULL;
43270: 4292 clrl %a2@
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
43272: 42a7 clrl %sp@-
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
*key = new_key;
new_key->val = NULL;
new_key->dtor = dtor;
43274: 2542 0004 movel %d2,%a2@(4)
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
43278: 4eb9 0004 6784 jsr 46784 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
4327e: 4fef 0010 lea %sp@(16),%sp
43282: 4a80 tstl %d0
43284: 670e beqs 43294 <rtems_gxx_key_create+0x46> <== ALWAYS TAKEN
return 0;
free( new_key );
43286: 2f0a movel %a2,%sp@- <== NOT EXECUTED
43288: 4eb9 0004 30e8 jsr 430e8 <free> <== NOT EXECUTED
return -1;
4328e: 588f addql #4,%sp <== NOT EXECUTED
43290: 70ff moveq #-1,%d0 <== NOT EXECUTED
43292: 6002 bras 43296 <rtems_gxx_key_create+0x48> <== NOT EXECUTED
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
if ( status == RTEMS_SUCCESSFUL )
return 0;
43294: 4280 clrl %d0
free( new_key );
return -1;
}
43296: 242e fff8 movel %fp@(-8),%d2
4329a: 246e fffc moveal %fp@(-4),%a2
4329e: 4e5e unlk %fp <== NOT EXECUTED
000432b2 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
432b2: 4e56 0000 linkw %fp,#0
432b6: 2f0a movel %a2,%sp@-
432b8: 246e 0008 moveal %fp@(8),%a2
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
432bc: 2f0a movel %a2,%sp@-
432be: 42a7 clrl %sp@-
432c0: 4eb9 0004 6814 jsr 46814 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
432c6: 508f addql #8,%sp
432c8: 4a80 tstl %d0
432ca: 660e bnes 432da <rtems_gxx_key_delete+0x28> <== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
432cc: 4a8a tstl %a2
432ce: 670a beqs 432da <rtems_gxx_key_delete+0x28> <== NEVER TAKEN
432d0: 2f12 movel %a2@,%sp@-
432d2: 4eb9 0004 30e8 jsr 430e8 <free>
432d8: 588f addql #4,%sp
return 0;
}
key = NULL;
return 0;
}
432da: 246e fffc moveal %fp@(-4),%a2
432de: 4280 clrl %d0
432e0: 4e5e unlk %fp <== NOT EXECUTED
000431f4 <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
431f4: 4e56 fff0 linkw %fp,#-16
431f8: 48d7 040c moveml %d2-%d3/%a2,%sp@
431fc: 246e 0008 moveal %fp@(8),%a2
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
43200: 2012 movel %a2@,%d0
43202: 663e bnes 43242 <rtems_gxx_once+0x4e>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
43204: 260e movel %fp,%d3
43206: 5983 subql #4,%d3
43208: 2f03 movel %d3,%sp@-
4320a: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
4320e: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
43212: 4eb9 0004 65b0 jsr 465b0 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
43218: 2412 movel %a2@,%d2
4321a: 4fef 000c lea %sp@(12),%sp
4321e: 6604 bnes 43224 <rtems_gxx_once+0x30> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
43220: 7001 moveq #1,%d0
43222: 2480 movel %d0,%a2@
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
43224: 2f03 movel %d3,%sp@-
43226: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
4322a: 2f2e fffc movel %fp@(-4),%sp@-
4322e: 4eb9 0004 65b0 jsr 465b0 <rtems_task_mode>
if ( o == 0 )
43234: 4fef 000c lea %sp@(12),%sp
43238: 4a82 tstl %d2
4323a: 6606 bnes 43242 <rtems_gxx_once+0x4e> <== NEVER TAKEN
(*func)();
4323c: 206e 000c moveal %fp@(12),%a0
43240: 4e90 jsr %a0@
}
return 0;
}
43242: 4280 clrl %d0
43244: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
4324a: 4e5e unlk %fp <== NOT EXECUTED
00043340 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
43340: 4e56 0000 linkw %fp,#0
43344: 2f0a movel %a2,%sp@-
43346: 246e 0008 moveal %fp@(8),%a2
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
4334a: 2f2a 0004 movel %a2@(4),%sp@-
4334e: 2f0a movel %a2,%sp@-
43350: 42a7 clrl %sp@-
43352: 4eb9 0004 6784 jsr 46784 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
43358: 4fef 000c lea %sp@(12),%sp
4335c: 4a80 tstl %d0
4335e: 6606 bnes 43366 <rtems_gxx_setspecific+0x26> <== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
43360: 24ae 000c movel %fp@(12),%a2@
return 0;
43364: 6002 bras 43368 <rtems_gxx_setspecific+0x28>
}
return -1;
43366: 70ff moveq #-1,%d0 <== NOT EXECUTED
}
43368: 246e fffc moveal %fp@(-4),%a2
4336c: 4e5e unlk %fp <== NOT EXECUTED
00046e08 <rtems_heap_allocate_aligned_with_boundary>:
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
if (
46e08: 7003 moveq #3,%d0
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
46e0a: 4e56 0000 linkw %fp,#0
if (
46e0e: b0b9 0006 42d8 cmpl 642d8 <_System_state_Current>,%d0
46e14: 660a bnes 46e20 <rtems_heap_allocate_aligned_with_boundary+0x18><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
46e16: 4eb9 0004 5f70 jsr 45f70 <malloc_is_system_state_OK>
46e1c: 4a00 tstb %d0
46e1e: 6724 beqs 46e44 <rtems_heap_allocate_aligned_with_boundary+0x3c>
) {
return NULL;
}
malloc_deferred_frees_process();
46e20: 4eb9 0004 5fae jsr 45fae <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
46e26: 2f2e 0010 movel %fp@(16),%sp@-
46e2a: 2f2e 000c movel %fp@(12),%sp@-
46e2e: 2f2e 0008 movel %fp@(8),%sp@-
46e32: 2f39 0006 1fae movel 61fae <RTEMS_Malloc_Heap>,%sp@-
46e38: 4eb9 0004 b43c jsr 4b43c <_Protected_heap_Allocate_aligned_with_boundary>
46e3e: 4fef 0010 lea %sp@(16),%sp
46e42: 6002 bras 46e46 <rtems_heap_allocate_aligned_with_boundary+0x3e>
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
) {
return NULL;
46e44: 4280 clrl %d0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
46e46: 4e5e unlk %fp
...
0004ca18 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4ca18: 4e56 0000 linkw %fp,#0
4ca1c: 202e 0008 movel %fp@(8),%d0
4ca20: 2f03 movel %d3,%sp@-
4ca22: 2f02 movel %d2,%sp@-
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4ca24: b0b9 0005 f412 cmpl 5f412 <_IO_Number_of_drivers>,%d0
4ca2a: 6420 bccs 4ca4c <rtems_io_close+0x34> <== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4ca2c: 2600 movel %d0,%d3
4ca2e: 2200 movel %d0,%d1
4ca30: e78b lsll #3,%d3
4ca32: eb89 lsll #5,%d1
4ca34: 2279 0005 f416 moveal 5f416 <_IO_Driver_address_table>,%a1
4ca3a: 9283 subl %d3,%d1
4ca3c: 2271 1808 moveal %a1@(00000008,%d1:l),%a1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4ca40: 4a89 tstl %a1
4ca42: 670c beqs 4ca50 <rtems_io_close+0x38>
}
4ca44: 241f movel %sp@+,%d2
4ca46: 261f movel %sp@+,%d3
4ca48: 4e5e unlk %fp
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4ca4a: 4ed1 jmp %a1@
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
4ca4c: 700a moveq #10,%d0
4ca4e: 6002 bras 4ca52 <rtems_io_close+0x3a>
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4ca50: 4280 clrl %d0
}
4ca52: 241f movel %sp@+,%d2
4ca54: 261f movel %sp@+,%d3
4ca56: 4e5e unlk %fp
...
00042648 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
42648: 4e56 ffd4 linkw %fp,#-44
4264c: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
42650: 262e 0008 movel %fp@(8),%d3
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
42654: 49f9 0004 e0d4 lea 4e0d4 <strlen>,%a4
4265a: 240e movel %fp,%d2
4265c: 0682 ffff ffec addil #-20,%d2
42662: 2f03 movel %d3,%sp@-
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
42664: 246e 000c moveal %fp@(12),%a2
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
42668: 4e94 jsr %a4@
4266a: 7201 moveq #1,%d1
4266c: 2e81 movel %d1,%sp@
4266e: 2f02 movel %d2,%sp@-
42670: 42a7 clrl %sp@-
42672: 2f00 movel %d0,%sp@-
42674: 2f03 movel %d3,%sp@-
42676: 4eb9 0004 2a88 jsr 42a88 <rtems_filesystem_evaluate_path>
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
4267c: 206e fff8 moveal %fp@(-8),%a0
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
42680: 2800 movel %d0,%d4
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
42682: 2f02 movel %d2,%sp@-
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
42684: 266e ffec moveal %fp@(-20),%a3
node_type = (*loc.ops->node_type_h)( &loc );
42688: 2068 0010 moveal %a0@(16),%a0
4268c: 4e90 jsr %a0@
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
4268e: 4fef 0018 lea %sp@(24),%sp
42692: 4a84 tstl %d4
42694: 6606 bnes 4269c <rtems_io_lookup_name+0x54> <== NEVER TAKEN
42696: 7202 moveq #2,%d1
42698: b280 cmpl %d0,%d1
4269a: 670e beqs 426aa <rtems_io_lookup_name+0x62>
rtems_filesystem_freenode( &loc );
4269c: 2f02 movel %d2,%sp@-
4269e: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
426a4: 588f addql #4,%sp
426a6: 700d moveq #13,%d0
426a8: 6022 bras 426cc <rtems_io_lookup_name+0x84>
}
device_info->device_name = (char *) name;
426aa: 2483 movel %d3,%a2@
device_info->device_name_length = strlen( name );
426ac: 2f03 movel %d3,%sp@-
426ae: 4e94 jsr %a4@
426b0: 2540 0004 movel %d0,%a2@(4)
device_info->major = the_jnode->info.device.major;
426b4: 256b 004c 0008 movel %a3@(76),%a2@(8)
device_info->minor = the_jnode->info.device.minor;
426ba: 256b 0050 000c movel %a3@(80),%a2@(12)
rtems_filesystem_freenode( &loc );
426c0: 2e82 movel %d2,%sp@
426c2: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
426c8: 588f addql #4,%sp
426ca: 4280 clrl %d0
}
426cc: 4cee 1c1c ffd4 moveml %fp@(-44),%d2-%d4/%a2-%a4
426d2: 4e5e unlk %fp
...
00046e1c <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
46e1c: 4e56 0000 linkw %fp,#0
46e20: 206e 000c moveal %fp@(12),%a0
46e24: 2f0a movel %a2,%sp@-
46e26: 226e 0010 moveal %fp@(16),%a1
46e2a: 2f02 movel %d2,%sp@-
46e2c: 242e 0008 movel %fp@(8),%d2
rtems_device_major_number major_limit = _IO_Number_of_drivers;
46e30: 2039 0006 282a movel 6282a <_IO_Number_of_drivers>,%d0
if ( rtems_interrupt_is_in_progress() )
46e36: 4ab9 0006 240e tstl 6240e <_Per_CPU_Information+0x8>
46e3c: 6600 00de bnew 46f1c <rtems_io_register_driver+0x100>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
46e40: 4a89 tstl %a1
46e42: 6700 00dc beqw 46f20 <rtems_io_register_driver+0x104>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
46e46: 2280 movel %d0,%a1@
if ( driver_table == NULL )
46e48: 4a88 tstl %a0
46e4a: 6700 00d4 beqw 46f20 <rtems_io_register_driver+0x104>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46e4e: 4a90 tstl %a0@
46e50: 6600 00e0 bnew 46f32 <rtems_io_register_driver+0x116>
46e54: 4aa8 0004 tstl %a0@(4)
46e58: 6600 00d8 bnew 46f32 <rtems_io_register_driver+0x116>
46e5c: 6000 00c2 braw 46f20 <rtems_io_register_driver+0x104>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
46e60: 2039 0006 1fb0 movel 61fb0 <_Thread_Dispatch_disable_level>,%d0
46e66: 5280 addql #1,%d0
46e68: 23c0 0006 1fb0 movel %d0,61fb0 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
46e6e: 2039 0006 1fb0 movel 61fb0 <_Thread_Dispatch_disable_level>,%d0
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
46e74: 4a82 tstl %d2
46e76: 662c bnes 46ea4 <rtems_io_register_driver+0x88>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
46e78: 2039 0006 282a movel 6282a <_IO_Number_of_drivers>,%d0
46e7e: 2479 0006 282e moveal 6282e <_IO_Driver_address_table>,%a2
46e84: 6010 bras 46e96 <rtems_io_register_driver+0x7a>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46e86: 4a92 tstl %a2@
46e88: 6600 00b0 bnew 46f3a <rtems_io_register_driver+0x11e>
46e8c: 4aaa 0004 tstl %a2@(4)
46e90: 6600 00a8 bnew 46f3a <rtems_io_register_driver+0x11e>
46e94: 6004 bras 46e9a <rtems_io_register_driver+0x7e>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
46e96: b082 cmpl %d2,%d0
46e98: 66ec bnes 46e86 <rtems_io_register_driver+0x6a>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
46e9a: 2282 movel %d2,%a1@
if ( m != n )
46e9c: b082 cmpl %d2,%d0
46e9e: 6638 bnes 46ed8 <rtems_io_register_driver+0xbc>
46ea0: 6000 00a2 braw 46f44 <rtems_io_register_driver+0x128>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
46ea4: 2202 movel %d2,%d1
46ea6: 2002 movel %d2,%d0
46ea8: e789 lsll #3,%d1
46eaa: eb88 lsll #5,%d0
46eac: 2479 0006 282e moveal 6282e <_IO_Driver_address_table>,%a2
46eb2: 9081 subl %d1,%d0
46eb4: d5c0 addal %d0,%a2
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46eb6: 4a92 tstl %a2@
46eb8: 660c bnes 46ec6 <rtems_io_register_driver+0xaa>
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
}
rtems_status_code rtems_io_register_driver(
46eba: 4aaa 0004 tstl %a2@(4)
46ebe: 57c0 seq %d0
46ec0: 49c0 extbl %d0
46ec2: 4480 negl %d0
46ec4: 6002 bras 46ec8 <rtems_io_register_driver+0xac>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46ec6: 4280 clrl %d0
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
46ec8: 4a00 tstb %d0
46eca: 660a bnes 46ed6 <rtems_io_register_driver+0xba>
_Thread_Enable_dispatch();
46ecc: 4eb9 0004 8bc4 jsr 48bc4 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
46ed2: 700c moveq #12,%d0
46ed4: 6050 bras 46f26 <rtems_io_register_driver+0x10a>
}
*registered_major = major;
46ed6: 2282 movel %d2,%a1@
}
_IO_Driver_address_table [major] = *driver_table;
46ed8: 2202 movel %d2,%d1
46eda: 2002 movel %d2,%d0
46edc: 4878 0018 pea 18 <OPER2+0x4>
46ee0: e789 lsll #3,%d1
46ee2: eb88 lsll #5,%d0
46ee4: 2f08 movel %a0,%sp@-
46ee6: 9081 subl %d1,%d0
46ee8: d0b9 0006 282e addl 6282e <_IO_Driver_address_table>,%d0
46eee: 2f00 movel %d0,%sp@-
46ef0: 4eb9 0005 0b90 jsr 50b90 <memcpy>
_Thread_Enable_dispatch();
46ef6: 4eb9 0004 8bc4 jsr 48bc4 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
}
46efc: 246e fffc moveal %fp@(-4),%a2
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46f00: 4fef 000c lea %sp@(12),%sp
46f04: 2d42 0008 movel %d2,%fp@(8)
}
46f08: 242e fff8 movel %fp@(-8),%d2
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46f0c: 42ae 0010 clrl %fp@(16)
46f10: 42ae 000c clrl %fp@(12)
}
46f14: 4e5e unlk %fp
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46f16: 4ef9 0004 e388 jmp 4e388 <rtems_io_initialize>
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
46f1c: 7012 moveq #18,%d0
46f1e: 6006 bras 46f26 <rtems_io_register_driver+0x10a>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
46f20: 7009 moveq #9,%d0
46f22: 6002 bras 46f26 <rtems_io_register_driver+0x10a>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
46f24: 700a moveq #10,%d0
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
46f26: 242e fff8 movel %fp@(-8),%d2
46f2a: 246e fffc moveal %fp@(-4),%a2
46f2e: 4e5e unlk %fp
46f30: 4e75 rts
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
46f32: b082 cmpl %d2,%d0
46f34: 63ee blss 46f24 <rtems_io_register_driver+0x108>
46f36: 6000 ff28 braw 46e60 <rtems_io_register_driver+0x44>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
46f3a: 5282 addql #1,%d2
46f3c: 45ea 0018 lea %a2@(24),%a2
46f40: 6000 ff54 braw 46e96 <rtems_io_register_driver+0x7a>
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
46f44: 4eb9 0004 8bc4 jsr 48bc4 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
46f4a: 7005 moveq #5,%d0
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
46f4c: 60d8 bras 46f26 <rtems_io_register_driver+0x10a>
...
00047d80 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
47d80: 4e56 fff0 linkw %fp,#-16
47d84: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
47d88: 286e 0008 moveal %fp@(8),%a4
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
47d8c: 4a8c tstl %a4
47d8e: 6738 beqs 47dc8 <rtems_iterate_over_all_threads+0x48><== NEVER TAKEN
47d90: 45f9 0006 0d38 lea 60d38 <_Objects_Information_table+0x4>,%a2
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
47d96: 205a moveal %a2@+,%a0
47d98: 2668 0004 moveal %a0@(4),%a3
if ( !information )
47d9c: 4a8b tstl %a3
47d9e: 6720 beqs 47dc0 <rtems_iterate_over_all_threads+0x40>
47da0: 7401 moveq #1,%d2
47da2: 6012 bras 47db6 <rtems_iterate_over_all_threads+0x36>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
47da4: 206b 0018 moveal %a3@(24),%a0
47da8: 2030 2c00 movel %a0@(00000000,%d2:l:4),%d0
if ( !the_thread )
47dac: 6706 beqs 47db4 <rtems_iterate_over_all_threads+0x34><== NEVER TAKEN
continue;
(*routine)(the_thread);
47dae: 2f00 movel %d0,%sp@-
47db0: 4e94 jsr %a4@
47db2: 588f addql #4,%sp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
47db4: 5282 addql #1,%d2
47db6: 4280 clrl %d0
47db8: 302b 000e movew %a3@(14),%d0
47dbc: b082 cmpl %d2,%d0
47dbe: 64e4 bccs 47da4 <rtems_iterate_over_all_threads+0x24>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
47dc0: b5fc 0006 0d44 cmpal #396612,%a2
47dc6: 66ce bnes 47d96 <rtems_iterate_over_all_threads+0x16>
(*routine)(the_thread);
}
}
}
47dc8: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
47dce: 4e5e unlk %fp
...
00049f86 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
49f86: 4e56 0000 linkw %fp,#0
49f8a: 2f0a movel %a2,%sp@-
49f8c: 246e 0008 moveal %fp@(8),%a2
rtems_libio_lock();
49f90: 4eba fea2 jsr %pc@(49e34 <rtems_libio_lock>)
if (iop->sem)
49f94: 202a 002c movel %a2@(44),%d0
49f98: 670a beqs 49fa4 <rtems_libio_free+0x1e> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
49f9a: 2f00 movel %d0,%sp@-
49f9c: 4eb9 0004 5944 jsr 45944 <rtems_semaphore_delete>
49fa2: 588f addql #4,%sp
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
49fa4: 41f9 0005 ea48 lea 5ea48 <rtems_libio_iop_freelist>,%a0
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
49faa: 203c ffff feff movel #-257,%d0
iop->data1 = rtems_libio_iop_freelist;
49fb0: 2550 0034 movel %a0@,%a2@(52)
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
49fb4: c1aa 0014 andl %d0,%a2@(20)
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
49fb8: 23ca 0005 ea48 movel %a2,5ea48 <rtems_libio_iop_freelist>
rtems_libio_unlock();
}
49fbe: 246e fffc moveal %fp@(-4),%a2
49fc2: 4e5e unlk %fp
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
49fc4: 6000 fe8a braw 49e50 <rtems_libio_unlock>
00042c74 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
42c74: 4e56 0000 linkw %fp,#0
42c78: 2f02 movel %d2,%sp@-
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
42c7a: 2439 0005 d2e2 movel 5d2e2 <rtems_libio_number_iops>,%d2
42c80: 6744 beqs 42cc6 <rtems_libio_init+0x52> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
42c82: 4878 0038 pea 38 <DBL_MANT_DIG+0x3>
42c86: 2f02 movel %d2,%sp@-
42c88: 4eb9 0004 27cc jsr 427cc <calloc>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
42c8e: 508f addql #8,%sp
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
42c90: 23c0 0005 ea44 movel %d0,5ea44 <rtems_libio_iops>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
42c96: 6606 bnes 42c9e <rtems_libio_init+0x2a>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
42c98: 4878 001a pea 1a <OPER2+0x6>
42c9c: 604e bras 42cec <rtems_libio_init+0x78>
iop = rtems_libio_iop_freelist = rtems_libio_iops;
42c9e: 23c0 0005 ea48 movel %d0,5ea48 <rtems_libio_iop_freelist>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
42ca4: 2040 moveal %d0,%a0
42ca6: 4281 clrl %d1
42ca8: 6008 bras 42cb2 <rtems_libio_init+0x3e>
iop->data1 = iop + 1;
42caa: 41e8 0038 lea %a0@(56),%a0
42cae: 2148 fffc movel %a0,%a0@(-4)
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
42cb2: 5281 addql #1,%d1
42cb4: b481 cmpl %d1,%d2
42cb6: 66f2 bnes 42caa <rtems_libio_init+0x36>
iop->data1 = iop + 1;
iop->data1 = NULL;
42cb8: 2401 movel %d1,%d2
42cba: 2040 moveal %d0,%a0
42cbc: e78a lsll #3,%d2
42cbe: ed89 lsll #6,%d1
42cc0: 9282 subl %d2,%d1
42cc2: 42b0 18fc clrl %a0@(fffffffc,%d1:l)
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
42cc6: 4879 0005 ea4c pea 5ea4c <rtems_libio_semaphore>
42ccc: 42a7 clrl %sp@-
42cce: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
42cd2: 4878 0001 pea 1 <ADD>
42cd6: 2f3c 4c42 494f movel #1279412559,%sp@-
42cdc: 4eb9 0004 57a4 jsr 457a4 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
42ce2: 4fef 0014 lea %sp@(20),%sp
42ce6: 4a80 tstl %d0
42ce8: 6708 beqs 42cf2 <rtems_libio_init+0x7e> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
42cea: 2f00 movel %d0,%sp@- <== NOT EXECUTED
42cec: 4eb9 0004 60a4 jsr 460a4 <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
42cf2: 2279 0005 d2e6 moveal 5d2e6 <rtems_fs_init_helper>,%a1
42cf8: 4a89 tstl %a1
42cfa: 6708 beqs 42d04 <rtems_libio_init+0x90> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
42cfc: 242e fffc movel %fp@(-4),%d2
42d00: 4e5e unlk %fp
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
42d02: 4ed1 jmp %a1@
}
42d04: 242e fffc movel %fp@(-4),%d2 <== NOT EXECUTED
42d08: 4e5e unlk %fp <== NOT EXECUTED
00045d2c <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
45d2c: 4e56 fff8 linkw %fp,#-8
45d30: 2f03 movel %d3,%sp@-
45d32: 262e 0008 movel %fp@(8),%d3
45d36: 2f02 movel %d2,%sp@-
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
45d38: 4eb9 0004 87d8 jsr 487d8 <rtems_task_self>
45d3e: 2400 movel %d0,%d2
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
45d40: b083 cmpl %d3,%d0
45d42: 6740 beqs 45d84 <rtems_libio_share_private_env+0x58><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
45d44: 486e fffc pea %fp@(-4)
45d48: 4879 0006 0030 pea 60030 <rtems_current_user_env>
45d4e: 2f03 movel %d3,%sp@-
45d50: 4eb9 0004 8924 jsr 48924 <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
45d56: 4fef 000c lea %sp@(12),%sp
45d5a: 4a80 tstl %d0
45d5c: 6628 bnes 45d86 <rtems_libio_share_private_env+0x5a>
* If we have a current environment in place, we need to
* free it, since we will be sharing the variable with the
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
45d5e: 2079 0006 0030 moveal 60030 <rtems_current_user_env>,%a0
45d64: b490 cmpl %a0@,%d2
45d66: 6610 bnes 45d78 <rtems_libio_share_private_env+0x4c>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
45d68: 2f08 movel %a0,%sp@-
45d6a: 2d40 fff8 movel %d0,%fp@(-8)
45d6e: 4eba fe70 jsr %pc@(45be0 <free_user_env>)
45d72: 202e fff8 movel %fp@(-8),%d0
45d76: 588f addql #4,%sp
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
45d78: 41ee fffc lea %fp@(-4),%a0
45d7c: 23d0 0006 0030 movel %a0@,60030 <rtems_current_user_env>
/* increase the reference count */
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
45d82: 6002 bras 45d86 <rtems_libio_share_private_env+0x5a>
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
45d84: 4280 clrl %d0 <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
45d86: 242e fff0 movel %fp@(-16),%d2
45d8a: 262e fff4 movel %fp@(-12),%d3
45d8e: 4e5e unlk %fp
...
00049ea6 <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49ea6: 7006 moveq #6,%d0
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
49ea8: 4e56 0000 linkw %fp,#0
49eac: 222e 0008 movel %fp@(8),%d1
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49eb0: c081 andl %d1,%d0
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
49eb2: 2f02 movel %d2,%sp@-
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49eb4: 7406 moveq #6,%d2
49eb6: b480 cmpl %d0,%d2
49eb8: 6710 beqs 49eca <rtems_libio_to_fcntl_flags+0x24>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
49eba: 0801 0001 btst #1,%d1
49ebe: 660e bnes 49ece <rtems_libio_to_fcntl_flags+0x28><== ALWAYS TAKEN
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
49ec0: 44c1 movew %d1,%ccr <== NOT EXECUTED
49ec2: 57c0 seq %d0 <== NOT EXECUTED
49ec4: 49c0 extbl %d0 <== NOT EXECUTED
49ec6: 4480 negl %d0 <== NOT EXECUTED
49ec8: 6006 bras 49ed0 <rtems_libio_to_fcntl_flags+0x2a><== NOT EXECUTED
49eca: 7002 moveq #2,%d0
49ecc: 6002 bras 49ed0 <rtems_libio_to_fcntl_flags+0x2a>
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
49ece: 4280 clrl %d0
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
49ed0: 0801 0000 btst #0,%d1
49ed4: 6704 beqs 49eda <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_NONBLOCK;
49ed6: 08c0 000e bset #14,%d0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
49eda: 0801 0009 btst #9,%d1
49ede: 6704 beqs 49ee4 <rtems_libio_to_fcntl_flags+0x3e>
fcntl_flags |= O_APPEND;
49ee0: 7408 moveq #8,%d2
49ee2: 8082 orl %d2,%d0
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
49ee4: 0801 000a btst #10,%d1
49ee8: 6704 beqs 49eee <rtems_libio_to_fcntl_flags+0x48>
fcntl_flags |= O_CREAT;
49eea: 08c0 0009 bset #9,%d0
}
return fcntl_flags;
}
49eee: 241f movel %sp@+,%d2
49ef0: 4e5e unlk %fp <== NOT EXECUTED
00046288 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
46288: 4e56 fffc linkw %fp,#-4
4628c: 2f03 movel %d3,%sp@-
4628e: 2f02 movel %d2,%sp@-
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
46290: 486e fffc pea %fp@(-4)
46294: 2f2e 0008 movel %fp@(8),%sp@-
46298: 2f39 0006 1fae movel 61fae <RTEMS_Malloc_Heap>,%sp@-
4629e: 4eb9 0004 b4f4 jsr 4b4f4 <_Protected_heap_Get_block_size>
462a4: 4fef 000c lea %sp@(12),%sp
462a8: 4a00 tstb %d0
462aa: 671a beqs 462c6 <rtems_malloc_statistics_at_free+0x3e><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
462ac: 262e fffc movel %fp@(-4),%d3
462b0: 4282 clrl %d2
462b2: d7b9 0006 4080 addl %d3,64080 <rtems_malloc_statistics+0x28>
462b8: 2039 0006 407c movel 6407c <rtems_malloc_statistics+0x24>,%d0
462be: d182 addxl %d2,%d0
462c0: 23c0 0006 407c movel %d0,6407c <rtems_malloc_statistics+0x24>
}
}
462c6: 242e fff4 movel %fp@(-12),%d2
462ca: 262e fff8 movel %fp@(-8),%d3
462ce: 4e5e unlk %fp <== NOT EXECUTED
000462d2 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
462d2: 4e56 fffc linkw %fp,#-4
462d6: 202e 0008 movel %fp@(8),%d0
462da: 2f03 movel %d3,%sp@-
uintptr_t actual_size = 0;
462dc: 42ae fffc clrl %fp@(-4)
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
462e0: 2f02 movel %d2,%sp@-
uintptr_t actual_size = 0;
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
462e2: 4a80 tstl %d0
462e4: 674c beqs 46332 <rtems_malloc_statistics_at_malloc+0x60><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
462e6: 486e fffc pea %fp@(-4)
MSBUMP(lifetime_allocated, actual_size);
462ea: 4282 clrl %d2
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
462ec: 2f00 movel %d0,%sp@-
462ee: 2f39 0006 1fae movel 61fae <RTEMS_Malloc_Heap>,%sp@-
462f4: 4eb9 0004 b4f4 jsr 4b4f4 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
462fa: 262e fffc movel %fp@(-4),%d3
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
462fe: 4fef 000c lea %sp@(12),%sp
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
46302: 2039 0006 4074 movel 64074 <rtems_malloc_statistics+0x1c>,%d0
46308: d6b9 0006 4078 addl 64078 <rtems_malloc_statistics+0x20>,%d3
4630e: d580 addxl %d0,%d2
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
46310: 2003 movel %d3,%d0
46312: 90b9 0006 4080 subl 64080 <rtems_malloc_statistics+0x28>,%d0
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
46318: 23c2 0006 4074 movel %d2,64074 <rtems_malloc_statistics+0x1c>
4631e: 23c3 0006 4078 movel %d3,64078 <rtems_malloc_statistics+0x20>
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
46324: b0b9 0006 4070 cmpl 64070 <rtems_malloc_statistics+0x18>,%d0
4632a: 6306 blss 46332 <rtems_malloc_statistics_at_malloc+0x60>
s->max_depth = current_depth;
4632c: 23c0 0006 4070 movel %d0,64070 <rtems_malloc_statistics+0x18>
}
46332: 242e fff4 movel %fp@(-12),%d2
46336: 262e fff8 movel %fp@(-8),%d3
4633a: 4e5e unlk %fp <== NOT EXECUTED
0004d62c <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
4d62c: 4e56 0000 linkw %fp,#0
4d630: 2f0a movel %a2,%sp@-
4d632: 246e 0008 moveal %fp@(8),%a2
4d636: 2f02 movel %d2,%sp@-
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
4d638: 4a8a tstl %a2
4d63a: 6754 beqs 4d690 <rtems_memalign+0x64>
return EINVAL;
*pointer = NULL;
4d63c: 4292 clrl %a2@
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
4d63e: 7003 moveq #3,%d0
4d640: b0b9 0006 20f4 cmpl 620f4 <_System_state_Current>,%d0
4d646: 660a bnes 4d652 <rtems_memalign+0x26> <== NEVER TAKEN
!malloc_is_system_state_OK() )
4d648: 4eb9 0004 37d4 jsr 437d4 <malloc_is_system_state_OK>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
4d64e: 4a00 tstb %d0
4d650: 673e beqs 4d690 <rtems_memalign+0x64> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
4d652: 4eb9 0004 3812 jsr 43812 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
4d658: 42a7 clrl %sp@-
4d65a: 2f2e 000c movel %fp@(12),%sp@-
4d65e: 2f2e 0010 movel %fp@(16),%sp@-
4d662: 2f39 0006 05e2 movel 605e2 <RTEMS_Malloc_Heap>,%sp@-
4d668: 4eb9 0004 8168 jsr 48168 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
4d66e: 4fef 0010 lea %sp@(16),%sp
4d672: 2400 movel %d0,%d2
4d674: 671e beqs 4d694 <rtems_memalign+0x68>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
4d676: 2079 0006 0d94 moveal 60d94 <rtems_malloc_statistics_helpers>,%a0
4d67c: 4a88 tstl %a0
4d67e: 670a beqs 4d68a <rtems_memalign+0x5e>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
4d680: 2f0a movel %a2,%sp@-
4d682: 2068 0004 moveal %a0@(4),%a0
4d686: 4e90 jsr %a0@
4d688: 588f addql #4,%sp
*pointer = return_this;
4d68a: 2482 movel %d2,%a2@
return 0;
4d68c: 4280 clrl %d0
4d68e: 6006 bras 4d696 <rtems_memalign+0x6a>
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
return EINVAL;
4d690: 7016 moveq #22,%d0
4d692: 6002 bras 4d696 <rtems_memalign+0x6a>
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
4d694: 700c moveq #12,%d0
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
4d696: 242e fff8 movel %fp@(-8),%d2
4d69a: 246e fffc moveal %fp@(-4),%a2
4d69e: 4e5e unlk %fp
...
0004b7bc <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
4b7bc: 4e56 fffc linkw %fp,#-4
4b7c0: 2f0a movel %a2,%sp@-
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
4b7c2: 486e fffc pea %fp@(-4)
4b7c6: 2f2e 0008 movel %fp@(8),%sp@-
4b7ca: 4879 0006 1688 pea 61688 <_Message_queue_Information>
4b7d0: 4eb9 0004 7a78 jsr 47a78 <_Objects_Get>
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
4b7d6: 4fef 000c lea %sp@(12),%sp
4b7da: 2440 moveal %d0,%a2
4b7dc: 4aae fffc tstl %fp@(-4)
4b7e0: 663a bnes 4b81c <rtems_message_queue_delete+0x60><== NEVER TAKEN
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
4b7e2: 2f00 movel %d0,%sp@-
4b7e4: 4879 0006 1688 pea 61688 <_Message_queue_Information>
4b7ea: 4eb9 0004 7694 jsr 47694 <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
4b7f0: 4878 0005 pea 5 <COMPARE>
4b7f4: 42a7 clrl %sp@-
4b7f6: 486a 0014 pea %a2@(20)
4b7fa: 4eb9 0004 bd3c jsr 4bd3c <_CORE_message_queue_Close>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
4b800: 2f0a movel %a2,%sp@-
4b802: 4879 0006 1688 pea 61688 <_Message_queue_Information>
4b808: 4eb9 0004 7914 jsr 47914 <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
4b80e: 4eb9 0004 868c jsr 4868c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4b814: 4fef 001c lea %sp@(28),%sp
4b818: 4280 clrl %d0
4b81a: 6002 bras 4b81e <rtems_message_queue_delete+0x62>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4b81c: 7004 moveq #4,%d0
}
4b81e: 246e fff8 moveal %fp@(-8),%a2
4b822: 4e5e unlk %fp
...
0004bef8 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
4bef8: 4e56 ff90 linkw %fp,#-112
4befc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int success = 0;
char *dup_path = strdup(path);
4bf00: 2f2e 0008 movel %fp@(8),%sp@-
4bf04: 4eb9 0004 f320 jsr 4f320 <strdup>
if (dup_path != NULL) {
4bf0a: 588f addql #4,%sp
int
rtems_mkdir(const char *path, mode_t mode)
{
int success = 0;
char *dup_path = strdup(path);
4bf0c: 2440 moveal %d0,%a2
if (dup_path != NULL) {
4bf0e: 4a80 tstl %d0
4bf10: 6700 0134 beqw 4c046 <rtems_mkdir+0x14e>
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bf14: 722f moveq #47,%d1
4bf16: 1012 moveb %a2@,%d0
4bf18: 49c0 extbl %d0
4bf1a: b280 cmpl %d0,%d1
4bf1c: 6606 bnes 4bf24 <rtems_mkdir+0x2c>
++p;
4bf1e: 47ea 0001 lea %a2@(1),%a3
4bf22: 6002 bras 4bf26 <rtems_mkdir+0x2e>
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bf24: 264a moveal %a2,%a3
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
4bf26: 2c0e movel %fp,%d6
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bf28: 7601 moveq #1,%d3
4bf2a: 4284 clrl %d4
4bf2c: 7001 moveq #1,%d0
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bf2e: 2e3c 0004 4024 movel #278564,%d7
if (errno == EEXIST || errno == EISDIR) {
4bf34: 4bf9 0004 e404 lea 4e404 <__errno>,%a5
if (stat(path, &sb) < 0) {
4bf3a: 0686 ffff ffba addil #-70,%d6
4bf40: 2a3c 0004 c058 movel #311384,%d5
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
4bf46: 49f9 0004 c0fc lea 4c0fc <umask>,%a4
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
4bf4c: 1213 moveb %a3@,%d1
4bf4e: 670e beqs 4bf5e <rtems_mkdir+0x66>
last = 1;
else if (p[0] != '/')
4bf50: 49c1 extbl %d1
4bf52: 742f moveq #47,%d2
4bf54: b481 cmpl %d1,%d2
4bf56: 6600 00bc bnew 4c014 <rtems_mkdir+0x11c>
4bf5a: 4281 clrl %d1
4bf5c: 6002 bras 4bf60 <rtems_mkdir+0x68>
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
4bf5e: 7201 moveq #1,%d1
else if (p[0] != '/')
continue;
*p = '\0';
4bf60: 4213 clrb %a3@
if (!last && p[1] == '\0')
4bf62: 4a81 tstl %d1
4bf64: 660c bnes 4bf72 <rtems_mkdir+0x7a>
4bf66: 4a2b 0001 tstb %a3@(1)
4bf6a: 57c2 seq %d2
4bf6c: 49c2 extbl %d2
4bf6e: 4482 negl %d2
4bf70: 6002 bras 4bf74 <rtems_mkdir+0x7c>
4bf72: 7401 moveq #1,%d2
last = 1;
if (first) {
4bf74: 4a80 tstl %d0
4bf76: 6712 beqs 4bf8a <rtems_mkdir+0x92>
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
4bf78: 42a7 clrl %sp@-
4bf7a: 4e94 jsr %a4@
4bf7c: 2800 movel %d0,%d4
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
4bf7e: 0280 ffff ff3f andil #-193,%d0
4bf84: 2f00 movel %d0,%sp@-
4bf86: 4e94 jsr %a4@
4bf88: 508f addql #8,%sp
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bf8a: 203c 0000 01ff movel #511,%d0
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
4bf90: 4a82 tstl %d2
4bf92: 670a beqs 4bf9e <rtems_mkdir+0xa6>
(void)umask(oumask);
4bf94: 2f04 movel %d4,%sp@-
4bf96: 4e94 jsr %a4@
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bf98: 202e 000c movel %fp@(12),%d0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
4bf9c: 588f addql #4,%sp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bf9e: 2f00 movel %d0,%sp@-
4bfa0: 2047 moveal %d7,%a0
4bfa2: 2f0a movel %a2,%sp@-
4bfa4: 4e90 jsr %a0@
4bfa6: 508f addql #8,%sp
4bfa8: 4a80 tstl %d0
4bfaa: 6c5c bges 4c008 <rtems_mkdir+0x110>
if (errno == EEXIST || errno == EISDIR) {
4bfac: 4e95 jsr %a5@
4bfae: 7211 moveq #17,%d1
4bfb0: 2040 moveal %d0,%a0
4bfb2: b290 cmpl %a0@,%d1
4bfb4: 670c beqs 4bfc2 <rtems_mkdir+0xca>
4bfb6: 4e95 jsr %a5@
4bfb8: 7215 moveq #21,%d1
4bfba: 2040 moveal %d0,%a0
4bfbc: b290 cmpl %a0@,%d1
4bfbe: 6600 0092 bnew 4c052 <rtems_mkdir+0x15a>
if (stat(path, &sb) < 0) {
4bfc2: 2f06 movel %d6,%sp@-
4bfc4: 2045 moveal %d5,%a0
4bfc6: 2f0a movel %a2,%sp@-
4bfc8: 4e90 jsr %a0@
4bfca: 508f addql #8,%sp
4bfcc: 4a80 tstl %d0
4bfce: 6d00 0082 bltw 4c052 <rtems_mkdir+0x15a>
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
4bfd2: 202e ffc6 movel %fp@(-58),%d0
4bfd6: 0280 0000 f000 andil #61440,%d0
4bfdc: 0c80 0000 4000 cmpil #16384,%d0
4bfe2: 671e beqs 4c002 <rtems_mkdir+0x10a>
4bfe4: 41f9 0004 e404 lea 4e404 <__errno>,%a0
if (last)
4bfea: 4a82 tstl %d2
4bfec: 670a beqs 4bff8 <rtems_mkdir+0x100>
errno = EEXIST;
4bfee: 4e90 jsr %a0@
4bff0: 7211 moveq #17,%d1
4bff2: 2040 moveal %d0,%a0
4bff4: 2081 movel %d1,%a0@
4bff6: 603a bras 4c032 <rtems_mkdir+0x13a>
else
errno = ENOTDIR;
4bff8: 4e90 jsr %a0@
4bffa: 2040 moveal %d0,%a0
4bffc: 7014 moveq #20,%d0
4bffe: 2080 movel %d0,%a0@
4c000: 6026 bras 4c028 <rtems_mkdir+0x130>
retval = 0;
break;
}
if (last)
4c002: 4a82 tstl %d2
4c004: 6612 bnes 4c018 <rtems_mkdir+0x120>
4c006: 6004 bras 4c00c <rtems_mkdir+0x114>
} else {
retval = 0;
break;
}
}
if (!last)
4c008: 4a82 tstl %d2
4c00a: 660e bnes 4c01a <rtems_mkdir+0x122>
*p = '/';
4c00c: 4281 clrl %d1
4c00e: 16bc 002f moveb #47,%a3@
4c012: 6008 bras 4c01c <rtems_mkdir+0x124>
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
4c014: 4281 clrl %d1
4c016: 6006 bras 4c01e <rtems_mkdir+0x126>
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
4c018: 7602 moveq #2,%d3
} else {
retval = 0;
break;
}
}
if (!last)
4c01a: 7201 moveq #1,%d1
4c01c: 4280 clrl %d0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
4c01e: 528b addql #1,%a3
4c020: 4a81 tstl %d1
4c022: 6700 ff28 beqw 4bf4c <rtems_mkdir+0x54>
4c026: 600c bras 4c034 <rtems_mkdir+0x13c>
}
if (!last)
*p = '/';
}
if (!first && !last)
(void)umask(oumask);
4c028: 2f04 movel %d4,%sp@-
4c02a: 4eb9 0004 c0fc jsr 4c0fc <umask>
4c030: 588f addql #4,%sp
4c032: 4283 clrl %d3
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
4c034: 2f0a movel %a2,%sp@-
4c036: 4eb9 0004 3a0c jsr 43a0c <free>
}
return success != 0 ? 0 : -1;
4c03c: 588f addql #4,%sp
4c03e: 4a83 tstl %d3
4c040: 57c0 seq %d0
4c042: 49c0 extbl %d0
4c044: 6002 bras 4c048 <rtems_mkdir+0x150>
4c046: 70ff moveq #-1,%d0 <== NOT EXECUTED
}
4c048: 4cee 3cfc ff90 moveml %fp@(-112),%d2-%d7/%a2-%a5
4c04e: 4e5e unlk %fp
4c050: 4e75 rts
}
}
if (!last)
*p = '/';
}
if (!first && !last)
4c052: 4a82 tstl %d2
4c054: 67d2 beqs 4c028 <rtems_mkdir+0x130> <== NEVER TAKEN
4c056: 60da bras 4c032 <rtems_mkdir+0x13a>
0004f7dc <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
rtems_id id,
void **buffer
)
{
4f7dc: 4e56 fff0 linkw %fp,#-16
4f7e0: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4f7e4: 266e 000c moveal %fp@(12),%a3
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
4f7e8: 4a8b tstl %a3
4f7ea: 6748 beqs 4f834 <rtems_partition_get_buffer+0x58><== NEVER TAKEN
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
4f7ec: 486e fffc pea %fp@(-4)
4f7f0: 2f2e 0008 movel %fp@(8),%sp@-
4f7f4: 4879 0007 69d2 pea 769d2 <_Partition_Information>
4f7fa: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
4f800: 4fef 000c lea %sp@(12),%sp
4f804: 2440 moveal %d0,%a2
4f806: 4aae fffc tstl %fp@(-4)
4f80a: 662c bnes 4f838 <rtems_partition_get_buffer+0x5c>
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
4f80c: 486a 0024 pea %a2@(36)
4f810: 4eb9 0005 24c0 jsr 524c0 <_Chain_Get>
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
4f816: 588f addql #4,%sp
4f818: 41f9 0005 4ab4 lea 54ab4 <_Thread_Enable_dispatch>,%a0
4f81e: 2400 movel %d0,%d2
4f820: 670c beqs 4f82e <rtems_partition_get_buffer+0x52>
the_partition->number_of_used_blocks += 1;
4f822: 52aa 0020 addql #1,%a2@(32)
_Thread_Enable_dispatch();
4f826: 4e90 jsr %a0@
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
4f828: 4280 clrl %d0
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
4f82a: 2682 movel %d2,%a3@
return RTEMS_SUCCESSFUL;
4f82c: 600c bras 4f83a <rtems_partition_get_buffer+0x5e>
}
_Thread_Enable_dispatch();
4f82e: 4e90 jsr %a0@
return RTEMS_UNSATISFIED;
4f830: 700d moveq #13,%d0
4f832: 6006 bras 4f83a <rtems_partition_get_buffer+0x5e>
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
4f834: 7009 moveq #9,%d0
4f836: 6002 bras 4f83a <rtems_partition_get_buffer+0x5e>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4f838: 7004 moveq #4,%d0
}
4f83a: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4f840: 4e5e unlk %fp <== NOT EXECUTED
0004f870 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
4f870: 4e56 fffc linkw %fp,#-4
4f874: 2f0a movel %a2,%sp@-
4f876: 2f02 movel %d2,%sp@-
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
4f878: 486e fffc pea %fp@(-4)
4f87c: 2f2e 0008 movel %fp@(8),%sp@-
4f880: 4879 0007 69d2 pea 769d2 <_Partition_Information>
4f886: 242e 000c movel %fp@(12),%d2
4f88a: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
4f890: 4fef 000c lea %sp@(12),%sp
4f894: 2440 moveal %d0,%a2
4f896: 4aae fffc tstl %fp@(-4)
4f89a: 663e bnes 4f8da <rtems_partition_return_buffer+0x6a>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
4f89c: 202a 0010 movel %a2@(16),%d0
ending = _Addresses_Add_offset( starting, the_partition->length );
4f8a0: 222a 0014 movel %a2@(20),%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
4f8a4: b082 cmpl %d2,%d0
4f8a6: 6240 bhis 4f8e8 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
4f8a8: d280 addl %d0,%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
4f8aa: b282 cmpl %d2,%d1
4f8ac: 653a bcss 4f8e8 <rtems_partition_return_buffer+0x78><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
4f8ae: 2202 movel %d2,%d1
4f8b0: 9280 subl %d0,%d1
4f8b2: 2001 movel %d1,%d0
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
4f8b4: 4c6a 0001 0018 remul %a2@(24),%d1,%d0
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
4f8ba: 4a81 tstl %d1
4f8bc: 662a bnes 4f8e8 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
4f8be: 2f02 movel %d2,%sp@-
4f8c0: 486a 0024 pea %a2@(36)
4f8c4: 4eb9 0005 2460 jsr 52460 <_Chain_Append>
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
4f8ca: 53aa 0020 subql #1,%a2@(32)
_Thread_Enable_dispatch();
4f8ce: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4f8d4: 508f addql #8,%sp
4f8d6: 4280 clrl %d0
4f8d8: 6002 bras 4f8dc <rtems_partition_return_buffer+0x6c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4f8da: 7004 moveq #4,%d0
}
4f8dc: 242e fff4 movel %fp@(-12),%d2
4f8e0: 246e fff8 moveal %fp@(-8),%a2
4f8e4: 4e5e unlk %fp
4f8e6: 4e75 rts
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
4f8e8: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
4f8ee: 7009 moveq #9,%d0
4f8f0: 60ea bras 4f8dc <rtems_partition_return_buffer+0x6c>
...
00046552 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
46552: 4e56 ffec linkw %fp,#-20
46556: 48d7 041c moveml %d2-%d4/%a2,%sp@
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
4655a: 486e fffc pea %fp@(-4)
4655e: 262e 0008 movel %fp@(8),%d3
46562: 2f03 movel %d3,%sp@-
46564: 4879 0006 04ac pea 604ac <_Rate_monotonic_Information>
4656a: 242e 000c movel %fp@(12),%d2
4656e: 4eb9 0004 8580 jsr 48580 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
46574: 4fef 000c lea %sp@(12),%sp
46578: 2440 moveal %d0,%a2
4657a: 4aae fffc tstl %fp@(-4)
4657e: 6600 015a bnew 466da <rtems_rate_monotonic_period+0x188>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
46582: 2039 0006 0a04 movel 60a04 <_Per_CPU_Information+0xc>,%d0
46588: b0aa 0040 cmpl %a2@(64),%d0
4658c: 670c beqs 4659a <rtems_rate_monotonic_period+0x48>
_Thread_Enable_dispatch();
4658e: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
46594: 7417 moveq #23,%d2
46596: 6000 0144 braw 466dc <rtems_rate_monotonic_period+0x18a>
}
if ( length == RTEMS_PERIOD_STATUS ) {
4659a: 4a82 tstl %d2
4659c: 6624 bnes 465c2 <rtems_rate_monotonic_period+0x70>
switch ( the_period->state ) {
4659e: 202a 0038 movel %a2@(56),%d0
465a2: 7204 moveq #4,%d1
465a4: b280 cmpl %d0,%d1
465a6: 650e bcss 465b6 <rtems_rate_monotonic_period+0x64><== NEVER TAKEN
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
465a8: 41f9 0005 db0a lea 5db0a <CSWTCH.2>,%a0
465ae: 4282 clrl %d2
465b0: 1430 0800 moveb %a0@(00000000,%d0:l),%d2
465b4: 6002 bras 465b8 <rtems_rate_monotonic_period+0x66>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
465b6: 4282 clrl %d2 <== NOT EXECUTED
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
465b8: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return( return_value );
465be: 6000 011c braw 466dc <rtems_rate_monotonic_period+0x18a>
}
_ISR_Disable( level );
465c2: 203c 0000 0700 movel #1792,%d0
465c8: 40c4 movew %sr,%d4
465ca: 8084 orl %d4,%d0
465cc: 46c0 movew %d0,%sr
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
465ce: 202a 0038 movel %a2@(56),%d0
465d2: 664a bnes 4661e <rtems_rate_monotonic_period+0xcc>
_ISR_Enable( level );
465d4: 46c4 movew %d4,%sr
the_period->next_length = length;
465d6: 2542 003c movel %d2,%a2@(60)
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
465da: 2f0a movel %a2,%sp@-
465dc: 4eb9 0004 63d6 jsr 463d6 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
465e2: 7002 moveq #2,%d0
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
465e4: 223c 0004 692c movel #289068,%d1
465ea: 2540 0038 movel %d0,%a2@(56)
465ee: 2541 002c movel %d1,%a2@(44)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
465f2: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine;
the_watchdog->id = id;
465f6: 2543 0030 movel %d3,%a2@(48)
the_watchdog->user_data = user_data;
465fa: 42aa 0034 clrl %a2@(52)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
465fe: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
46602: 486a 0010 pea %a2@(16)
46606: 4879 0006 065a pea 6065a <_Watchdog_Ticks_chain>
4660c: 4eb9 0004 9f0c jsr 49f0c <_Watchdog_Insert>
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
46612: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
46618: 4fef 000c lea %sp@(12),%sp
4661c: 606c bras 4668a <rtems_rate_monotonic_period+0x138>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
4661e: 7202 moveq #2,%d1
46620: b280 cmpl %d0,%d1
46622: 666a bnes 4668e <rtems_rate_monotonic_period+0x13c>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
46624: 2f0a movel %a2,%sp@-
46626: 4eb9 0004 6460 jsr 46460 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
4662c: 7001 moveq #1,%d0
the_period->next_length = length;
4662e: 2542 003c movel %d2,%a2@(60)
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
46632: 2540 0038 movel %d0,%a2@(56)
the_period->next_length = length;
_ISR_Enable( level );
46636: 46c4 movew %d4,%sr
_Thread_Executing->Wait.id = the_period->Object.id;
46638: 2079 0006 0a04 moveal 60a04 <_Per_CPU_Information+0xc>,%a0
4663e: 216a 0008 0020 movel %a2@(8),%a0@(32)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
46644: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
46648: 2f08 movel %a0,%sp@-
4664a: 4eb9 0004 998c jsr 4998c <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
46650: 203c 0000 0700 movel #1792,%d0
46656: 40c1 movew %sr,%d1
46658: 8081 orl %d1,%d0
4665a: 46c0 movew %d0,%sr
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
4665c: 7402 moveq #2,%d2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
4665e: 202a 0038 movel %a2@(56),%d0
the_period->state = RATE_MONOTONIC_ACTIVE;
46662: 2542 0038 movel %d2,%a2@(56)
_ISR_Enable( level );
46666: 46c1 movew %d1,%sr
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
46668: 7203 moveq #3,%d1
4666a: 4fef 000c lea %sp@(12),%sp
4666e: b280 cmpl %d0,%d1
46670: 6612 bnes 46684 <rtems_rate_monotonic_period+0x132>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
46672: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
46676: 2f39 0006 0a04 movel 60a04 <_Per_CPU_Information+0xc>,%sp@-
4667c: 4eb9 0004 8e94 jsr 48e94 <_Thread_Clear_state>
46682: 508f addql #8,%sp
_Thread_Enable_dispatch();
46684: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4668a: 4282 clrl %d2
4668c: 604e bras 466dc <rtems_rate_monotonic_period+0x18a>
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
4668e: 7204 moveq #4,%d1
46690: b280 cmpl %d0,%d1
46692: 6646 bnes 466da <rtems_rate_monotonic_period+0x188><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
46694: 2f0a movel %a2,%sp@-
46696: 4eb9 0004 6460 jsr 46460 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
4669c: 46c4 movew %d4,%sr
the_period->state = RATE_MONOTONIC_ACTIVE;
4669e: 7002 moveq #2,%d0
the_period->next_length = length;
466a0: 2542 003c movel %d2,%a2@(60)
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
466a4: 2540 0038 movel %d0,%a2@(56)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
466a8: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
466ac: 486a 0010 pea %a2@(16)
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
466b0: 7406 moveq #6,%d2
466b2: 4879 0006 065a pea 6065a <_Watchdog_Ticks_chain>
466b8: 4eb9 0004 9f0c jsr 49f0c <_Watchdog_Insert>
466be: 2f2a 003c movel %a2@(60),%sp@-
466c2: 2f2a 0040 movel %a2@(64),%sp@-
466c6: 2079 0005 ebf2 moveal 5ebf2 <_Scheduler+0x34>,%a0
466cc: 4e90 jsr %a0@
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
466ce: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
466d4: 4fef 0014 lea %sp@(20),%sp
466d8: 6002 bras 466dc <rtems_rate_monotonic_period+0x18a>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
466da: 7404 moveq #4,%d2
}
466dc: 2002 movel %d2,%d0
466de: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
466e4: 4e5e unlk %fp <== NOT EXECUTED
0004687c <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
4687c: 4e56 0000 linkw %fp,#0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
46880: 2039 0006 05a2 movel 605a2 <_Thread_Dispatch_disable_level>,%d0
46886: 5280 addql #1,%d0
46888: 2f0a movel %a2,%sp@-
4688a: 23c0 0006 05a2 movel %d0,605a2 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
46890: 2039 0006 05a2 movel 605a2 <_Thread_Dispatch_disable_level>,%d0
46896: 2f02 movel %d2,%sp@-
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
46898: 2439 0006 04b2 movel 604b2 <_Rate_monotonic_Information+0x6>,%d2
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
4689e: 45f9 0004 68c8 lea 468c8 <rtems_rate_monotonic_reset_statistics>,%a2
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
468a4: 6008 bras 468ae <rtems_rate_monotonic_reset_all_statistics+0x32>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
468a6: 2f02 movel %d2,%sp@-
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
468a8: 5282 addql #1,%d2
(void) rtems_rate_monotonic_reset_statistics( id );
468aa: 4e92 jsr %a2@
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
468ac: 588f addql #4,%sp
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
468ae: b4b9 0006 04b6 cmpl 604b6 <_Rate_monotonic_Information+0xa>,%d2
468b4: 63f0 blss 468a6 <rtems_rate_monotonic_reset_all_statistics+0x2a>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
468b6: 242e fff8 movel %fp@(-8),%d2
468ba: 246e fffc moveal %fp@(-4),%a2
468be: 4e5e unlk %fp
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
468c0: 4ef9 0004 9208 jmp 49208 <_Thread_Enable_dispatch>
...
00050224 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
50224: 4e56 fff8 linkw %fp,#-8
50228: 2f0a movel %a2,%sp@-
5022a: 2f02 movel %d2,%sp@-
5022c: 242e 000c movel %fp@(12),%d2
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
50230: 676e beqs 502a0 <rtems_region_extend+0x7c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
50232: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@-
50238: 4eb9 0005 23c8 jsr 523c8 <_API_Mutex_Lock>
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
5023e: 486e fffc pea %fp@(-4)
50242: 2f2e 0008 movel %fp@(8),%sp@-
50246: 4879 0007 6a46 pea 76a46 <_Region_Information>
5024c: 4eb9 0005 3df4 jsr 53df4 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
50252: 4fef 0010 lea %sp@(16),%sp
50256: 2440 moveal %d0,%a2
50258: 4aae fffc tstl %fp@(-4)
5025c: 662c bnes 5028a <rtems_region_extend+0x66>
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
5025e: 486e fff8 pea %fp@(-8)
50262: 2f2e 0010 movel %fp@(16),%sp@-
50266: 2f02 movel %d2,%sp@-
50268: 486a 0068 pea %a2@(104)
5026c: 4eb9 0005 3050 jsr 53050 <_Heap_Extend>
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
50272: 4fef 0010 lea %sp@(16),%sp
50276: 4a00 tstb %d0
50278: 6714 beqs 5028e <rtems_region_extend+0x6a> <== ALWAYS TAKEN
the_region->length += amount_extended;
5027a: 202e fff8 movel %fp@(-8),%d0 <== NOT EXECUTED
5027e: d1aa 0054 addl %d0,%a2@(84) <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
50282: 4282 clrl %d2 <== NOT EXECUTED
&amount_extended
);
if ( extend_ok ) {
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
50284: d1aa 005c addl %d0,%a2@(92) <== NOT EXECUTED
50288: 6006 bras 50290 <rtems_region_extend+0x6c> <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
5028a: 7404 moveq #4,%d2
5028c: 6002 bras 50290 <rtems_region_extend+0x6c>
if ( extend_ok ) {
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
} else {
return_status = RTEMS_INVALID_ADDRESS;
5028e: 7409 moveq #9,%d2
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
50290: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@-
50296: 4eb9 0005 2428 jsr 52428 <_API_Mutex_Unlock>
return return_status;
5029c: 588f addql #4,%sp
5029e: 6002 bras 502a2 <rtems_region_extend+0x7e>
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
502a0: 7409 moveq #9,%d2
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
502a2: 2002 movel %d2,%d0
502a4: 242e fff0 movel %fp@(-16),%d2
502a8: 246e fff4 moveal %fp@(-12),%a2
502ac: 4e5e unlk %fp <== NOT EXECUTED
000504a8 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
504a8: 4e56 fffc linkw %fp,#-4
504ac: 2f03 movel %d3,%sp@-
504ae: 262e 0010 movel %fp@(16),%d3
504b2: 2f02 movel %d2,%sp@-
504b4: 242e 000c movel %fp@(12),%d2
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
504b8: 6768 beqs 50522 <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
if ( !size )
504ba: 4a83 tstl %d3
504bc: 6764 beqs 50522 <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
504be: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@-
504c4: 4eb9 0005 23c8 jsr 523c8 <_API_Mutex_Lock>
504ca: 486e fffc pea %fp@(-4)
504ce: 2f2e 0008 movel %fp@(8),%sp@-
504d2: 4879 0007 6a46 pea 76a46 <_Region_Information>
504d8: 4eb9 0005 3df4 jsr 53df4 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
504de: 222e fffc movel %fp@(-4),%d1
504e2: 4fef 0010 lea %sp@(16),%sp
504e6: 6708 beqs 504f0 <rtems_region_get_segment_size+0x48>
504e8: 7001 moveq #1,%d0
504ea: b081 cmpl %d1,%d0
504ec: 661a bnes 50508 <rtems_region_get_segment_size+0x60><== NEVER TAKEN
504ee: 601c bras 5050c <rtems_region_get_segment_size+0x64>
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
504f0: 2f03 movel %d3,%sp@-
504f2: 2040 moveal %d0,%a0
504f4: 2f02 movel %d2,%sp@-
504f6: 4868 0068 pea %a0@(104)
504fa: 4eb9 0005 3860 jsr 53860 <_Heap_Size_of_alloc_area>
50500: 4fef 000c lea %sp@(12),%sp
50504: 4a00 tstb %d0
50506: 6708 beqs 50510 <rtems_region_get_segment_size+0x68><== NEVER TAKEN
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
50508: 4282 clrl %d2
5050a: 6006 bras 50512 <rtems_region_get_segment_size+0x6a>
case OBJECTS_REMOTE: /* this error cannot be returned */
break;
#endif
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
5050c: 7404 moveq #4,%d2
5050e: 6002 bras 50512 <rtems_region_get_segment_size+0x6a>
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
return_status = RTEMS_INVALID_ADDRESS;
50510: 7409 moveq #9,%d2 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
50512: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@-
50518: 4eb9 0005 2428 jsr 52428 <_API_Mutex_Unlock>
return return_status;
5051e: 588f addql #4,%sp
50520: 6002 bras 50524 <rtems_region_get_segment_size+0x7c>
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
50522: 7409 moveq #9,%d2
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
50524: 2002 movel %d2,%d0
50526: 242e fff4 movel %fp@(-12),%d2
5052a: 262e fff8 movel %fp@(-8),%d3
5052e: 4e5e unlk %fp
...
00055538 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
55538: 4e56 ffdc linkw %fp,#-36
5553c: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
55540: 486e fffc pea %fp@(-4)
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
55544: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
55548: 2f0a movel %a2,%sp@-
5554a: 4eba fb20 jsr %pc@(5506c <rtems_rfs_bitmap_load_map>)
if (rc > 0)
5554e: 508f addql #8,%sp
55550: 4a80 tstl %d0
55552: 6e70 bgts 555c4 <rtems_rfs_bitmap_create_search+0x8c><== NEVER TAKEN
return rc;
control->free = 0;
55554: 42aa 0010 clrl %a2@(16)
search_map = control->search_bits;
55558: 286a 0014 moveal %a2@(20),%a4
size = control->size;
5555c: 242a 000c movel %a2@(12),%d2
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
55560: 76ff moveq #-1,%d3
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
{
bits = rtems_rfs_bitmap_merge (*map,
55562: 4bf9 0005 5260 lea 55260 <rtems_rfs_bitmap_mask_section>,%a5
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
55568: 7801 moveq #1,%d4
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
5556a: 2883 movel %d3,%a4@
5556c: 266e fffc moveal %fp@(-4),%a3
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
55570: 4283 clrl %d3
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
55572: 604a bras 555be <rtems_rfs_bitmap_create_search+0x86>
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
55574: 701f moveq #31,%d0
55576: b082 cmpl %d2,%d0
55578: 650e bcss 55588 <rtems_rfs_bitmap_create_search+0x50>
{
bits = rtems_rfs_bitmap_merge (*map,
5557a: 2f02 movel %d2,%sp@-
5557c: 42a7 clrl %sp@-
5557e: 4e95 jsr %a5@
55580: 508f addql #8,%sp
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
55582: 2042 moveal %d2,%a0
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
55584: c093 andl %a3@,%d0
55586: 6006 bras 5558e <rtems_rfs_bitmap_create_search+0x56>
rtems_rfs_bitmap_mask_section (0, size));
available = size;
}
else
{
bits = *map;
55588: 2013 movel %a3@,%d0
available = rtems_rfs_bitmap_element_bits ();
5558a: 307c 0020 moveaw #32,%a0
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
5558e: 4a80 tstl %d0
55590: 6714 beqs 555a6 <rtems_rfs_bitmap_create_search+0x6e>
55592: 4281 clrl %d1
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
55594: 2a04 movel %d4,%d5
55596: e3ad lsll %d1,%d5
55598: ca80 andl %d0,%d5
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
5559a: 6704 beqs 555a0 <rtems_rfs_bitmap_create_search+0x68>
control->free++;
5559c: 52aa 0010 addql #1,%a2@(16)
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
555a0: 5281 addql #1,%d1
555a2: b1c1 cmpal %d1,%a0
555a4: 6eee bgts 55594 <rtems_rfs_bitmap_create_search+0x5c>
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
}
size -= available;
555a6: 9488 subl %a0,%d2
if (bit == rtems_rfs_bitmap_element_bits ())
555a8: 7020 moveq #32,%d0
555aa: b083 cmpl %d3,%d0
555ac: 660c bnes 555ba <rtems_rfs_bitmap_create_search+0x82><== ALWAYS TAKEN
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
555ae: 70ff moveq #-1,%d0 <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
555b0: 4283 clrl %d3 <== NOT EXECUTED
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
555b2: 2940 0004 movel %d0,%a4@(4) <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
555b6: 588c addql #4,%a4 <== NOT EXECUTED
555b8: 6002 bras 555bc <rtems_rfs_bitmap_create_search+0x84><== NOT EXECUTED
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
555ba: 5283 addql #1,%d3
555bc: 588b addql #4,%a3
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
555be: 4a82 tstl %d2
555c0: 66b2 bnes 55574 <rtems_rfs_bitmap_create_search+0x3c>
else
bit++;
map++;
}
return 0;
555c2: 4280 clrl %d0
}
555c4: 4cee 3c3c ffdc moveml %fp@(-36),%d2-%d5/%a2-%a5
555ca: 4e5e unlk %fp <== NOT EXECUTED
0005506c <rtems_rfs_bitmap_load_map>:
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
5506c: 4e56 0000 linkw %fp,#0
55070: 2f0b movel %a3,%sp@-
55072: 266e 000c moveal %fp@(12),%a3
55076: 2f0a movel %a2,%sp@-
55078: 246e 0008 moveal %fp@(8),%a2
int rc;
if (!control->buffer)
5507c: 4a92 tstl %a2@
5507e: 672a beqs 550aa <rtems_rfs_bitmap_load_map+0x3e> <== NEVER TAKEN
return ENXIO;
*map = NULL;
55080: 4293 clrl %a3@
rc = rtems_rfs_buffer_handle_request (control->fs,
55082: 4878 0001 pea 1 <ADD>
55086: 2f2a 0008 movel %a2@(8),%sp@-
5508a: 2f12 movel %a2@,%sp@-
5508c: 2f2a 0004 movel %a2@(4),%sp@-
55090: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
control->buffer,
control->block,
true);
if (rc)
55096: 4fef 0010 lea %sp@(16),%sp
5509a: 4a80 tstl %d0
5509c: 660e bnes 550ac <rtems_rfs_bitmap_load_map+0x40> <== NEVER TAKEN
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
5509e: 2052 moveal %a2@,%a0
550a0: 2068 0006 moveal %a0@(6),%a0
550a4: 26a8 001e movel %a0@(30),%a3@
550a8: 6002 bras 550ac <rtems_rfs_bitmap_load_map+0x40>
rtems_rfs_bitmap_map* map)
{
int rc;
if (!control->buffer)
return ENXIO;
550aa: 7006 moveq #6,%d0 <== NOT EXECUTED
if (rc)
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
return 0;
}
550ac: 246e fff8 moveal %fp@(-8),%a2
550b0: 266e fffc moveal %fp@(-4),%a3
550b4: 4e5e unlk %fp <== NOT EXECUTED
000554a2 <rtems_rfs_bitmap_map_alloc>:
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
554a2: 4e56 ffe8 linkw %fp,#-24
554a6: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
554aa: 266e 0010 moveal %fp@(16),%a3
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
554ae: 4bfa fc08 lea %pc@(550b8 <rtems_rfs_search_map_for_clear_bit.constprop.1>),%a5
* seed up then from the seed down a window number of bits, then repeat the
* process from the window distance from the seed, again above then
* below. Keep moving out until all bits have been searched.
*/
upper_seed = seed;
lower_seed = seed;
554b2: 242e 000c movel %fp@(12),%d2
* of bits from the original seed above then below. That is search from the
* seed up then from the seed down a window number of bits, then repeat the
* process from the window distance from the seed, again above then
* below. Keep moving out until all bits have been searched.
*/
upper_seed = seed;
554b6: 2602 movel %d2,%d3
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
554b8: 246e 0008 moveal %fp@(8),%a2
554bc: 286e 0014 moveal %fp@(20),%a4
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
554c0: 4213 clrb %a3@
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
554c2: 6054 bras 55518 <rtems_rfs_bitmap_map_alloc+0x76>
|| ((lower_seed >= 0) && (lower_seed < control->size)))
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
554c4: b6aa 000c cmpl %a2@(12),%d3
554c8: 641a bccs 554e4 <rtems_rfs_bitmap_map_alloc+0x42><== NEVER TAKEN
{
*bit = upper_seed;
554ca: 2883 movel %d3,%a4@
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
554cc: 4878 0001 pea 1 <ADD>
554d0: 2f0b movel %a3,%sp@-
554d2: 2f0c movel %a4,%sp@-
554d4: 2f0a movel %a2,%sp@-
554d6: 4e95 jsr %a5@
window, 1);
if ((rc > 0) || *allocated)
554d8: 4fef 0010 lea %sp@(16),%sp
554dc: 4a80 tstl %d0
554de: 6e4c bgts 5552c <rtems_rfs_bitmap_map_alloc+0x8a><== NEVER TAKEN
554e0: 4a13 tstb %a3@
554e2: 6648 bnes 5552c <rtems_rfs_bitmap_map_alloc+0x8a>
break;
}
if (lower_seed >= 0)
554e4: 4a82 tstl %d2
554e6: 6d1a blts 55502 <rtems_rfs_bitmap_map_alloc+0x60><== NEVER TAKEN
{
*bit = lower_seed;
554e8: 2882 movel %d2,%a4@
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
554ea: 4878 ffff pea ffffffff <LESS>
554ee: 2f0b movel %a3,%sp@-
554f0: 2f0c movel %a4,%sp@-
554f2: 2f0a movel %a2,%sp@-
554f4: 4e95 jsr %a5@
window, -1);
if ((rc > 0) || *allocated)
554f6: 4fef 0010 lea %sp@(16),%sp
554fa: 4a80 tstl %d0
554fc: 6e2e bgts 5552c <rtems_rfs_bitmap_map_alloc+0x8a><== NEVER TAKEN
554fe: 4a13 tstb %a3@
55500: 662a bnes 5552c <rtems_rfs_bitmap_map_alloc+0x8a><== NEVER TAKEN
/*
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
55502: b6aa 000c cmpl %a2@(12),%d3
55506: 6406 bccs 5550e <rtems_rfs_bitmap_map_alloc+0x6c><== NEVER TAKEN
upper_seed += window;
55508: 0683 0000 0800 addil #2048,%d3
if (lower_seed >= 0)
5550e: 4a82 tstl %d2
55510: 6d06 blts 55518 <rtems_rfs_bitmap_map_alloc+0x76><== NEVER TAKEN
lower_seed -= window;
55512: 0682 ffff f800 addil #-2048,%d2
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
55518: 4a83 tstl %d3
5551a: 6d06 blts 55522 <rtems_rfs_bitmap_map_alloc+0x80><== NEVER TAKEN
5551c: b6aa 000c cmpl %a2@(12),%d3
55520: 65a2 bcss 554c4 <rtems_rfs_bitmap_map_alloc+0x22>
|| ((lower_seed >= 0) && (lower_seed < control->size)))
55522: 4a82 tstl %d2
55524: 6d06 blts 5552c <rtems_rfs_bitmap_map_alloc+0x8a>
55526: b4aa 000c cmpl %a2@(12),%d2
5552a: 6598 bcss 554c4 <rtems_rfs_bitmap_map_alloc+0x22><== NEVER TAKEN
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
5552c: 4280 clrl %d0
5552e: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
55534: 4e5e unlk %fp <== NOT EXECUTED
00055304 <rtems_rfs_bitmap_map_clear>:
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
55304: 4e56 ffec linkw %fp,#-20
55308: 48d7 041c moveml %d2-%d4/%a2,%sp@
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
5530c: 486e fffc pea %fp@(-4)
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
55310: 246e 0008 moveal %fp@(8),%a2
55314: 242e 000c movel %fp@(12),%d2
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
55318: 2f0a movel %a2,%sp@-
5531a: 4eba fd50 jsr %pc@(5506c <rtems_rfs_bitmap_load_map>)
if (rc > 0)
5531e: 508f addql #8,%sp
55320: 4a80 tstl %d0
55322: 6e42 bgts 55366 <rtems_rfs_bitmap_map_clear+0x62><== NEVER TAKEN
return rc;
if (bit >= control->size)
55324: b4aa 000c cmpl %a2@(12),%d2
55328: 643a bccs 55364 <rtems_rfs_bitmap_map_clear+0x60><== NEVER TAKEN
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
5532a: 2202 movel %d2,%d1
5532c: ea81 asrl #5,%d1
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
5532e: 2001 movel %d1,%d0
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
55330: 761f moveq #31,%d3
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
55332: e588 lsll #2,%d0
55334: 226e fffc moveal %fp@(-4),%a1
55338: d3c0 addal %d0,%a1
5533a: 7001 moveq #1,%d0
5533c: 2800 movel %d0,%d4
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
5533e: c682 andl %d2,%d3
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
55340: 206a 0014 moveal %a2@(20),%a0
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
55344: e7ac lsll %d3,%d4
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
55346: 760a moveq #10,%d3
55348: e6a2 asrl %d3,%d2
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_clear (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
5534a: 8991 orl %d4,%a1@
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
5534c: 781f moveq #31,%d4
5534e: c284 andl %d4,%d1
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
55350: e3a8 lsll %d1,%d0
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_clear (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
55352: 81b0 2c00 orl %d0,%a0@(00000000,%d2:l:4)
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
55356: 2052 moveal %a2@,%a0
control->free++;
return 0;
55358: 4280 clrl %d0
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
5535a: 10bc 0001 moveb #1,%a0@
control->free++;
5535e: 52aa 0010 addql #1,%a2@(16)
return 0;
55362: 6002 bras 55366 <rtems_rfs_bitmap_map_clear+0x62>
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
55364: 7016 moveq #22,%d0 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
return 0;
}
55366: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
5536c: 4e5e unlk %fp <== NOT EXECUTED
00055424 <rtems_rfs_bitmap_map_clear_all>:
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
55424: 4e56 fff0 linkw %fp,#-16
55428: 48d7 040c moveml %d2-%d3/%a2,%sp@
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
5542c: 486e fffc pea %fp@(-4)
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
55430: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
55434: 2f0a movel %a2,%sp@-
55436: 4eba fc34 jsr %pc@(5506c <rtems_rfs_bitmap_load_map>)
if (rc > 0)
5543a: 508f addql #8,%sp
5543c: 4a80 tstl %d0
5543e: 6e58 bgts 55498 <rtems_rfs_bitmap_map_clear_all+0x74><== NEVER TAKEN
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
55440: 202a 000c movel %a2@(12),%d0
55444: 5380 subql #1,%d0
55446: ea88 lsrl #5,%d0
55448: 2200 movel %d0,%d1
5544a: 5281 addql #1,%d1
control->free = elements;
for (e = 0; e < elements; e++)
5544c: 91c8 subal %a0,%a0
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
5544e: 2541 0010 movel %d1,%a2@(16)
55452: 226e fffc moveal %fp@(-4),%a1
for (e = 0; e < elements; e++)
55456: 6006 bras 5545e <rtems_rfs_bitmap_map_clear_all+0x3a>
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
55458: 74ff moveq #-1,%d2
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
5545a: 5288 addql #1,%a0
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
5545c: 22c2 movel %d2,%a1@+
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
5545e: b288 cmpl %a0,%d1
55460: 62f6 bhis 55458 <rtems_rfs_bitmap_map_clear_all+0x34>
/*
* Set the un-mapped bits in the last search element so the available logic
* works.
*/
last_search_bit = rtems_rfs_bitmap_map_offset (elements);
55462: 741f moveq #31,%d2
55464: c282 andl %d2,%d1
if (last_search_bit == 0)
55466: 6604 bnes 5546c <rtems_rfs_bitmap_map_clear_all+0x48><== NEVER TAKEN
last_search_bit = rtems_rfs_bitmap_element_bits ();
55468: 123c 0020 moveb #32,%d1
elements = rtems_rfs_bitmap_elements (elements);
5546c: 2400 movel %d0,%d2
5546e: ea8a lsrl #5,%d2
for (e = 0; e < (elements - 1); e++)
55470: 4280 clrl %d0
55472: 6008 bras 5547c <rtems_rfs_bitmap_map_clear_all+0x58>
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
55474: 76ff moveq #-1,%d3 <== NOT EXECUTED
55476: 2183 0c00 movel %d3,%a0@(00000000,%d0:l:4) <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
5547a: 5280 addql #1,%d0 <== NOT EXECUTED
5547c: 206a 0014 moveal %a2@(20),%a0
55480: b480 cmpl %d0,%d2
55482: 66f0 bnes 55474 <rtems_rfs_bitmap_map_clear_all+0x50><== NEVER TAKEN
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
55484: 7420 moveq #32,%d2
55486: 9481 subl %d1,%d2
55488: 72ff moveq #-1,%d1
5548a: e4a9 lsrl %d2,%d1
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
5548c: 2181 0c00 movel %d1,%a0@(00000000,%d0:l:4)
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
55490: 4280 clrl %d0
control->search_bits[elements - 1] =
rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
55492: 2052 moveal %a2@,%a0
55494: 10bc 0001 moveb #1,%a0@
return 0;
}
55498: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
5549e: 4e5e unlk %fp <== NOT EXECUTED
00055288 <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
55288: 4e56 ffec linkw %fp,#-20
5528c: 48d7 041c moveml %d2-%d4/%a2,%sp@
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
55290: 486e fffc pea %fp@(-4)
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
55294: 246e 0008 moveal %fp@(8),%a2
55298: 242e 000c movel %fp@(12),%d2
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
5529c: 2f0a movel %a2,%sp@-
5529e: 4eba fdcc jsr %pc@(5506c <rtems_rfs_bitmap_load_map>)
if (rc > 0)
552a2: 508f addql #8,%sp
552a4: 4a80 tstl %d0
552a6: 6e52 bgts 552fa <rtems_rfs_bitmap_map_set+0x72> <== NEVER TAKEN
return rc;
if (bit >= control->size)
552a8: b4aa 000c cmpl %a2@(12),%d2
552ac: 6446 bccs 552f4 <rtems_rfs_bitmap_map_set+0x6c> <== NEVER TAKEN
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
552ae: 2602 movel %d2,%d3
552b0: ea83 asrl #5,%d3
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
552b2: 2003 movel %d3,%d0
552b4: 7201 moveq #1,%d1
552b6: 2801 movel %d1,%d4
552b8: e588 lsll #2,%d0
552ba: 226e fffc moveal %fp@(-4),%a1
552be: d3c0 addal %d0,%a1
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
552c0: 701f moveq #31,%d0
552c2: c082 andl %d2,%d0
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
552c4: 206a 0014 moveal %a2@(20),%a0
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
552c8: e1ac lsll %d0,%d4
552ca: 2004 movel %d4,%d0
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
552cc: 4680 notl %d0
552ce: c091 andl %a1@,%d0
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
552d0: 2280 movel %d0,%a1@
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
552d2: 6624 bnes 552f8 <rtems_rfs_bitmap_map_set+0x70> <== ALWAYS TAKEN
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
552d4: 781f moveq #31,%d4 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
552d6: 103c 000a moveb #10,%d0 <== NOT EXECUTED
552da: e0a2 asrl %d0,%d2 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
552dc: 2001 movel %d1,%d0 <== NOT EXECUTED
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
552de: c684 andl %d4,%d3 <== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
552e0: e7a8 lsll %d3,%d0 <== NOT EXECUTED
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
552e2: 4680 notl %d0 <== NOT EXECUTED
552e4: c1b0 2c00 andl %d0,%a0@(00000000,%d2:l:4) <== NOT EXECUTED
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
552e8: 2052 moveal %a2@,%a0 <== NOT EXECUTED
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
552ea: 53aa 0010 subql #1,%a2@(16) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
552ee: 10bc 0001 moveb #1,%a0@ <== NOT EXECUTED
552f2: 6004 bras 552f8 <rtems_rfs_bitmap_map_set+0x70> <== NOT EXECUTED
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
552f4: 7016 moveq #22,%d0 <== NOT EXECUTED
552f6: 6002 bras 552fa <rtems_rfs_bitmap_map_set+0x72> <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
}
return 0;
552f8: 4280 clrl %d0
}
552fa: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
55300: 4e5e unlk %fp <== NOT EXECUTED
000553c2 <rtems_rfs_bitmap_map_set_all>:
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
553c2: 4e56 fffc linkw %fp,#-4 <== NOT EXECUTED
553c6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
553c8: 486e fffc pea %fp@(-4) <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
553cc: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
553d0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
553d2: 4eba fc98 jsr %pc@(5506c <rtems_rfs_bitmap_load_map>) <== NOT EXECUTED
if (rc > 0)
553d6: 508f addql #8,%sp <== NOT EXECUTED
553d8: 4a80 tstl %d0 <== NOT EXECUTED
553da: 6e40 bgts 5541c <rtems_rfs_bitmap_map_set_all+0x5a><== NOT EXECUTED
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
553dc: 202a 000c movel %a2@(12),%d0 <== NOT EXECUTED
553e0: 5380 subql #1,%d0 <== NOT EXECUTED
553e2: ea88 lsrl #5,%d0 <== NOT EXECUTED
553e4: 2240 moveal %d0,%a1 <== NOT EXECUTED
553e6: 5289 addql #1,%a1 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
553e8: 4281 clrl %d1 <== NOT EXECUTED
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
553ea: 42aa 0010 clrl %a2@(16) <== NOT EXECUTED
553ee: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
for (e = 0; e < elements; e++)
553f2: 6004 bras 553f8 <rtems_rfs_bitmap_map_set_all+0x36><== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
553f4: 4298 clrl %a0@+ <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
553f6: 5281 addql #1,%d1 <== NOT EXECUTED
553f8: b3c1 cmpal %d1,%a1 <== NOT EXECUTED
553fa: 62f8 bhis 553f4 <rtems_rfs_bitmap_map_set_all+0x32><== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
553fc: ea88 lsrl #5,%d0 <== NOT EXECUTED
553fe: 2200 movel %d0,%d1 <== NOT EXECUTED
55400: 5281 addql #1,%d1 <== NOT EXECUTED
for (e = 0; e < elements; e++)
55402: 4280 clrl %d0 <== NOT EXECUTED
55404: 600a bras 55410 <rtems_rfs_bitmap_map_set_all+0x4e><== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
55406: 206a 0014 moveal %a2@(20),%a0 <== NOT EXECUTED
5540a: 42b0 0c00 clrl %a0@(00000000,%d0:l:4) <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
5540e: 5280 addql #1,%d0 <== NOT EXECUTED
55410: b280 cmpl %d0,%d1 <== NOT EXECUTED
55412: 62f2 bhis 55406 <rtems_rfs_bitmap_map_set_all+0x44><== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
55414: 2052 moveal %a2@,%a0 <== NOT EXECUTED
return 0;
55416: 4280 clrl %d0 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
55418: 10bc 0001 moveb #1,%a0@ <== NOT EXECUTED
return 0;
}
5541c: 246e fff8 moveal %fp@(-8),%a2 <== NOT EXECUTED
55420: 4e5e unlk %fp <== NOT EXECUTED
00055370 <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
55370: 4e56 fffc linkw %fp,#-4 <== NOT EXECUTED
55374: 2f0a movel %a2,%sp@- <== NOT EXECUTED
55376: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
5537a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
5537c: 486e fffc pea %fp@(-4) <== NOT EXECUTED
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
55380: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
55384: 2f0a movel %a2,%sp@- <== NOT EXECUTED
55386: 4eba fce4 jsr %pc@(5506c <rtems_rfs_bitmap_load_map>) <== NOT EXECUTED
if (rc > 0)
5538a: 508f addql #8,%sp <== NOT EXECUTED
5538c: 4a80 tstl %d0 <== NOT EXECUTED
5538e: 6e26 bgts 553b6 <rtems_rfs_bitmap_map_test+0x46> <== NOT EXECUTED
return rc;
if (bit >= control->size)
55390: b4aa 000c cmpl %a2@(12),%d2 <== NOT EXECUTED
55394: 641e bccs 553b4 <rtems_rfs_bitmap_map_test+0x44> <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
55396: 7001 moveq #1,%d0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
55398: 2202 movel %d2,%d1 <== NOT EXECUTED
5539a: ea81 asrl #5,%d1 <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
5539c: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
553a0: e5a8 lsll %d2,%d0 <== NOT EXECUTED
553a2: c0b0 1c00 andl %a0@(00000000,%d1:l:4),%d0 <== NOT EXECUTED
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
553a6: 206e 0010 moveal %fp@(16),%a0 <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
553aa: 57c0 seq %d0 <== NOT EXECUTED
553ac: 4480 negl %d0 <== NOT EXECUTED
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
553ae: 1080 moveb %d0,%a0@ <== NOT EXECUTED
return 0;
553b0: 4280 clrl %d0 <== NOT EXECUTED
553b2: 6002 bras 553b6 <rtems_rfs_bitmap_map_test+0x46> <== NOT EXECUTED
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
553b4: 7016 moveq #22,%d0 <== NOT EXECUTED
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
return 0;
}
553b6: 242e fff4 movel %fp@(-12),%d2 <== NOT EXECUTED
553ba: 246e fff8 moveal %fp@(-8),%a2 <== NOT EXECUTED
553be: 4e5e unlk %fp <== NOT EXECUTED
0005524e <rtems_rfs_bitmap_mask>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
5524e: 7220 moveq #32,%d1 <== NOT EXECUTED
return mask;
}
55250: 70ff moveq #-1,%d0 <== NOT EXECUTED
return 0;
}
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
55252: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
55256: 92ae 0008 subl %fp@(8),%d1 <== NOT EXECUTED
return mask;
}
5525a: 4e5e unlk %fp <== NOT EXECUTED
5525c: e2a8 lsrl %d1,%d0 <== NOT EXECUTED
00055260 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
55260: 4e56 0000 linkw %fp,#0
55264: 222e 0008 movel %fp@(8),%d1
55268: 202e 000c movel %fp@(12),%d0
5526c: 2f02 movel %d2,%sp@-
rtems_rfs_bitmap_element mask = 0;
if (end > start)
5526e: b280 cmpl %d0,%d1
55270: 640e bccs 55280 <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
mask = rtems_rfs_bitmap_mask (end - start) << start;
55272: 9081 subl %d1,%d0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
55274: 7420 moveq #32,%d2
55276: 9480 subl %d0,%d2
55278: 70ff moveq #-1,%d0
5527a: e4a8 lsrl %d2,%d0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
5527c: e3a8 lsll %d1,%d0
5527e: 6002 bras 55282 <rtems_rfs_bitmap_mask_section+0x22>
}
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
55280: 4280 clrl %d0 <== NOT EXECUTED
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
return mask;
}
55282: 241f movel %sp@+,%d2
55284: 4e5e unlk %fp <== NOT EXECUTED
000555ce <rtems_rfs_bitmap_open>:
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
555ce: 720a moveq #10,%d1
rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
555d0: 4e56 0000 linkw %fp,#0
555d4: 202e 0014 movel %fp@(20),%d0
555d8: 2f0a movel %a2,%sp@-
555da: 246e 0008 moveal %fp@(8),%a2
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
555de: 2540 000c movel %d0,%a2@(12)
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
555e2: 5380 subql #1,%d0
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
555e4: e2a8 lsrl %d1,%d0
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
555e6: e588 lsll #2,%d0
size_t size,
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
555e8: 24ae 0010 movel %fp@(16),%a2@
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
555ec: 2040 moveal %d0,%a0
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
control->fs = fs;
555ee: 256e 000c 0004 movel %fp@(12),%a2@(4)
control->block = block;
555f4: 256e 0018 0008 movel %fp@(24),%a2@(8)
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
555fa: 4868 0004 pea %a0@(4)
555fe: 4eb9 0004 5af0 jsr 45af0 <malloc>
if (!control->search_bits)
55604: 588f addql #4,%sp
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
55606: 2540 0014 movel %d0,%a2@(20)
if (!control->search_bits)
5560a: 6710 beqs 5561c <rtems_rfs_bitmap_open+0x4e> <== NEVER TAKEN
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
5560c: 2d4a 0008 movel %a2,%fp@(8)
}
55610: 246e fffc moveal %fp@(-4),%a2
55614: 4e5e unlk %fp
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
if (!control->search_bits)
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
55616: 4ef9 0005 5538 jmp 55538 <rtems_rfs_bitmap_create_search>
}
5561c: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
55620: 700c moveq #12,%d0 <== NOT EXECUTED
55622: 4e5e unlk %fp <== NOT EXECUTED
00055768 <rtems_rfs_block_find_indirect>:
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
55768: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
5576c: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@ <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
55770: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
55774: 242e 0010 movel %fp@(16),%d2 <== NOT EXECUTED
55778: 286e 000c moveal %fp@(12),%a4 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
5577c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
5577e: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
55782: 2f0c movel %a4,%sp@- <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
55784: 262e 0014 movel %fp@(20),%d3 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
55788: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
5578a: 246e 0018 moveal %fp@(24),%a2 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
5578e: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
55794: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
55798: 4a80 tstl %d0 <== NOT EXECUTED
5579a: 6e76 bgts 55812 <rtems_rfs_block_find_indirect+0xaa><== NOT EXECUTED
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
5579c: 206c 0006 moveal %a4@(6),%a0 <== NOT EXECUTED
557a0: 2203 movel %d3,%d1 <== NOT EXECUTED
557a2: 4284 clrl %d4 <== NOT EXECUTED
557a4: 4280 clrl %d0 <== NOT EXECUTED
557a6: 7a18 moveq #24,%d5 <== NOT EXECUTED
557a8: e589 lsll #2,%d1 <== NOT EXECUTED
557aa: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
557ae: 1830 1800 moveb %a0@(00000000,%d1:l),%d4 <== NOT EXECUTED
557b2: 1030 1803 moveb %a0@(00000003,%d1:l),%d0 <== NOT EXECUTED
557b6: ebac lsll %d5,%d4 <== NOT EXECUTED
557b8: 8084 orl %d4,%d0 <== NOT EXECUTED
557ba: 4284 clrl %d4 <== NOT EXECUTED
557bc: 1830 1801 moveb %a0@(00000001,%d1:l),%d4 <== NOT EXECUTED
557c0: 1230 1802 moveb %a0@(00000002,%d1:l),%d1 <== NOT EXECUTED
557c4: 4844 swap %d4 <== NOT EXECUTED
557c6: 4244 clrw %d4 <== NOT EXECUTED
557c8: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
557ce: 8084 orl %d4,%d0 <== NOT EXECUTED
557d0: e189 lsll #8,%d1 <== NOT EXECUTED
557d2: 8081 orl %d1,%d0 <== NOT EXECUTED
if ((*result + 1) == 0)
557d4: 72ff moveq #-1,%d1 <== NOT EXECUTED
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
557d6: 2480 movel %d0,%a2@ <== NOT EXECUTED
if ((*result + 1) == 0)
557d8: b280 cmpl %d0,%d1 <== NOT EXECUTED
557da: 6602 bnes 557de <rtems_rfs_block_find_indirect+0x76><== NOT EXECUTED
*result = 0;
557dc: 4292 clrl %a2@ <== NOT EXECUTED
if (*result >= rtems_rfs_fs_blocks (fs))
557de: 266b 0004 moveal %a3@(4),%a3 <== NOT EXECUTED
557e2: b7d2 cmpal %a2@,%a3 <== NOT EXECUTED
557e4: 622a bhis 55810 <rtems_rfs_block_find_indirect+0xa8><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
557e6: 4878 1000 pea 1000 <D_MAX_EXP+0x801> <== NOT EXECUTED
557ea: 42a7 clrl %sp@- <== NOT EXECUTED
557ec: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
557f2: 508f addql #8,%sp <== NOT EXECUTED
557f4: 4a00 tstb %d0 <== NOT EXECUTED
557f6: 6716 beqs 5580e <rtems_rfs_block_find_indirect+0xa6><== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
557f8: 2f03 movel %d3,%sp@- <== NOT EXECUTED
557fa: 2f02 movel %d2,%sp@- <== NOT EXECUTED
557fc: 2f12 movel %a2@,%sp@- <== NOT EXECUTED
557fe: 4879 0006 c6f1 pea 6c6f1 <CSWTCH.1+0x37> <== NOT EXECUTED
55804: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5580a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
5580e: 4292 clrl %a2@ <== NOT EXECUTED
*result = rtems_rfs_block_get_number (buffer, offset);
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
55810: 4280 clrl %d0 <== NOT EXECUTED
*result = 0;
rc = EIO;
}
return 0;
}
55812: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4 <== NOT EXECUTED
55818: 4e5e unlk %fp <== NOT EXECUTED
00055926 <rtems_rfs_block_get_block_size>:
void
rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_size* size)
{
55926: 4e56 ffec linkw %fp,#-20 <== NOT EXECUTED
5592a: 48d7 043c moveml %d2-%d5/%a2,%sp@ <== NOT EXECUTED
5592e: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
55932: 262e 0010 movel %fp@(16),%d3 <== NOT EXECUTED
55936: 246e 0014 moveal %fp@(20),%a2 <== NOT EXECUTED
if (pos == 0)
5593a: 2002 movel %d2,%d0 <== NOT EXECUTED
5593c: 8083 orl %d3,%d0 <== NOT EXECUTED
5593e: 6608 bnes 55948 <rtems_rfs_block_get_block_size+0x22><== NOT EXECUTED
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
55940: 4292 clrl %a2@ <== NOT EXECUTED
size->offset = 0;
55942: 42aa 0004 clrl %a2@(4) <== NOT EXECUTED
55946: 6036 bras 5597e <rtems_rfs_block_get_block_size+0x58><== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
55948: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
5594c: 4284 clrl %d4 <== NOT EXECUTED
5594e: 2a28 0008 movel %a0@(8),%d5 <== NOT EXECUTED
55952: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55954: 2f04 movel %d4,%sp@- <== NOT EXECUTED
55956: 2f03 movel %d3,%sp@- <== NOT EXECUTED
55958: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5595a: 4eb9 0006 8874 jsr 68874 <__udivdi3> <== NOT EXECUTED
55960: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
55964: 5281 addql #1,%d1 <== NOT EXECUTED
55966: 2481 movel %d1,%a2@ <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
55968: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5596a: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5596c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5596e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55970: 4eb9 0006 8ca0 jsr 68ca0 <__umoddi3> <== NOT EXECUTED
55976: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5597a: 2541 0004 movel %d1,%a2@(4) <== NOT EXECUTED
}
}
5597e: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2 <== NOT EXECUTED
55984: 4e5e unlk %fp <== NOT EXECUTED
00055b60 <rtems_rfs_block_map_close>:
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
55b60: 4e56 ffe8 linkw %fp,#-24
55b64: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
55b68: 262e 0008 movel %fp@(8),%d3
55b6c: 246e 000c moveal %fp@(12),%a2
int rc = 0;
int brc;
if (map->dirty && map->inode)
55b70: 4a12 tstb %a2@
55b72: 6700 015e beqw 55cd2 <rtems_rfs_block_map_close+0x172>
55b76: 202a 0002 movel %a2@(2),%d0
55b7a: 6700 0156 beqw 55cd2 <rtems_rfs_block_map_close+0x172>
{
brc = rtems_rfs_inode_load (fs, map->inode);
55b7e: 2f00 movel %d0,%sp@-
55b80: 2f03 movel %d3,%sp@-
55b82: 4eb9 0004 d73c jsr 4d73c <rtems_rfs_inode_load>
if (brc > 0)
55b88: 508f addql #8,%sp
55b8a: 4a80 tstl %d0
55b8c: 6e00 0148 bgtw 55cd6 <rtems_rfs_block_map_close+0x176>
55b90: 7001 moveq #1,%d0
55b92: 4281 clrl %d1
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
55b94: 2432 0821 movel %a2@(00000021,%d0:l),%d2
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
55b98: 7a18 moveq #24,%d5
55b9a: 2802 movel %d2,%d4
55b9c: eaac lsrl %d5,%d4
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
55b9e: 1a3c 0005 moveb #5,%d5
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
55ba2: 206a 0002 moveal %a2@(2),%a0
55ba6: 2268 000c moveal %a0@(12),%a1
55baa: 1384 1c1c moveb %d4,%a1@(0000001c,%d1:l:4)
55bae: 2802 movel %d2,%d4
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
55bb0: 5281 addql #1,%d1
55bb2: 2268 000c moveal %a0@(12),%a1
55bb6: 4244 clrw %d4
55bb8: 4844 swap %d4
55bba: 1384 081c moveb %d4,%a1@(0000001c,%d0:l)
55bbe: 2802 movel %d2,%d4
55bc0: e08c lsrl #8,%d4
55bc2: 2268 000c moveal %a0@(12),%a1
55bc6: 1384 081d moveb %d4,%a1@(0000001d,%d0:l)
55bca: 2268 000c moveal %a0@(12),%a1
55bce: 1382 081e moveb %d2,%a1@(0000001e,%d0:l)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55bd2: 7401 moveq #1,%d2
55bd4: 5880 addql #4,%d0
55bd6: 1142 0010 moveb %d2,%a0@(16)
55bda: ba81 cmpl %d1,%d5
55bdc: 66b6 bnes 55b94 <rtems_rfs_block_map_close+0x34>
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
55bde: 206a 0002 moveal %a2@(2),%a0
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
55be2: 7418 moveq #24,%d2
55be4: 202a 0006 movel %a2@(6),%d0
55be8: 2200 movel %d0,%d1
55bea: e4a9 lsrl %d2,%d1
55bec: 2268 000c moveal %a0@(12),%a1
55bf0: 1341 000c moveb %d1,%a1@(12)
55bf4: 2200 movel %d0,%d1
55bf6: 2268 000c moveal %a0@(12),%a1
55bfa: 4241 clrw %d1
55bfc: 4841 swap %d1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55bfe: 7a01 moveq #1,%d5
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
55c00: 1341 000d moveb %d1,%a1@(13)
55c04: 2200 movel %d0,%d1
55c06: e089 lsrl #8,%d1
55c08: 2268 000c moveal %a0@(12),%a1
55c0c: 1341 000e moveb %d1,%a1@(14)
55c10: 2268 000c moveal %a0@(12),%a1
55c14: 1340 000f moveb %d0,%a1@(15)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55c18: 1145 0010 moveb %d5,%a0@(16)
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
55c1c: 206a 0002 moveal %a2@(2),%a0
55c20: 302a 000c movew %a2@(12),%d0
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
55c24: 2268 000c moveal %a0@(12),%a1
55c28: 2200 movel %d0,%d1
55c2a: e089 lsrl #8,%d1
55c2c: 1341 000a moveb %d1,%a1@(10)
55c30: 2268 000c moveal %a0@(12),%a1
55c34: 1340 000b moveb %d0,%a1@(11)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55c38: 1145 0010 moveb %d5,%a0@(16)
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
55c3c: 206a 0002 moveal %a2@(2),%a0
55c40: 202a 001a movel %a2@(26),%d0
* @param block_count The last map block number.
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
55c44: 2200 movel %d0,%d1
55c46: e4a9 lsrl %d2,%d1
55c48: 2268 000c moveal %a0@(12),%a1
55c4c: 1341 0030 moveb %d1,%a1@(48)
55c50: 2200 movel %d0,%d1
55c52: 2268 000c moveal %a0@(12),%a1
55c56: 4241 clrw %d1
55c58: 4841 swap %d1
55c5a: 1341 0031 moveb %d1,%a1@(49)
55c5e: 2200 movel %d0,%d1
55c60: e089 lsrl #8,%d1
55c62: 2268 000c moveal %a0@(12),%a1
55c66: 1341 0032 moveb %d1,%a1@(50)
55c6a: 2268 000c moveal %a0@(12),%a1
55c6e: 1340 0033 moveb %d0,%a1@(51)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55c72: 1145 0010 moveb %d5,%a0@(16)
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
55c76: 206a 0002 moveal %a2@(2),%a0
55c7a: 202a 001e movel %a2@(30),%d0
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
55c7e: 2200 movel %d0,%d1
55c80: e4a9 lsrl %d2,%d1
55c82: 2268 000c moveal %a0@(12),%a1
55c86: 1341 0034 moveb %d1,%a1@(52)
55c8a: 2200 movel %d0,%d1
55c8c: 2268 000c moveal %a0@(12),%a1
55c90: 4241 clrw %d1
55c92: 4841 swap %d1
55c94: 1341 0035 moveb %d1,%a1@(53)
55c98: 2268 000c moveal %a0@(12),%a1
55c9c: 2200 movel %d0,%d1
55c9e: e089 lsrl #8,%d1
55ca0: 1341 0036 moveb %d1,%a1@(54)
55ca4: 2268 000c moveal %a0@(12),%a1
55ca8: 1340 0037 moveb %d0,%a1@(55)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55cac: 1145 0010 moveb %d5,%a0@(16)
brc = rtems_rfs_inode_unload (fs, map->inode, true);
55cb0: 4878 0001 pea 1 <ADD>
55cb4: 2f2a 0002 movel %a2@(2),%sp@-
55cb8: 2f03 movel %d3,%sp@-
55cba: 4eb9 0004 d890 jsr 4d890 <rtems_rfs_inode_unload>
55cc0: 4fef 000c lea %sp@(12),%sp
55cc4: 2400 movel %d0,%d2
55cc6: 4680 notl %d0
55cc8: d080 addl %d0,%d0
55cca: 9180 subxl %d0,%d0
if (brc > 0)
rc = brc;
map->dirty = false;
55ccc: 4212 clrb %a2@
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
55cce: c480 andl %d0,%d2
55cd0: 6006 bras 55cd8 <rtems_rfs_block_map_close+0x178>
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
int rc = 0;
55cd2: 4282 clrl %d2
55cd4: 6002 bras 55cd8 <rtems_rfs_block_map_close+0x178>
int brc;
if (map->dirty && map->inode)
{
brc = rtems_rfs_inode_load (fs, map->inode);
if (brc > 0)
55cd6: 2400 movel %d0,%d2 <== NOT EXECUTED
map->dirty = false;
}
}
map->inode = NULL;
55cd8: 42aa 0002 clrl %a2@(2)
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55cdc: 486a 0036 pea %a2@(54)
55ce0: 47f9 0005 6580 lea 56580 <rtems_rfs_buffer_handle_release>,%a3
55ce6: 2f03 movel %d3,%sp@-
handle->dirty = false;
55ce8: 4205 clrb %d5
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55cea: 4e93 jsr %a3@
handle->dirty = false;
55cec: 4200 clrb %d0
55cee: 1540 0036 moveb %d0,%a2@(54)
handle->bnum = 0;
55cf2: 42aa 0038 clrl %a2@(56)
handle->buffer = NULL;
55cf6: 42aa 003c clrl %a2@(60)
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55cfa: 486a 0040 pea %a2@(64)
55cfe: 2f03 movel %d3,%sp@-
55d00: 4e93 jsr %a3@
rc = brc;
brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
if ((brc > 0) && (rc == 0))
rc = brc;
return rc;
}
55d02: 2002 movel %d2,%d0
handle->dirty = false;
55d04: 1545 0040 moveb %d5,%a2@(64)
handle->bnum = 0;
55d08: 42aa 0042 clrl %a2@(66)
handle->buffer = NULL;
55d0c: 42aa 0046 clrl %a2@(70)
55d10: 4cee 0c3c ffe8 moveml %fp@(-24),%d2-%d5/%a2-%a3
55d16: 4e5e unlk %fp <== NOT EXECUTED
00055d1a <rtems_rfs_block_map_find>:
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
55d1a: 4e56 ffe0 linkw %fp,#-32
55d1e: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
55d22: 266e 0014 moveal %fp@(20),%a3
55d26: 2a6e 0010 moveal %fp@(16),%a5
int rc = 0;
*block = 0;
55d2a: 4293 clrl %a3@
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
55d2c: 286e 0008 moveal %fp@(8),%a4
55d30: 246e 000c moveal %fp@(12),%a2
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
55d34: 2015 movel %a5@,%d0
55d36: 6708 beqs 55d40 <rtems_rfs_block_map_find+0x26>
55d38: 4aaa 0006 tstl %a2@(6)
55d3c: 6700 00bc beqw 55dfa <rtems_rfs_block_map_find+0xe0>
55d40: 222a 0006 movel %a2@(6),%d1
55d44: b280 cmpl %d0,%d1
55d46: 6300 00b2 blsw 55dfa <rtems_rfs_block_map_find+0xe0>
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
55d4a: b0aa 000e cmpl %a2@(14),%d0
55d4e: 660e bnes 55d5e <rtems_rfs_block_map_find+0x44> <== NEVER TAKEN
55d50: 206a 0016 moveal %a2@(22),%a0
55d54: 4a88 tstl %a0
55d56: 6706 beqs 55d5e <rtems_rfs_block_map_find+0x44> <== ALWAYS TAKEN
{
*block = map->bpos.block;
55d58: 2688 movel %a0,%a3@ <== NOT EXECUTED
55d5a: 6000 0086 braw 55de2 <rtems_rfs_block_map_find+0xc8> <== NOT EXECUTED
/*
* Determine the type of access we need to perform. If the number of blocks
* is less than or equal to the number of slots in the inode the blocks are
* directly accessed.
*/
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
55d5e: 7405 moveq #5,%d2
55d60: b481 cmpl %d1,%d2
55d62: 6506 bcss 55d6a <rtems_rfs_block_map_find+0x50> <== NEVER TAKEN
{
*block = map->blocks[bpos->bno];
55d64: 26b2 0c22 movel %a2@(00000022,%d0:l:4),%a3@
55d68: 6078 bras 55de2 <rtems_rfs_block_map_find+0xc8>
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
55d6a: 242c 0030 movel %a4@(48),%d2 <== NOT EXECUTED
55d6e: 4c42 0003 remul %d2,%d3,%d0 <== NOT EXECUTED
55d72: 4c42 0000 remul %d2,%d0,%d0 <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
55d76: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
if (map->size.count <= fs->block_map_singly_blocks)
55d7a: b2ac 0034 cmpl %a4@(52),%d1 <== NOT EXECUTED
55d7e: 6214 bhis 55d94 <rtems_rfs_block_map_find+0x7a> <== NOT EXECUTED
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
55d80: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55d82: 2f03 movel %d3,%sp@- <== NOT EXECUTED
55d84: 2f32 0c22 movel %a2@(00000022,%d0:l:4),%sp@- <== NOT EXECUTED
55d88: 486a 0036 pea %a2@(54) <== NOT EXECUTED
55d8c: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55d8e: 4eba f9d8 jsr %pc@(55768 <rtems_rfs_block_find_indirect>)<== NOT EXECUTED
55d92: 6046 bras 55dda <rtems_rfs_block_map_find+0xc0> <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
55d94: 4c42 0004 remul %d2,%d4,%d0 <== NOT EXECUTED
55d98: 4c42 0000 remul %d2,%d0,%d0 <== NOT EXECUTED
55d9c: 2d44 fffc movel %d4,%fp@(-4) <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
55da0: b2ac 0038 cmpl %a4@(56),%d1 <== NOT EXECUTED
55da4: 6454 bccs 55dfa <rtems_rfs_block_map_find+0xe0> <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
55da6: 486e fffc pea %fp@(-4) <== NOT EXECUTED
55daa: 243c 0005 5768 movel #350056,%d2 <== NOT EXECUTED
55db0: 2042 moveal %d2,%a0 <== NOT EXECUTED
55db2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
55db4: 2f32 0c22 movel %a2@(00000022,%d0:l:4),%sp@- <== NOT EXECUTED
55db8: 486a 0040 pea %a2@(64) <== NOT EXECUTED
55dbc: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55dbe: 4e90 jsr %a0@ <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
55dc0: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
55dc4: 4a80 tstl %d0 <== NOT EXECUTED
55dc6: 6634 bnes 55dfc <rtems_rfs_block_map_find+0xe2> <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
55dc8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55dca: 2042 moveal %d2,%a0 <== NOT EXECUTED
55dcc: 2f03 movel %d3,%sp@- <== NOT EXECUTED
55dce: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
55dd2: 486a 0036 pea %a2@(54) <== NOT EXECUTED
55dd6: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55dd8: 4e90 jsr %a0@ <== NOT EXECUTED
55dda: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
}
}
}
}
if (rc == 0)
55dde: 4a80 tstl %d0 <== NOT EXECUTED
55de0: 661a bnes 55dfc <rtems_rfs_block_map_find+0xe2> <== NOT EXECUTED
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
55de2: 2555 000e movel %a5@,%a2@(14)
map->bpos.block = *block;
55de6: 4280 clrl %d0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
55de8: 256d 0004 0012 movel %a5@(4),%a2@(18)
55dee: 256d 0008 0016 movel %a5@(8),%a2@(22)
map->bpos.block = *block;
55df4: 2553 0016 movel %a3@,%a2@(22)
55df8: 6002 bras 55dfc <rtems_rfs_block_map_find+0xe2>
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
return ENXIO;
55dfa: 7006 moveq #6,%d0
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
}
return rc;
}
55dfc: 4cee 3c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a5
55e02: 4e5e unlk %fp <== NOT EXECUTED
00055eb6 <rtems_rfs_block_map_grow>:
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
55eb6: 4e56 ffd0 linkw %fp,#-48
55eba: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
55ebe: 4878 2000 pea 2000 <D_MAX_EXP+0x1801>
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
55ec2: 266e 0008 moveal %fp@(8),%a3
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
55ec6: 42a7 clrl %sp@-
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
55ec8: 246e 000c moveal %fp@(12),%a2
55ecc: 242e 0010 movel %fp@(16),%d2
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
55ed0: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
55ed6: 508f addql #8,%sp
55ed8: 4a00 tstb %d0
55eda: 6716 beqs 55ef2 <rtems_rfs_block_map_grow+0x3c> <== ALWAYS TAKEN
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
55edc: 2f2a 0006 movel %a2@(6),%sp@- <== NOT EXECUTED
55ee0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55ee2: 4879 0006 c73c pea 6c73c <CSWTCH.1+0x82> <== NOT EXECUTED
55ee8: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
55eee: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
55ef2: 2002 movel %d2,%d0
55ef4: d0aa 0006 addl %a2@(6),%d0
55ef8: b0ab 0038 cmpl %a3@(56),%d0
55efc: 6400 0262 bccw 56160 <rtems_rfs_block_map_grow+0x2aa>
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
55f00: 260a movel %a2,%d3
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
55f02: 4284 clrl %d4
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
55f04: 4bea 0040 lea %a2@(64),%a5
55f08: 49f9 0005 66f8 lea 566f8 <rtems_rfs_buffer_handle_request>,%a4
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
55f0e: 0683 0000 0036 addil #54,%d3
55f14: 6000 0240 braw 56156 <rtems_rfs_block_map_grow+0x2a0>
/*
* Allocate the block. If an indirect block is needed and cannot be
* allocated free this block.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
55f18: 486e fff8 pea %fp@(-8)
55f1c: 42a7 clrl %sp@-
55f1e: 2f2a 001e movel %a2@(30),%sp@-
55f22: 2f0b movel %a3,%sp@-
55f24: 4eb9 0004 d3b8 jsr 4d3b8 <rtems_rfs_group_bitmap_alloc>
false, &block);
if (rc > 0)
55f2a: 4fef 0010 lea %sp@(16),%sp
55f2e: 4a80 tstl %d0
55f30: 6e00 0232 bgtw 56164 <rtems_rfs_block_map_grow+0x2ae>
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
55f34: 202a 0006 movel %a2@(6),%d0
55f38: 7204 moveq #4,%d1
55f3a: b280 cmpl %d0,%d1
55f3c: 650c bcss 55f4a <rtems_rfs_block_map_grow+0x94>
map->blocks[map->size.count] = block;
55f3e: 41ee fff8 lea %fp@(-8),%a0
55f42: 2590 0c22 movel %a0@,%a2@(00000022,%d0:l:4)
55f46: 6000 01ee braw 56136 <rtems_rfs_block_map_grow+0x280>
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
55f4a: 222b 0030 movel %a3@(48),%d1
55f4e: 2e00 movel %d0,%d7
55f50: 4c41 7005 remul %d1,%d5,%d7
55f54: 4c41 7007 remul %d1,%d7,%d7
singly = map->size.count / fs->blocks_per_block;
if (map->size.count < fs->block_map_singly_blocks)
55f58: b0ab 0034 cmpl %a3@(52),%d0
55f5c: 643c bccs 55f9a <rtems_rfs_block_map_grow+0xe4>
* Singly indirect tables are being used. Allocate a new block for a
* mapping table if direct is 0 or we are moving up (upping). If upping
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
55f5e: 4a85 tstl %d5
55f60: 670a beqs 55f6c <rtems_rfs_block_map_grow+0xb6>
55f62: 4a87 tstl %d7
55f64: 6628 bnes 55f8e <rtems_rfs_block_map_grow+0xd8>
((singly == 0) && (direct == RTEMS_RFS_INODE_BLOCKS)))
55f66: 7205 moveq #5,%d1
55f68: b285 cmpl %d5,%d1
55f6a: 6622 bnes 55f8e <rtems_rfs_block_map_grow+0xd8>
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
55f6c: 7205 moveq #5,%d1
55f6e: b280 cmpl %d0,%d1
55f70: 57c0 seq %d0
55f72: 49c0 extbl %d0
55f74: 4480 negl %d0
55f76: 2f00 movel %d0,%sp@-
55f78: 4872 7c22 pea %a2@(00000022,%d7:l:4)
55f7c: 2f03 movel %d3,%sp@-
55f7e: 2f0a movel %a2,%sp@-
55f80: 2f0b movel %a3,%sp@-
55f82: 4eba f6bc jsr %pc@(55640 <rtems_rfs_block_map_indirect_alloc>)
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
((singly == 0) && (direct == RTEMS_RFS_INODE_BLOCKS)))
{
55f86: 4fef 0014 lea %sp@(20),%sp
55f8a: 6000 0148 braw 560d4 <rtems_rfs_block_map_grow+0x21e>
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
55f8e: 4878 0001 pea 1 <ADD>
55f92: 2f32 7c22 movel %a2@(00000022,%d7:l:4),%sp@-
55f96: 6000 0132 braw 560ca <rtems_rfs_block_map_grow+0x214>
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
55f9a: 4c41 7006 remul %d1,%d6,%d7
55f9e: 4c41 7007 remul %d1,%d7,%d7
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
55fa2: 4a85 tstl %d5
55fa4: 6600 00d2 bnew 56078 <rtems_rfs_block_map_grow+0x1c2>
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
55fa8: 42a7 clrl %sp@-
55faa: 486e fffc pea %fp@(-4)
55fae: 2f03 movel %d3,%sp@-
55fb0: 2f0a movel %a2,%sp@-
55fb2: 2f0b movel %a3,%sp@-
55fb4: 4eba f68a jsr %pc@(55640 <rtems_rfs_block_map_indirect_alloc>)
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
55fb8: 4fef 0014 lea %sp@(20),%sp
55fbc: 4a80 tstl %d0
55fbe: 6e00 0118 bgtw 560d8 <rtems_rfs_block_map_grow+0x222>
/*
* Allocate a new block for a doubly indirect table if singly is 0 as
* it is the first entry of a new singly indirect block.
*/
if ((singly == 0) ||
55fc2: 4a86 tstl %d6
55fc4: 670a beqs 55fd0 <rtems_rfs_block_map_grow+0x11a> <== NEVER TAKEN
55fc6: 4a87 tstl %d7
55fc8: 662a bnes 55ff4 <rtems_rfs_block_map_grow+0x13e> <== NEVER TAKEN
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
55fca: 7005 moveq #5,%d0
55fcc: b086 cmpl %d6,%d0
55fce: 6624 bnes 55ff4 <rtems_rfs_block_map_grow+0x13e>
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
55fd0: 222b 0034 movel %a3@(52),%d1
55fd4: b2aa 0006 cmpl %a2@(6),%d1
55fd8: 57c0 seq %d0
55fda: 49c0 extbl %d0
55fdc: 4480 negl %d0
55fde: 2f00 movel %d0,%sp@-
55fe0: 4872 7c22 pea %a2@(00000022,%d7:l:4)
55fe4: 2f0d movel %a5,%sp@-
55fe6: 2f0a movel %a2,%sp@-
55fe8: 2f0b movel %a3,%sp@-
55fea: 4eba f654 jsr %pc@(55640 <rtems_rfs_block_map_indirect_alloc>)
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
55fee: 4fef 0014 lea %sp@(20),%sp
55ff2: 6012 bras 56006 <rtems_rfs_block_map_grow+0x150>
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
55ff4: 4878 0001 pea 1 <ADD>
55ff8: 2f32 7c22 movel %a2@(00000022,%d7:l:4),%sp@-
55ffc: 2f0d movel %a5,%sp@-
55ffe: 2f0b movel %a3,%sp@-
56000: 4e94 jsr %a4@
map->blocks[doubly], true);
if (rc > 0)
56002: 4fef 0010 lea %sp@(16),%sp
56006: 4a80 tstl %d0
56008: 6f24 bles 5602e <rtems_rfs_block_map_grow+0x178> <== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
5600a: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
5600e: 45f9 0004 d53a lea 4d53a <rtems_rfs_group_bitmap_free>,%a2 <== NOT EXECUTED
56014: 2400 movel %d0,%d2 <== NOT EXECUTED
56016: 42a7 clrl %sp@- <== NOT EXECUTED
56018: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5601a: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
5601c: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
56020: 42a7 clrl %sp@- <== NOT EXECUTED
56022: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56024: 4e92 jsr %a2@ <== NOT EXECUTED
return rc;
56026: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
5602a: 6000 013a braw 56166 <rtems_rfs_block_map_grow+0x2b0> <== NOT EXECUTED
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
5602e: 206a 0046 moveal %a2@(70),%a0
56032: 43ee fffc lea %fp@(-4),%a1
56036: 2068 001e moveal %a0@(30),%a0
5603a: e58e lsll #2,%d6
5603c: 7001 moveq #1,%d0
5603e: 1191 6800 moveb %a1@,%a0@(00000000,%d6:l)
56042: 43ee fffd lea %fp@(-3),%a1
56046: 206a 0046 moveal %a2@(70),%a0
5604a: 2068 001e moveal %a0@(30),%a0
5604e: 1191 6801 moveb %a1@,%a0@(00000001,%d6:l)
56052: 43ee fffe lea %fp@(-2),%a1
56056: 206a 0046 moveal %a2@(70),%a0
5605a: 2068 001e moveal %a0@(30),%a0
5605e: 1191 6802 moveb %a1@,%a0@(00000002,%d6:l)
56062: 43ee ffff lea %fp@(-1),%a1
56066: 206a 0046 moveal %a2@(70),%a0
5606a: 2068 001e moveal %a0@(30),%a0
5606e: 1191 6803 moveb %a1@,%a0@(00000003,%d6:l)
56072: 1540 0040 moveb %d0,%a2@(64)
56076: 6076 bras 560ee <rtems_rfs_block_map_grow+0x238>
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
56078: 4878 0001 pea 1 <ADD>
5607c: 2f32 7c22 movel %a2@(00000022,%d7:l:4),%sp@-
56080: 2f0d movel %a5,%sp@-
56082: 2f0b movel %a3,%sp@-
56084: 4e94 jsr %a4@
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
56086: 4fef 0010 lea %sp@(16),%sp
5608a: 4a80 tstl %d0
5608c: 6e4a bgts 560d8 <rtems_rfs_block_map_grow+0x222> <== NEVER TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
5608e: 206a 0046 moveal %a2@(70),%a0
56092: 4281 clrl %d1
56094: 4280 clrl %d0
56096: 7e18 moveq #24,%d7
56098: e58e lsll #2,%d6
5609a: 2068 001e moveal %a0@(30),%a0
5609e: 1230 6800 moveb %a0@(00000000,%d6:l),%d1
560a2: 1030 6803 moveb %a0@(00000003,%d6:l),%d0
560a6: efa9 lsll %d7,%d1
560a8: 8081 orl %d1,%d0
560aa: 4281 clrl %d1
560ac: 1230 6801 moveb %a0@(00000001,%d6:l),%d1
560b0: 4841 swap %d1
560b2: 4241 clrw %d1
560b4: 8081 orl %d1,%d0
560b6: 4281 clrl %d1
560b8: 1230 6802 moveb %a0@(00000002,%d6:l),%d1
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
560bc: 4878 0001 pea 1 <ADD>
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
560c0: e189 lsll #8,%d1
560c2: 8081 orl %d1,%d0
560c4: 2d40 fffc movel %d0,%fp@(-4)
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
560c8: 2f00 movel %d0,%sp@-
560ca: 2f03 movel %d3,%sp@-
560cc: 2f0b movel %a3,%sp@-
560ce: 4e94 jsr %a4@
singly_block, true);
if (rc > 0)
560d0: 4fef 0010 lea %sp@(16),%sp
560d4: 4a80 tstl %d0
560d6: 6f16 bles 560ee <rtems_rfs_block_map_grow+0x238> <== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, block);
560d8: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
560dc: 2400 movel %d0,%d2 <== NOT EXECUTED
560de: 42a7 clrl %sp@- <== NOT EXECUTED
560e0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
560e2: 4eb9 0004 d53a jsr 4d53a <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
560e8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
560ec: 6078 bras 56166 <rtems_rfs_block_map_grow+0x2b0> <== NOT EXECUTED
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
560ee: 206a 003c moveal %a2@(60),%a0
560f2: 43ee fff8 lea %fp@(-8),%a1
560f6: 2068 001e moveal %a0@(30),%a0
560fa: e58d lsll #2,%d5
560fc: 7001 moveq #1,%d0
560fe: 1191 5800 moveb %a1@,%a0@(00000000,%d5:l)
56102: 43ee fff9 lea %fp@(-7),%a1
56106: 206a 003c moveal %a2@(60),%a0
5610a: 2068 001e moveal %a0@(30),%a0
5610e: 1191 5801 moveb %a1@,%a0@(00000001,%d5:l)
56112: 43ee fffa lea %fp@(-6),%a1
56116: 206a 003c moveal %a2@(60),%a0
5611a: 2068 001e moveal %a0@(30),%a0
5611e: 1191 5802 moveb %a1@,%a0@(00000002,%d5:l)
56122: 43ee fffb lea %fp@(-5),%a1
56126: 206a 003c moveal %a2@(60),%a0
5612a: 2068 001e moveal %a0@(30),%a0
5612e: 1191 5803 moveb %a1@,%a0@(00000003,%d5:l)
56132: 1540 0036 moveb %d0,%a2@(54)
}
map->size.count++;
56136: 52aa 0006 addql #1,%a2@(6)
map->size.offset = 0;
5613a: 42aa 000a clrl %a2@(10)
if (b == 0)
5613e: 4a84 tstl %d4
56140: 6608 bnes 5614a <rtems_rfs_block_map_grow+0x294> <== NEVER TAKEN
*new_block = block;
56142: 206e 0014 moveal %fp@(20),%a0
56146: 20ae fff8 movel %fp@(-8),%a0@
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
5614a: 5284 addql #1,%d4
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
map->dirty = true;
5614c: 14bc 0001 moveb #1,%a2@
map->size.count++;
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
56150: 256e fff8 001e movel %fp@(-8),%a2@(30)
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
56156: b484 cmpl %d4,%d2
56158: 6600 fdbe bnew 55f18 <rtems_rfs_block_map_grow+0x62>
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
5615c: 4282 clrl %d2
5615e: 6006 bras 56166 <rtems_rfs_block_map_grow+0x2b0>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
return EFBIG;
56160: 741b moveq #27,%d2 <== NOT EXECUTED
56162: 6002 bras 56166 <rtems_rfs_block_map_grow+0x2b0> <== NOT EXECUTED
56164: 2400 movel %d0,%d2
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
56166: 2002 movel %d2,%d0
56168: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
5616e: 4e5e unlk %fp <== NOT EXECUTED
00055640 <rtems_rfs_block_map_indirect_alloc>:
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
55640: 4e56 ffe4 linkw %fp,#-28
55644: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
55648: 486e fffc pea %fp@(-4)
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
5564c: 266e 000c moveal %fp@(12),%a3
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
55650: 42a7 clrl %sp@-
55652: 2f2b 001a movel %a3@(26),%sp@-
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
55656: 286e 0008 moveal %fp@(8),%a4
5565a: 246e 0010 moveal %fp@(16),%a2
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
5565e: 2f0c movel %a4,%sp@-
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
55660: 162e 001b moveb %fp@(27),%d3
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
55664: 4eb9 0004 d3b8 jsr 4d3b8 <rtems_rfs_group_bitmap_alloc>
if (rc > 0)
5566a: 4fef 0010 lea %sp@(16),%sp
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
5566e: 2400 movel %d0,%d2
if (rc > 0)
55670: 6e00 00ea bgtw 5575c <rtems_rfs_block_map_indirect_alloc+0x11c>
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
55674: 42a7 clrl %sp@-
55676: 2f2e fffc movel %fp@(-4),%sp@-
5567a: 2f0a movel %a2,%sp@-
5567c: 2f0c movel %a4,%sp@-
5567e: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
55684: 4fef 0010 lea %sp@(16),%sp
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
if (rc > 0)
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
55688: 2400 movel %d0,%d2
if (rc > 0)
5568a: 6f16 bles 556a2 <rtems_rfs_block_map_indirect_alloc+0x62><== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
5568c: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
55690: 42a7 clrl %sp@- <== NOT EXECUTED
55692: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55694: 4eb9 0004 d53a jsr 4d53a <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
5569a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5569e: 6000 00bc braw 5575c <rtems_rfs_block_map_indirect_alloc+0x11c><== NOT EXECUTED
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
556a2: 2f2c 0008 movel %a4@(8),%sp@-
556a6: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
556aa: 206a 0006 moveal %a2@(6),%a0
556ae: 2f28 001e movel %a0@(30),%sp@-
556b2: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
if (upping)
556b8: 4fef 000c lea %sp@(12),%sp
556bc: 4a03 tstb %d3
556be: 6700 0088 beqw 55748 <rtems_rfs_block_map_indirect_alloc+0x108>
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
556c2: 4878 2000 pea 2000 <D_MAX_EXP+0x1801>
556c6: 42a7 clrl %sp@-
556c8: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
556ce: 508f addql #8,%sp
556d0: 4a00 tstb %d0
556d2: 6712 beqs 556e6 <rtems_rfs_block_map_indirect_alloc+0xa6><== ALWAYS TAKEN
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
556d4: 2f2b 0006 movel %a3@(6),%sp@- <== NOT EXECUTED
556d8: 4879 0006 c6bd pea 6c6bd <CSWTCH.1+0x3> <== NOT EXECUTED
556de: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
556e4: 508f addql #8,%sp <== NOT EXECUTED
* @param block The block number of the indirect block allocated.
* @param upping True is upping the map to the next indirect level.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
556e6: 41eb 0022 lea %a3@(34),%a0
556ea: 4280 clrl %d0
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
556ec: 226a 0006 moveal %a2@(6),%a1
556f0: 4be8 0001 lea %a0@(1),%a5
* @param block The block number of the indirect block allocated.
* @param upping True is upping the map to the next indirect level.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
556f4: 2848 moveal %a0,%a4
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
556f6: 568c addql #3,%a4
556f8: 2269 001e moveal %a1@(30),%a1
556fc: 1390 0800 moveb %a0@,%a1@(00000000,%d0:l)
55700: 226a 0006 moveal %a2@(6),%a1
55704: 2269 001e moveal %a1@(30),%a1
55708: 1395 0801 moveb %a5@,%a1@(00000001,%d0:l)
5570c: 226a 0006 moveal %a2@(6),%a1
55710: 2218 movel %a0@+,%d1
55712: e089 lsrl #8,%d1
55714: 2269 001e moveal %a1@(30),%a1
55718: 1381 0802 moveb %d1,%a1@(00000002,%d0:l)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
5571c: 7214 moveq #20,%d1
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
5571e: 226a 0006 moveal %a2@(6),%a1
55722: 2269 001e moveal %a1@(30),%a1
55726: 1394 0803 moveb %a4@,%a1@(00000003,%d0:l)
5572a: 14bc 0001 moveb #1,%a2@
5572e: 5880 addql #4,%d0
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
55730: b280 cmpl %d0,%d1
55732: 66b8 bnes 556ec <rtems_rfs_block_map_indirect_alloc+0xac>
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
55734: 4878 0014 pea 14 <OPER2>
55738: 42a7 clrl %sp@-
5573a: 486b 0022 pea %a3@(34)
5573e: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
55744: 4fef 000c lea %sp@(12),%sp
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
55748: 202e fffc movel %fp@(-4),%d0
map->last_map_block = new_block;
return 0;
5574c: 4282 clrl %d2
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
5574e: 206e 0014 moveal %fp@(20),%a0
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
55752: 14bc 0001 moveb #1,%a2@
*block = new_block;
55756: 2080 movel %d0,%a0@
map->last_map_block = new_block;
55758: 2740 001a movel %d0,%a3@(26)
return 0;
}
5575c: 2002 movel %d2,%d0
5575e: 4cee 3c0c ffe4 moveml %fp@(-28),%d2-%d3/%a2-%a5
55764: 4e5e unlk %fp <== NOT EXECUTED
0005581c <rtems_rfs_block_map_indirect_shrink.isra.7>:
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
5581c: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
55820: 202e 0014 movel %fp@(20),%d0 <== NOT EXECUTED
55824: 48d7 040c moveml %d2-%d3/%a2,%sp@ <== NOT EXECUTED
55828: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
5582c: 222e 0018 movel %fp@(24),%d1 <== NOT EXECUTED
* block to be freed and the indirect block is now also free, or we have only
* one indirect table and we can fit the remaining blocks into the inode,
* then either move to the next indirect block or move the remaining blocks
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
55830: 670a beqs 5583c <rtems_rfs_block_map_indirect_shrink.isra.7+0x20><== NOT EXECUTED
55832: 4a80 tstl %d0 <== NOT EXECUTED
55834: 6674 bnes 558aa <rtems_rfs_block_map_indirect_shrink.isra.7+0x8e><== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
55836: 7405 moveq #5,%d2 <== NOT EXECUTED
55838: b481 cmpl %d1,%d2 <== NOT EXECUTED
5583a: 666e bnes 558aa <rtems_rfs_block_map_indirect_shrink.isra.7+0x8e><== NOT EXECUTED
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
5583c: 2432 0c22 movel %a2@(00000022,%d0:l:4),%d2 <== NOT EXECUTED
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
55840: 4a80 tstl %d0 <== NOT EXECUTED
55842: 6646 bnes 5588a <rtems_rfs_block_map_indirect_shrink.isra.7+0x6e><== NOT EXECUTED
55844: 7605 moveq #5,%d3 <== NOT EXECUTED
55846: b681 cmpl %d1,%d3 <== NOT EXECUTED
55848: 6640 bnes 5588a <rtems_rfs_block_map_indirect_shrink.isra.7+0x6e><== NOT EXECUTED
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
5584a: 206e 0010 moveal %fp@(16),%a0 <== NOT EXECUTED
5584e: 4281 clrl %d1 <== NOT EXECUTED
55850: 2050 moveal %a0@,%a0 <== NOT EXECUTED
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
55852: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
55856: 4280 clrl %d0 <== NOT EXECUTED
55858: 1010 moveb %a0@,%d0 <== NOT EXECUTED
5585a: 7618 moveq #24,%d3 <== NOT EXECUTED
5585c: e7a8 lsll %d3,%d0 <== NOT EXECUTED
5585e: 4283 clrl %d3 <== NOT EXECUTED
55860: 1628 0001 moveb %a0@(1),%d3 <== NOT EXECUTED
55864: 4843 swap %d3 <== NOT EXECUTED
55866: 4243 clrw %d3 <== NOT EXECUTED
55868: 8083 orl %d3,%d0 <== NOT EXECUTED
5586a: 4283 clrl %d3 <== NOT EXECUTED
5586c: 1628 0003 moveb %a0@(3),%d3 <== NOT EXECUTED
55870: 8083 orl %d3,%d0 <== NOT EXECUTED
55872: 1628 0002 moveb %a0@(2),%d3 <== NOT EXECUTED
55876: 5888 addql #4,%a0 <== NOT EXECUTED
55878: e18b lsll #8,%d3 <== NOT EXECUTED
5587a: 8083 orl %d3,%d0 <== NOT EXECUTED
5587c: 2580 1822 movel %d0,%a2@(00000022,%d1:l) <== NOT EXECUTED
55880: 5881 addql #4,%d1 <== NOT EXECUTED
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
55882: 7014 moveq #20,%d0 <== NOT EXECUTED
55884: b081 cmpl %d1,%d0 <== NOT EXECUTED
55886: 66ce bnes 55856 <rtems_rfs_block_map_indirect_shrink.isra.7+0x3a><== NOT EXECUTED
55888: 6004 bras 5588e <rtems_rfs_block_map_indirect_shrink.isra.7+0x72><== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
5588a: 42b2 0c22 clrl %a2@(00000022,%d0:l:4) <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
5588e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55890: 42a7 clrl %sp@- <== NOT EXECUTED
55892: 2f2e 0008 movel %fp@(8),%sp@- <== NOT EXECUTED
55896: 4eb9 0004 d53a jsr 4d53a <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
5589c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
558a0: 4a80 tstl %d0 <== NOT EXECUTED
558a2: 6e08 bgts 558ac <rtems_rfs_block_map_indirect_shrink.isra.7+0x90><== NOT EXECUTED
return rc;
map->last_map_block = block_to_free;
558a4: 2542 001a movel %d2,%a2@(26) <== NOT EXECUTED
558a8: 6002 bras 558ac <rtems_rfs_block_map_indirect_shrink.isra.7+0x90><== NOT EXECUTED
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
int rc = 0;
558aa: 4280 clrl %d0 <== NOT EXECUTED
map->last_map_block = block_to_free;
}
return rc;
}
558ac: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 <== NOT EXECUTED
558b2: 4e5e unlk %fp <== NOT EXECUTED
000559da <rtems_rfs_block_map_open>:
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
559da: 4e56 ffe8 linkw %fp,#-24
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
559de: 4200 clrb %d0
559e0: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
559e4: 246e 0010 moveal %fp@(16),%a2
559e8: 266e 000c moveal %fp@(12),%a3
* sure the inode has been loaded into memory. If we did not load the inode
* do not unload it. The caller may assume it is still loaded when we return.
*/
map->dirty = false;
map->inode = NULL;
559ec: 42aa 0002 clrl %a2@(2)
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
559f0: 242e 0008 movel %fp@(8),%d2
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
559f4: 42aa 0006 clrl %a2@(6)
* Set the count to 0 so at least find fails, then open the handle and make
* sure the inode has been loaded into memory. If we did not load the inode
* do not unload it. The caller may assume it is still loaded when we return.
*/
map->dirty = false;
559f8: 4212 clrb %a2@
size->offset = 0;
559fa: 42aa 000a clrl %a2@(10)
559fe: 1540 0036 moveb %d0,%a2@(54)
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
55a02: 42aa 000e clrl %a2@(14)
55a06: 1540 0040 moveb %d0,%a2@(64)
bpos->boff = 0;
55a0a: 42aa 0012 clrl %a2@(18)
bpos->block = 0;
55a0e: 42aa 0016 clrl %a2@(22)
handle->bnum = 0;
55a12: 42aa 0038 clrl %a2@(56)
handle->buffer = NULL;
55a16: 42aa 003c clrl %a2@(60)
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
55a1a: 42aa 0042 clrl %a2@(66)
handle->buffer = NULL;
55a1e: 42aa 0046 clrl %a2@(70)
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
55a22: 2f0b movel %a3,%sp@-
55a24: 2f02 movel %d2,%sp@-
55a26: 4eb9 0004 d73c jsr 4d73c <rtems_rfs_inode_load>
if (rc > 0)
55a2c: 508f addql #8,%sp
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
55a2e: 2600 movel %d0,%d3
if (rc > 0)
55a30: 6f42 bles 55a74 <rtems_rfs_block_map_open+0x9a> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55a32: 486a 0036 pea %a2@(54) <== NOT EXECUTED
55a36: 47f9 0005 6580 lea 56580 <rtems_rfs_buffer_handle_release>,%a3<== NOT EXECUTED
handle->dirty = false;
55a3c: 4204 clrb %d4 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55a3e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55a40: 4e93 jsr %a3@ <== NOT EXECUTED
handle->dirty = false;
55a42: 4201 clrb %d1 <== NOT EXECUTED
55a44: 1541 0036 moveb %d1,%a2@(54) <== NOT EXECUTED
handle->bnum = 0;
55a48: 42aa 0038 clrl %a2@(56) <== NOT EXECUTED
handle->buffer = NULL;
55a4c: 42aa 003c clrl %a2@(60) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55a50: 486a 0040 pea %a2@(64) <== NOT EXECUTED
55a54: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55a56: 4e93 jsr %a3@ <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &map->singly_buffer);
rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
return rc;
55a58: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
55a5c: 2003 movel %d3,%d0 <== NOT EXECUTED
handle->dirty = false;
55a5e: 1544 0040 moveb %d4,%a2@(64) <== NOT EXECUTED
handle->bnum = 0;
55a62: 42aa 0042 clrl %a2@(66) <== NOT EXECUTED
handle->buffer = NULL;
55a66: 42aa 0046 clrl %a2@(70) <== NOT EXECUTED
55a6a: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 <== NOT EXECUTED
55a70: 4e5e unlk %fp <== NOT EXECUTED
55a72: 4e75 rts <== NOT EXECUTED
int
rtems_rfs_block_map_free_all (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
return rtems_rfs_block_map_shrink (fs, map, map->size.count);
}
55a74: 206b 000c moveal %a3@(12),%a0
55a78: 284a moveal %a2,%a4
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
55a7a: 43e8 001c lea %a0@(28),%a1
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
55a7e: 4281 clrl %d1
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
55a80: 254b 0002 movel %a3,%a2@(2)
55a84: 4283 clrl %d3
55a86: 1630 1c1c moveb %a0@(0000001c,%d1:l:4),%d3
55a8a: 4280 clrl %d0
55a8c: 7818 moveq #24,%d4
55a8e: 1029 0003 moveb %a1@(3),%d0
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
55a92: 5281 addql #1,%d1
55a94: e9ab lsll %d4,%d3
55a96: 8083 orl %d3,%d0
55a98: 4283 clrl %d3
55a9a: 1629 0001 moveb %a1@(1),%d3
55a9e: 4843 swap %d3
55aa0: 4243 clrw %d3
55aa2: 8083 orl %d3,%d0
55aa4: 4283 clrl %d3
55aa6: 1629 0002 moveb %a1@(2),%d3
55aaa: 5889 addql #4,%a1
55aac: e18b lsll #8,%d3
55aae: 8083 orl %d3,%d0
55ab0: 2940 0022 movel %d0,%a4@(34)
55ab4: 588c addql #4,%a4
55ab6: 7005 moveq #5,%d0
55ab8: b081 cmpl %d1,%d0
55aba: 66c8 bnes 55a84 <rtems_rfs_block_map_open+0xaa>
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
55abc: 4280 clrl %d0
55abe: 4281 clrl %d1
55ac0: 1028 000c moveb %a0@(12),%d0
55ac4: 1228 000d moveb %a0@(13),%d1
55ac8: e9a8 lsll %d4,%d0
55aca: 4841 swap %d1
55acc: 4241 clrw %d1
55ace: 8081 orl %d1,%d0
55ad0: 4281 clrl %d1
55ad2: 1228 000f moveb %a0@(15),%d1
55ad6: 8081 orl %d1,%d0
55ad8: 1228 000e moveb %a0@(14),%d1
55adc: e189 lsll #8,%d1
55ade: 8081 orl %d1,%d0
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
55ae0: 4281 clrl %d1
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
55ae2: 2540 0006 movel %d0,%a2@(6)
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
55ae6: 4280 clrl %d0
55ae8: 1028 000a moveb %a0@(10),%d0
55aec: 1228 000b moveb %a0@(11),%d1
55af0: e188 lsll #8,%d0
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
55af2: 8081 orl %d1,%d0
55af4: 2540 000a movel %d0,%a2@(10)
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
55af8: 4280 clrl %d0
55afa: 1028 0030 moveb %a0@(48),%d0
55afe: 1228 0031 moveb %a0@(49),%d1
55b02: e9a8 lsll %d4,%d0
55b04: 4841 swap %d1
55b06: 4241 clrw %d1
55b08: 8081 orl %d1,%d0
55b0a: 4281 clrl %d1
55b0c: 1228 0033 moveb %a0@(51),%d1
55b10: 8081 orl %d1,%d0
55b12: 1228 0032 moveb %a0@(50),%d1
55b16: e189 lsll #8,%d1
55b18: 8081 orl %d1,%d0
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
55b1a: 4281 clrl %d1
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
55b1c: 2540 001a movel %d0,%a2@(26)
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
55b20: 4280 clrl %d0
55b22: 1028 0034 moveb %a0@(52),%d0
55b26: 1228 0035 moveb %a0@(53),%d1
55b2a: e9a8 lsll %d4,%d0
55b2c: 4841 swap %d1
55b2e: 4241 clrw %d1
55b30: 8081 orl %d1,%d0
55b32: 4281 clrl %d1
55b34: 1228 0037 moveb %a0@(55),%d1
55b38: 8081 orl %d1,%d0
55b3a: 1228 0036 moveb %a0@(54),%d1
55b3e: e189 lsll #8,%d1
55b40: 8081 orl %d1,%d0
55b42: 2540 001e movel %d0,%a2@(30)
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
55b46: 2d4b 000c movel %a3,%fp@(12)
55b4a: 2d42 0008 movel %d2,%fp@(8)
return rc;
}
55b4e: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
55b54: 42ae 0010 clrl %fp@(16)
return rc;
}
55b58: 4e5e unlk %fp
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
55b5a: 4ef9 0004 d890 jmp 4d890 <rtems_rfs_inode_unload>
00056172 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
56172: 4e56 ffc0 linkw %fp,#-64
56176: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
5617a: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
5617e: 266e 0008 moveal %fp@(8),%a3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
56182: 42a7 clrl %sp@-
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
56184: 246e 000c moveal %fp@(12),%a2
56188: 262e 0010 movel %fp@(16),%d3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
5618c: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56192: 508f addql #8,%sp
56194: 4a00 tstb %d0
56196: 6716 beqs 561ae <rtems_rfs_block_map_shrink+0x3c><== ALWAYS TAKEN
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
56198: 2f2a 0006 movel %a2@(6),%sp@- <== NOT EXECUTED
5619c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5619e: 4879 0006 c774 pea 6c774 <CSWTCH.1+0xba> <== NOT EXECUTED
561a4: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
561aa: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
561ae: 202a 0006 movel %a2@(6),%d0
561b2: 6700 0244 beqw 563f8 <rtems_rfs_block_map_shrink+0x286>
561b6: b083 cmpl %d3,%d0 <== NOT EXECUTED
561b8: 6400 01c0 bccw 5637a <rtems_rfs_block_map_shrink+0x208><== NOT EXECUTED
561bc: 2600 movel %d0,%d3 <== NOT EXECUTED
561be: 6000 01ba braw 5637a <rtems_rfs_block_map_shrink+0x208><== NOT EXECUTED
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
561c2: 202a 0006 movel %a2@(6),%d0 <== NOT EXECUTED
if (block < RTEMS_RFS_INODE_BLOCKS)
561c6: 7204 moveq #4,%d1 <== NOT EXECUTED
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
561c8: 5380 subql #1,%d0 <== NOT EXECUTED
if (block < RTEMS_RFS_INODE_BLOCKS)
561ca: b280 cmpl %d0,%d1 <== NOT EXECUTED
561cc: 650c bcss 561da <rtems_rfs_block_map_shrink+0x68><== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
561ce: 2432 0c22 movel %a2@(00000022,%d0:l:4),%d2 <== NOT EXECUTED
map->blocks[block] = 0;
561d2: 42b2 0c22 clrl %a2@(00000022,%d0:l:4) <== NOT EXECUTED
561d6: 6000 017c braw 56354 <rtems_rfs_block_map_shrink+0x1e2><== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
561da: 222b 0030 movel %a3@(48),%d1 <== NOT EXECUTED
561de: 2a00 movel %d0,%d5 <== NOT EXECUTED
561e0: 4c41 5004 remul %d1,%d4,%d5 <== NOT EXECUTED
561e4: 4c41 5005 remul %d1,%d5,%d5 <== NOT EXECUTED
singly = block / fs->blocks_per_block;
if (block < fs->block_map_singly_blocks)
561e8: b0ab 0034 cmpl %a3@(52),%d0 <== NOT EXECUTED
561ec: 647c bccs 5626a <rtems_rfs_block_map_shrink+0xf8><== NOT EXECUTED
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
561ee: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
561f2: 2f32 5c22 movel %a2@(00000022,%d5:l:4),%sp@- <== NOT EXECUTED
561f6: 2f2e ffea movel %fp@(-22),%sp@- <== NOT EXECUTED
561fa: 2f0b movel %a3,%sp@- <== NOT EXECUTED
561fc: 4e94 jsr %a4@ <== NOT EXECUTED
map->blocks[singly], true);
if (rc > 0)
561fe: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
56202: 4a80 tstl %d0 <== NOT EXECUTED
56204: 6e00 01f4 bgtw 563fa <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
56208: 206a 003c moveal %a2@(60),%a0 <== NOT EXECUTED
5620c: 2004 movel %d4,%d0 <== NOT EXECUTED
5620e: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
56212: e588 lsll #2,%d0 <== NOT EXECUTED
56214: 1430 0801 moveb %a0@(00000001,%d0:l),%d2 <== NOT EXECUTED
56218: 1c30 0800 moveb %a0@(00000000,%d0:l),%d6 <== NOT EXECUTED
5621c: 1e30 0802 moveb %a0@(00000002,%d0:l),%d7 <== NOT EXECUTED
56220: 1d42 fffb moveb %d2,%fp@(-5) <== NOT EXECUTED
56224: 1430 0803 moveb %a0@(00000003,%d0:l),%d2 <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
56228: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5622a: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5622c: 2f2e ffee movel %fp@(-18),%sp@- <== NOT EXECUTED
56230: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56232: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56234: 4eba f5e6 jsr %pc@(5581c <rtems_rfs_block_map_indirect_shrink.isra.7>)<== NOT EXECUTED
singly, direct);
if (rc)
56238: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
5623c: 4a80 tstl %d0 <== NOT EXECUTED
5623e: 6600 01ba bnew 563fa <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
56242: 2006 movel %d6,%d0 <== NOT EXECUTED
56244: 7218 moveq #24,%d1 <== NOT EXECUTED
56246: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
5624c: e3a8 lsll %d1,%d0 <== NOT EXECUTED
5624e: 0287 0000 00ff andil #255,%d7 <== NOT EXECUTED
56254: 8480 orl %d0,%d2 <== NOT EXECUTED
56256: 4280 clrl %d0 <== NOT EXECUTED
56258: 102e fffb moveb %fp@(-5),%d0 <== NOT EXECUTED
5625c: 4840 swap %d0 <== NOT EXECUTED
5625e: 4240 clrw %d0 <== NOT EXECUTED
56260: e18f lsll #8,%d7 <== NOT EXECUTED
56262: 8480 orl %d0,%d2 <== NOT EXECUTED
56264: 8487 orl %d7,%d2 <== NOT EXECUTED
56266: 6000 00ec braw 56354 <rtems_rfs_block_map_shrink+0x1e2><== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
5626a: b0ab 0038 cmpl %a3@(56),%d0 <== NOT EXECUTED
5626e: 6400 0140 bccw 563b0 <rtems_rfs_block_map_shrink+0x23e><== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
56272: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
56276: 4c41 5002 remul %d1,%d2,%d5 <== NOT EXECUTED
5627a: 4c41 5005 remul %d1,%d5,%d5 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
5627e: 2f32 5c22 movel %a2@(00000022,%d5:l:4),%sp@- <== NOT EXECUTED
56282: 2f2e fff6 movel %fp@(-10),%sp@- <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
56286: 2d42 fffc movel %d2,%fp@(-4) <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
5628a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5628c: 4e94 jsr %a4@ <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
5628e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
56292: 4a80 tstl %d0 <== NOT EXECUTED
56294: 6e00 0164 bgtw 563fa <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
56298: 206a 0046 moveal %a2@(70),%a0 <== NOT EXECUTED
5629c: 2002 movel %d2,%d0 <== NOT EXECUTED
5629e: 4281 clrl %d1 <== NOT EXECUTED
562a0: 4287 clrl %d7 <== NOT EXECUTED
562a2: 7c18 moveq #24,%d6 <== NOT EXECUTED
562a4: e588 lsll #2,%d0 <== NOT EXECUTED
562a6: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
562aa: 1230 0800 moveb %a0@(00000000,%d0:l),%d1 <== NOT EXECUTED
562ae: 1e30 0803 moveb %a0@(00000003,%d0:l),%d7 <== NOT EXECUTED
562b2: eda9 lsll %d6,%d1 <== NOT EXECUTED
562b4: 8e81 orl %d1,%d7 <== NOT EXECUTED
562b6: 4281 clrl %d1 <== NOT EXECUTED
562b8: 1230 0801 moveb %a0@(00000001,%d0:l),%d1 <== NOT EXECUTED
562bc: 1030 0802 moveb %a0@(00000002,%d0:l),%d0 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
562c0: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
562c4: 4841 swap %d1 <== NOT EXECUTED
562c6: 4241 clrw %d1 <== NOT EXECUTED
562c8: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
562ce: 8e81 orl %d1,%d7 <== NOT EXECUTED
562d0: e188 lsll #8,%d0 <== NOT EXECUTED
562d2: 8e80 orl %d0,%d7 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
562d4: 2f07 movel %d7,%sp@- <== NOT EXECUTED
562d6: 2f2e ffea movel %fp@(-22),%sp@- <== NOT EXECUTED
562da: 2f0b movel %a3,%sp@- <== NOT EXECUTED
562dc: 4e94 jsr %a4@ <== NOT EXECUTED
singly, true);
if (rc > 0)
562de: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
562e2: 4a80 tstl %d0 <== NOT EXECUTED
562e4: 6e00 0114 bgtw 563fa <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
562e8: 206a 003c moveal %a2@(60),%a0 <== NOT EXECUTED
562ec: 2004 movel %d4,%d0 <== NOT EXECUTED
562ee: 4281 clrl %d1 <== NOT EXECUTED
562f0: 4282 clrl %d2 <== NOT EXECUTED
562f2: e588 lsll #2,%d0 <== NOT EXECUTED
562f4: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
562f8: 1230 0800 moveb %a0@(00000000,%d0:l),%d1 <== NOT EXECUTED
562fc: 1430 0803 moveb %a0@(00000003,%d0:l),%d2 <== NOT EXECUTED
56300: eda9 lsll %d6,%d1 <== NOT EXECUTED
56302: 8481 orl %d1,%d2 <== NOT EXECUTED
56304: 4281 clrl %d1 <== NOT EXECUTED
56306: 1230 0801 moveb %a0@(00000001,%d0:l),%d1 <== NOT EXECUTED
5630a: 1030 0802 moveb %a0@(00000002,%d0:l),%d0 <== NOT EXECUTED
5630e: 4841 swap %d1 <== NOT EXECUTED
56310: 4241 clrw %d1 <== NOT EXECUTED
56312: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
56318: 8481 orl %d1,%d2 <== NOT EXECUTED
5631a: e188 lsll #8,%d0 <== NOT EXECUTED
5631c: 8480 orl %d0,%d2 <== NOT EXECUTED
direct);
if (direct == 0)
5631e: 4a84 tstl %d4 <== NOT EXECUTED
56320: 6632 bnes 56354 <rtems_rfs_block_map_shrink+0x1e2><== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
56322: 2f07 movel %d7,%sp@- <== NOT EXECUTED
56324: 42a7 clrl %sp@- <== NOT EXECUTED
56326: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56328: 4e95 jsr %a5@ <== NOT EXECUTED
if (rc > 0)
5632a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5632e: 4a80 tstl %d0 <== NOT EXECUTED
56330: 6e00 00c8 bgtw 563fa <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
map->last_map_block = singly;
56334: 2547 001a movel %d7,%a2@(26) <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
56338: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
5633c: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5633e: 2f2e fff2 movel %fp@(-14),%sp@- <== NOT EXECUTED
56342: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56344: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56346: 4eba f4d4 jsr %pc@(5581c <rtems_rfs_block_map_indirect_shrink.isra.7>)<== NOT EXECUTED
doubly, doubly_singly);
if (rc)
5634a: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
5634e: 4a80 tstl %d0 <== NOT EXECUTED
56350: 6600 00a8 bnew 563fa <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
56354: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56356: 42a7 clrl %sp@- <== NOT EXECUTED
56358: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5635a: 4e95 jsr %a5@ <== NOT EXECUTED
if (rc > 0)
5635c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
56360: 4a80 tstl %d0 <== NOT EXECUTED
56362: 6e00 0096 bgtw 563fa <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
map->size.count--;
56366: 53aa 0006 subql #1,%a2@(6) <== NOT EXECUTED
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
5636a: 5383 subql #1,%d3 <== NOT EXECUTED
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
5636c: 14bc 0001 moveb #1,%a2@ <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
56370: 42aa 000a clrl %a2@(10) <== NOT EXECUTED
map->last_data_block = block_to_free;
56374: 2542 001e movel %d2,%a2@(30) <== NOT EXECUTED
56378: 6030 bras 563aa <rtems_rfs_block_map_shrink+0x238><== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
5637a: 41ea 0040 lea %a2@(64),%a0 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
5637e: 2c0a movel %a2,%d6 <== NOT EXECUTED
56380: 0686 0000 0036 addil #54,%d6 <== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
56386: 49f9 0005 66f8 lea 566f8 <rtems_rfs_buffer_handle_request>,%a4<== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
direct);
if (direct == 0)
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
5638c: 4bf9 0004 d53a lea 4d53a <rtems_rfs_group_bitmap_free>,%a5 <== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
56392: 2d48 fff6 movel %a0,%fp@(-10) <== NOT EXECUTED
int
rtems_rfs_block_map_free_all (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
return rtems_rfs_block_map_shrink (fs, map, map->size.count);
}
56396: 41ea 0046 lea %a2@(70),%a0 <== NOT EXECUTED
5639a: 2d48 fff2 movel %a0,%fp@(-14) <== NOT EXECUTED
5639e: 41ea 003c lea %a2@(60),%a0 <== NOT EXECUTED
563a2: 2d46 ffea movel %d6,%fp@(-22) <== NOT EXECUTED
563a6: 2d48 ffee movel %a0,%fp@(-18) <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
563aa: 4a83 tstl %d3 <== NOT EXECUTED
563ac: 6600 fe14 bnew 561c2 <rtems_rfs_block_map_shrink+0x50><== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
563b0: 202a 0006 movel %a2@(6),%d0 <== NOT EXECUTED
563b4: 6608 bnes 563be <rtems_rfs_block_map_shrink+0x24c><== NOT EXECUTED
{
map->last_map_block = 0;
563b6: 42aa 001a clrl %a2@(26) <== NOT EXECUTED
map->last_data_block = 0;
563ba: 42aa 001e clrl %a2@(30) <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
563be: 222a 000e movel %a2@(14),%d1 <== NOT EXECUTED
563c2: 6704 beqs 563c8 <rtems_rfs_block_map_shrink+0x256><== NOT EXECUTED
563c4: 4a80 tstl %d0 <== NOT EXECUTED
563c6: 6716 beqs 563de <rtems_rfs_block_map_shrink+0x26c><== NOT EXECUTED
563c8: b081 cmpl %d1,%d0 <== NOT EXECUTED
563ca: 6312 blss 563de <rtems_rfs_block_map_shrink+0x26c><== NOT EXECUTED
563cc: 2040 moveal %d0,%a0 <== NOT EXECUTED
563ce: 5388 subql #1,%a0 <== NOT EXECUTED
563d0: b1c1 cmpal %d1,%a0 <== NOT EXECUTED
563d2: 6624 bnes 563f8 <rtems_rfs_block_map_shrink+0x286><== NOT EXECUTED
563d4: 222a 000a movel %a2@(10),%d1 <== NOT EXECUTED
563d8: b2aa 0012 cmpl %a2@(18),%d1 <== NOT EXECUTED
563dc: 641a bccs 563f8 <rtems_rfs_block_map_shrink+0x286><== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
563de: 222a 000a movel %a2@(10),%d1 <== NOT EXECUTED
563e2: 2540 000e movel %d0,%a2@(14) <== NOT EXECUTED
563e6: 2541 0012 movel %d1,%a2@(18) <== NOT EXECUTED
563ea: 42aa 0016 clrl %a2@(22) <== NOT EXECUTED
563ee: 4a81 tstl %d1 <== NOT EXECUTED
563f0: 6706 beqs 563f8 <rtems_rfs_block_map_shrink+0x286><== NOT EXECUTED
563f2: 5380 subql #1,%d0 <== NOT EXECUTED
563f4: 2540 000e movel %d0,%a2@(14) <== NOT EXECUTED
return 0;
563f8: 4280 clrl %d0
}
563fa: 4cee 3cfc ffc0 moveml %fp@(-64),%d2-%d7/%a2-%a5
56400: 4e5e unlk %fp <== NOT EXECUTED
0005b38a <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
5b38a: 4e56 0000 linkw %fp,#0
5b38e: 2f0a movel %a2,%sp@-
5b390: 246e 0008 moveal %fp@(8),%a2
5b394: 2f02 movel %d2,%sp@-
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
5b396: 4878 0040 pea 40 <DBL_MANT_DIG+0xb>
}
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
5b39a: 142e 000f moveb %fp@(15),%d2
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
5b39e: 42a7 clrl %sp@-
5b3a0: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
5b3a6: 508f addql #8,%sp
5b3a8: 4a00 tstb %d0
5b3aa: 672a beqs 5b3d6 <rtems_rfs_buffer_bdbuf_release+0x4c><== ALWAYS TAKEN
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
5b3ac: 203c 0006 b29c movel #438940,%d0 <== NOT EXECUTED
5b3b2: 4a02 tstb %d2 <== NOT EXECUTED
5b3b4: 6706 beqs 5b3bc <rtems_rfs_buffer_bdbuf_release+0x32><== NOT EXECUTED
5b3b6: 203c 0006 dc96 movel #449686,%d0 <== NOT EXECUTED
5b3bc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5b3be: 2f2a 001a movel %a2@(26),%sp@- <== NOT EXECUTED
5b3c2: 2f2a 0036 movel %a2@(54),%sp@- <== NOT EXECUTED
5b3c6: 4879 0006 dca1 pea 6dca1 <status_code_to_errno+0x7f> <== NOT EXECUTED
5b3cc: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5b3d2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
5b3d6: 4a02 tstb %d2
5b3d8: 670a beqs 5b3e4 <rtems_rfs_buffer_bdbuf_release+0x5a>
sc = rtems_bdbuf_release_modified (buffer);
5b3da: 2f0a movel %a2,%sp@-
5b3dc: 4eb9 0005 1590 jsr 51590 <rtems_bdbuf_release_modified>
5b3e2: 6008 bras 5b3ec <rtems_rfs_buffer_bdbuf_release+0x62>
else
sc = rtems_bdbuf_release (buffer);
5b3e4: 2f0a movel %a2,%sp@-
5b3e6: 4eb9 0005 14e6 jsr 514e6 <rtems_bdbuf_release>
5b3ec: 588f addql #4,%sp
if (sc != RTEMS_SUCCESSFUL)
5b3ee: 4a80 tstl %d0
5b3f0: 6702 beqs 5b3f4 <rtems_rfs_buffer_bdbuf_release+0x6a><== ALWAYS TAKEN
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-release: bdbuf-%s: %s(%d)\n",
modified ? "modified" : "not-modified",
rtems_status_text (sc), sc);
#endif
rc = EIO;
5b3f2: 7005 moveq #5,%d0 <== NOT EXECUTED
}
return rc;
}
5b3f4: 242e fff8 movel %fp@(-8),%d2
5b3f8: 246e fffc moveal %fp@(-4),%a2
5b3fc: 4e5e unlk %fp <== NOT EXECUTED
0005b340 <rtems_rfs_buffer_bdbuf_request>:
int
rtems_rfs_buffer_bdbuf_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block block,
bool read,
rtems_rfs_buffer** buffer)
{
5b340: 4e56 0000 linkw %fp,#0
5b344: 206e 0008 moveal %fp@(8),%a0
5b348: 202e 000c movel %fp@(12),%d0
5b34c: 222e 0014 movel %fp@(20),%d1
5b350: 2068 000c moveal %a0@(12),%a0
rtems_status_code sc;
int rc = 0;
if (read)
5b354: 4a2e 0013 tstb %fp@(19)
5b358: 6712 beqs 5b36c <rtems_rfs_buffer_bdbuf_request+0x2c>
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
5b35a: 2f01 movel %d1,%sp@-
5b35c: 2f00 movel %d0,%sp@-
5b35e: 2f28 0004 movel %a0@(4),%sp@-
5b362: 2f10 movel %a0@,%sp@-
5b364: 4eb9 0005 12cc jsr 512cc <rtems_bdbuf_read>
5b36a: 6010 bras 5b37c <rtems_rfs_buffer_bdbuf_request+0x3c>
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
5b36c: 2f01 movel %d1,%sp@-
5b36e: 2f00 movel %d0,%sp@-
5b370: 2f28 0004 movel %a0@(4),%sp@-
5b374: 2f10 movel %a0@,%sp@-
5b376: 4eb9 0005 1208 jsr 51208 <rtems_bdbuf_get>
5b37c: 4fef 0010 lea %sp@(16),%sp
if (sc != RTEMS_SUCCESSFUL)
5b380: 4a80 tstl %d0
5b382: 6702 beqs 5b386 <rtems_rfs_buffer_bdbuf_request+0x46><== ALWAYS TAKEN
{
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-bdbuf-request: block=%lu: bdbuf-%s: %d: %s\n",
block, read ? "read" : "get", sc, rtems_status_text (sc));
#endif
rc = EIO;
5b384: 7005 moveq #5,%d0 <== NOT EXECUTED
}
return rc;
}
5b386: 4e5e unlk %fp <== NOT EXECUTED
00056c26 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
56c26: 4e56 0000 linkw %fp,#0
56c2a: 2f0a movel %a2,%sp@-
56c2c: 246e 0008 moveal %fp@(8),%a2
56c30: 2f02 movel %d2,%sp@-
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
56c32: 4878 0010 pea 10 <INVALID_OPERATION>
56c36: 42a7 clrl %sp@-
56c38: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56c3e: 508f addql #8,%sp
56c40: 4a00 tstb %d0
56c42: 670e beqs 56c52 <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-close: closing\n");
56c44: 4879 0006 cbcf pea 6cbcf <CSWTCH.1+0x515> <== NOT EXECUTED
56c4a: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
56c50: 588f addql #4,%sp <== NOT EXECUTED
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
56c52: 206a 000c moveal %a2@(12),%a0
56c56: 2f28 0024 movel %a0@(36),%sp@-
56c5a: 2f0a movel %a2,%sp@-
56c5c: 4eb9 0005 6b4a jsr 56b4a <rtems_rfs_buffer_setblksize>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
56c62: 508f addql #8,%sp
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
56c64: 2400 movel %d0,%d2
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
56c66: 6f2e bles 56c96 <rtems_rfs_buffer_close+0x70> <== ALWAYS TAKEN
56c68: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
56c6c: 42a7 clrl %sp@- <== NOT EXECUTED
56c6e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
56c74: 508f addql #8,%sp <== NOT EXECUTED
56c76: 4a00 tstb %d0 <== NOT EXECUTED
56c78: 671c beqs 56c96 <rtems_rfs_buffer_close+0x70> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
56c7a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56c7c: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
56c82: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56c84: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56c86: 4879 0006 cbf0 pea 6cbf0 <CSWTCH.1+0x536> <== NOT EXECUTED
56c8c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56c92: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rtems_disk_release (fs->disk);
56c96: 2f2a 000c movel %a2@(12),%sp@-
56c9a: 4eb9 0004 4522 jsr 44522 <rtems_disk_release>
rc, strerror (rc));
}
#endif
return rc;
}
56ca0: 246e fffc moveal %fp@(-4),%a2
56ca4: 2002 movel %d2,%d0
56ca6: 242e fff8 movel %fp@(-8),%d2
56caa: 4e5e unlk %fp
...
00056580 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
56580: 4e56 fff4 linkw %fp,#-12
56584: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
56588: 246e 0008 moveal %fp@(8),%a2
5658c: 266e 000c moveal %fp@(12),%a3
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
56590: 4aab 0006 tstl %a3@(6)
56594: 6700 0154 beqw 566ea <rtems_rfs_buffer_handle_release+0x16a>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
56598: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
5659c: 42a7 clrl %sp@-
5659e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
565a4: 508f addql #8,%sp
565a6: 4a00 tstb %d0
565a8: 6740 beqs 565ea <rtems_rfs_buffer_handle_release+0x6a><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
565aa: 206b 0006 moveal %a3@(6),%a0 <== NOT EXECUTED
565ae: 2228 0032 movel %a0@(50),%d1 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
565b2: 41f9 0006 b29c lea 6b29c <rtems_filesystem_default_pathconf+0xb4>,%a0<== NOT EXECUTED
565b8: 6606 bnes 565c0 <rtems_rfs_buffer_handle_release+0x40><== NOT EXECUTED
565ba: 41f9 0006 c826 lea 6c826 <CSWTCH.1+0x16c>,%a0 <== NOT EXECUTED
565c0: 203c 0006 b29c movel #438940,%d0 <== NOT EXECUTED
565c6: 4a13 tstb %a3@ <== NOT EXECUTED
565c8: 6706 beqs 565d0 <rtems_rfs_buffer_handle_release+0x50><== NOT EXECUTED
565ca: 203c 0006 c834 movel #444468,%d0 <== NOT EXECUTED
565d0: 2f08 movel %a0,%sp@- <== NOT EXECUTED
565d2: 2f01 movel %d1,%sp@- <== NOT EXECUTED
565d4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
565d6: 2f2b 0002 movel %a3@(2),%sp@- <== NOT EXECUTED
565da: 4879 0006 c83c pea 6c83c <CSWTCH.1+0x182> <== NOT EXECUTED
565e0: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
565e6: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
565ea: 206b 0006 moveal %a3@(6),%a0
565ee: 2028 0032 movel %a0@(50),%d0
565f2: 6f06 bles 565fa <rtems_rfs_buffer_handle_release+0x7a><== NEVER TAKEN
rtems_rfs_buffer_refs_down (handle);
565f4: 5380 subql #1,%d0
565f6: 2140 0032 movel %d0,%a0@(50)
if (rtems_rfs_buffer_refs (handle) == 0)
565fa: 4aa8 0032 tstl %a0@(50)
565fe: 6600 00e2 bnew 566e2 <rtems_rfs_buffer_handle_release+0x162>
56602: 2f08 movel %a0,%sp@-
56604: 4eb9 0004 9a3c jsr 49a3c <_Chain_Extract>
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
5660a: 588f addql #4,%sp
5660c: 7002 moveq #2,%d0
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
5660e: 53aa 004c subql #1,%a2@(76)
if (rtems_rfs_fs_no_local_cache (fs))
56612: c092 andl %a2@,%d0
56614: 671c beqs 56632 <rtems_rfs_buffer_handle_release+0xb2>
{
handle->buffer->user = (void*) 0;
56616: 206b 0006 moveal %a3@(6),%a0
rc = rtems_rfs_buffer_io_release (handle->buffer,
5661a: 4280 clrl %d0
5661c: 1013 moveb %a3@,%d0
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
5661e: 42a8 0036 clrl %a0@(54)
rc = rtems_rfs_buffer_io_release (handle->buffer,
56622: 2f00 movel %d0,%sp@-
56624: 2f08 movel %a0,%sp@-
56626: 4eb9 0005 b38a jsr 5b38a <rtems_rfs_buffer_bdbuf_release>
5662c: 2400 movel %d0,%d2
5662e: 6000 00ae braw 566de <rtems_rfs_buffer_handle_release+0x15e>
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
56632: 202a 006c movel %a2@(108),%d0
56636: d0aa 005c addl %a2@(92),%d0
5663a: b0aa 003c cmpl %a2@(60),%d0
5663e: 6572 bcss 566b2 <rtems_rfs_buffer_handle_release+0x132>
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
56640: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
56644: 42a7 clrl %sp@-
56646: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
5664c: 508f addql #8,%sp
5664e: 4a00 tstb %d0
56650: 6718 beqs 5666a <rtems_rfs_buffer_handle_release+0xea><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-release: local cache overflow:"
56652: 202a 006c movel %a2@(108),%d0 <== NOT EXECUTED
56656: d0aa 005c addl %a2@(92),%d0 <== NOT EXECUTED
5665a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5665c: 4879 0006 c870 pea 6c870 <CSWTCH.1+0x1b6> <== NOT EXECUTED
56662: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56668: 508f addql #8,%sp <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
5666a: 242a 006c movel %a2@(108),%d2
5666e: 41f9 0004 9a64 lea 49a64 <_Chain_Get>,%a0
56674: b4aa 005c cmpl %a2@(92),%d2
56678: 6410 bccs 5668a <rtems_rfs_buffer_handle_release+0x10a><== ALWAYS TAKEN
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
5667a: 486a 0050 pea %a2@(80) <== NOT EXECUTED
5667e: 4e90 jsr %a0@ <== NOT EXECUTED
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
56680: 588f addql #4,%sp <== NOT EXECUTED
56682: 53aa 005c subql #1,%a2@(92) <== NOT EXECUTED
modified = false;
56686: 4201 clrb %d1 <== NOT EXECUTED
56688: 600e bras 56698 <rtems_rfs_buffer_handle_release+0x118><== NOT EXECUTED
5668a: 486a 0060 pea %a2@(96)
5668e: 4e90 jsr %a0@
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
56690: 588f addql #4,%sp
56692: 53aa 006c subql #1,%a2@(108)
modified = true;
56696: 7201 moveq #1,%d1
}
buffer->user = (void*) 0;
56698: 2040 moveal %d0,%a0
rc = rtems_rfs_buffer_io_release (buffer, modified);
5669a: 7401 moveq #1,%d2
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
5669c: 42a8 0036 clrl %a0@(54)
rc = rtems_rfs_buffer_io_release (buffer, modified);
566a0: c481 andl %d1,%d2
566a2: 2f02 movel %d2,%sp@-
566a4: 2f00 movel %d0,%sp@-
566a6: 4eb9 0005 b38a jsr 5b38a <rtems_rfs_buffer_bdbuf_release>
566ac: 508f addql #8,%sp
566ae: 2400 movel %d0,%d2
566b0: 6002 bras 566b4 <rtems_rfs_buffer_handle_release+0x134>
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
566b2: 4282 clrl %d2
}
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
}
if (rtems_rfs_buffer_dirty (handle))
566b4: 4a13 tstb %a3@
566b6: 6714 beqs 566cc <rtems_rfs_buffer_handle_release+0x14c>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
566b8: 2f2b 0006 movel %a3@(6),%sp@-
566bc: 486a 0060 pea %a2@(96)
566c0: 4eb9 0004 9a04 jsr 49a04 <_Chain_Append>
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
566c6: 52aa 006c addql #1,%a2@(108)
566ca: 6012 bras 566de <rtems_rfs_buffer_handle_release+0x15e>
566cc: 2f2b 0006 movel %a3@(6),%sp@-
566d0: 486a 0050 pea %a2@(80)
566d4: 4eb9 0004 9a04 jsr 49a04 <_Chain_Append>
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
566da: 52aa 005c addql #1,%a2@(92)
566de: 508f addql #8,%sp
566e0: 6002 bras 566e4 <rtems_rfs_buffer_handle_release+0x164>
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
566e2: 4282 clrl %d2
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
566e4: 42ab 0006 clrl %a3@(6)
566e8: 6002 bras 566ec <rtems_rfs_buffer_handle_release+0x16c>
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
566ea: 4282 clrl %d2
}
handle->buffer = NULL;
}
return rc;
}
566ec: 2002 movel %d2,%d0
566ee: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
566f4: 4e5e unlk %fp <== NOT EXECUTED
000566f8 <rtems_rfs_buffer_handle_request>:
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
566f8: 4e56 ffec linkw %fp,#-20
566fc: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
56700: 266e 0008 moveal %fp@(8),%a3
56704: 246e 000c moveal %fp@(12),%a2
56708: 242e 0010 movel %fp@(16),%d2
5670c: 182e 0017 moveb %fp@(23),%d4
/*
* If the handle has a buffer release it. This allows a handle to be reused
* without needing to close then open it again.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
56710: 4aaa 0006 tstl %a2@(6)
56714: 6748 beqs 5675e <rtems_rfs_buffer_handle_request+0x66>
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
56716: 4a82 tstl %d2
56718: 6708 beqs 56722 <rtems_rfs_buffer_handle_request+0x2a><== NEVER TAKEN
5671a: b4aa 0002 cmpl %a2@(2),%d2
5671e: 6700 01dc beqw 568fc <rtems_rfs_buffer_handle_request+0x204>
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
56722: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
56726: 42a7 clrl %sp@-
56728: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
5672e: 508f addql #8,%sp
56730: 4a00 tstb %d0
56732: 6712 beqs 56746 <rtems_rfs_buffer_handle_request+0x4e><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
56734: 2f2a 0002 movel %a2@(2),%sp@- <== NOT EXECUTED
56738: 4879 0006 c8aa pea 6c8aa <CSWTCH.1+0x1f0> <== NOT EXECUTED
5673e: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56744: 508f addql #8,%sp <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
56746: 2f0a movel %a2,%sp@-
56748: 2f0b movel %a3,%sp@-
5674a: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
if (rc > 0)
56750: 508f addql #8,%sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
56752: 2600 movel %d0,%d3
if (rc > 0)
56754: 6e00 01a8 bgtw 568fe <rtems_rfs_buffer_handle_request+0x206>
return rc;
handle->dirty = false;
handle->bnum = 0;
56758: 42aa 0002 clrl %a2@(2)
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
if (rc > 0)
return rc;
handle->dirty = false;
5675c: 4212 clrb %a2@
handle->bnum = 0;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
5675e: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
56762: 42a7 clrl %sp@-
56764: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
5676a: 508f addql #8,%sp
5676c: 4a00 tstb %d0
5676e: 6710 beqs 56780 <rtems_rfs_buffer_handle_request+0x88><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
56770: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56772: 4879 0006 c8dd pea 6c8dd <CSWTCH.1+0x223> <== NOT EXECUTED
56778: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5677e: 508f addql #8,%sp <== NOT EXECUTED
* currently attached to a handle. If it is share the access. A buffer could
* be shared where different parts of the block have separate functions. An
* example is an inode block and the file system needs to handle 2 inodes in
* the same block at the same time.
*/
if (fs->buffers_count)
56780: 4aab 004c tstl %a3@(76)
56784: 6744 beqs 567ca <rtems_rfs_buffer_handle_request+0xd2>
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
56786: 2f02 movel %d2,%sp@-
56788: 486b 004c pea %a3@(76)
5678c: 486b 0040 pea %a3@(64)
56790: 4eba fd0e jsr %pc@(564a0 <rtems_rfs_scan_chain>)
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
56794: 4fef 000c lea %sp@(12),%sp
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
56798: 2540 0006 movel %d0,%a2@(6)
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
5679c: 672c beqs 567ca <rtems_rfs_buffer_handle_request+0xd2>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
5679e: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
567a2: 42a7 clrl %sp@-
567a4: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
567aa: 508f addql #8,%sp
567ac: 4a00 tstb %d0
567ae: 671a beqs 567ca <rtems_rfs_buffer_handle_request+0xd2><== ALWAYS TAKEN
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
rtems_rfs_buffer_refs (handle) + 1);
567b0: 206a 0006 moveal %a2@(6),%a0 <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
567b4: 2068 0032 moveal %a0@(50),%a0 <== NOT EXECUTED
567b8: 5288 addql #1,%a0 <== NOT EXECUTED
567ba: 2f08 movel %a0,%sp@- <== NOT EXECUTED
567bc: 4879 0006 c903 pea 6c903 <CSWTCH.1+0x249> <== NOT EXECUTED
567c2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
567c8: 508f addql #8,%sp <== NOT EXECUTED
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
567ca: 7002 moveq #2,%d0
567cc: c093 andl %a3@,%d0
567ce: 664a bnes 5681a <rtems_rfs_buffer_handle_request+0x122>
567d0: 4aaa 0006 tstl %a2@(6)
567d4: 6644 bnes 5681a <rtems_rfs_buffer_handle_request+0x122>
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
567d6: 4aab 005c tstl %a3@(92)
567da: 6716 beqs 567f2 <rtems_rfs_buffer_handle_request+0xfa>
handle->buffer = rtems_rfs_scan_chain (&fs->release,
567dc: 2f02 movel %d2,%sp@-
567de: 486b 005c pea %a3@(92)
567e2: 486b 0050 pea %a3@(80)
567e6: 4eba fcb8 jsr %pc@(564a0 <rtems_rfs_scan_chain>)
567ea: 4fef 000c lea %sp@(12),%sp
567ee: 2540 0006 movel %d0,%a2@(6)
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
567f2: 4aaa 0006 tstl %a2@(6)
567f6: 6622 bnes 5681a <rtems_rfs_buffer_handle_request+0x122>
567f8: 4aab 006c tstl %a3@(108)
567fc: 671c beqs 5681a <rtems_rfs_buffer_handle_request+0x122>
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
567fe: 2f02 movel %d2,%sp@-
56800: 486b 006c pea %a3@(108)
56804: 486b 0060 pea %a3@(96)
56808: 4eba fc96 jsr %pc@(564a0 <rtems_rfs_scan_chain>)
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
5680c: 4fef 000c lea %sp@(12),%sp
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
56810: 2540 0006 movel %d0,%a2@(6)
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
56814: 6704 beqs 5681a <rtems_rfs_buffer_handle_request+0x122>
rtems_rfs_buffer_mark_dirty (handle);
56816: 14bc 0001 moveb #1,%a2@
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
5681a: 4aaa 0006 tstl %a2@(6)
5681e: 6670 bnes 56890 <rtems_rfs_buffer_handle_request+0x198>
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
56820: 486a 0006 pea %a2@(6)
56824: 4280 clrl %d0
56826: 1004 moveb %d4,%d0
56828: 2f00 movel %d0,%sp@-
5682a: 2f02 movel %d2,%sp@-
5682c: 2f0b movel %a3,%sp@-
5682e: 4eb9 0005 b340 jsr 5b340 <rtems_rfs_buffer_bdbuf_request>
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
56834: 206a 0006 moveal %a2@(6),%a0
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
56838: 2600 movel %d0,%d3
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
if (rc > 0)
5683a: 4fef 0010 lea %sp@(16),%sp
5683e: 42a8 0004 clrl %a0@(4)
56842: 4290 clrl %a0@
56844: 4a80 tstl %d0
56846: 6f48 bles 56890 <rtems_rfs_buffer_handle_request+0x198><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
56848: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> <== NOT EXECUTED
5684c: 42a7 clrl %sp@- <== NOT EXECUTED
5684e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
56854: 508f addql #8,%sp <== NOT EXECUTED
56856: 4a00 tstb %d0 <== NOT EXECUTED
56858: 6700 00a4 beqw 568fe <rtems_rfs_buffer_handle_request+0x206><== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
5685c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5685e: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
56864: 588f addql #4,%sp <== NOT EXECUTED
56866: 223c 0006 c8a6 movel #444582,%d1 <== NOT EXECUTED
5686c: 4a04 tstb %d4 <== NOT EXECUTED
5686e: 6706 beqs 56876 <rtems_rfs_buffer_handle_request+0x17e><== NOT EXECUTED
56870: 223c 0006 c2e8 movel #443112,%d1 <== NOT EXECUTED
56876: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56878: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5687a: 2f01 movel %d1,%sp@- <== NOT EXECUTED
5687c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5687e: 4879 0006 c937 pea 6c937 <CSWTCH.1+0x27d> <== NOT EXECUTED
56884: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5688a: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
5688e: 606e bras 568fe <rtems_rfs_buffer_handle_request+0x206><== NOT EXECUTED
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
56890: 206a 0006 moveal %a2@(6),%a0
56894: 52a8 0032 addql #1,%a0@(50)
56898: 2f08 movel %a0,%sp@-
5689a: 486b 0040 pea %a3@(64)
5689e: 4eb9 0004 9a04 jsr 49a04 <_Chain_Append>
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
handle->buffer->user = (void*) ((intptr_t) block);
568a4: 206a 0006 moveal %a2@(6),%a0
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
568a8: 52ab 004c addql #1,%a3@(76)
handle->buffer->user = (void*) ((intptr_t) block);
568ac: 2142 0036 movel %d2,%a0@(54)
handle->bnum = block;
568b0: 2542 0002 movel %d2,%a2@(2)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
568b4: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
568b8: 42a7 clrl %sp@-
568ba: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
568c0: 4fef 0010 lea %sp@(16),%sp
568c4: 4a00 tstb %d0
568c6: 6734 beqs 568fc <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
568c8: 206a 0006 moveal %a2@(6),%a0 <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
568cc: 2268 0032 moveal %a0@(50),%a1 <== NOT EXECUTED
568d0: 203c 0006 c8a6 movel #444582,%d0 <== NOT EXECUTED
568d6: 2228 001a movel %a0@(26),%d1 <== NOT EXECUTED
568da: 4a04 tstb %d4 <== NOT EXECUTED
568dc: 6706 beqs 568e4 <rtems_rfs_buffer_handle_request+0x1ec><== NOT EXECUTED
568de: 203c 0006 c2e8 movel #443112,%d0 <== NOT EXECUTED
568e4: 2f09 movel %a1,%sp@- <== NOT EXECUTED
568e6: 2f01 movel %d1,%sp@- <== NOT EXECUTED
568e8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
568ea: 2f02 movel %d2,%sp@- <== NOT EXECUTED
568ec: 4879 0006 c96f pea 6c96f <CSWTCH.1+0x2b5> <== NOT EXECUTED
568f2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
568f8: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
568fc: 4283 clrl %d3
}
568fe: 2003 movel %d3,%d0
56900: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
56906: 4e5e unlk %fp <== NOT EXECUTED
0005690a <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
5690a: 4e56 ffb8 linkw %fp,#-72
5690e: 2f0a movel %a2,%sp@-
56910: 246e 000c moveal %fp@(12),%a2
56914: 2f02 movel %d2,%sp@-
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
56916: 4878 0020 pea 20 <OPER2+0xc>
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
5691a: 242e 0008 movel %fp@(8),%d2
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
5691e: 42a7 clrl %sp@-
56920: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56926: 508f addql #8,%sp
56928: 4a00 tstb %d0
5692a: 6710 beqs 5693c <rtems_rfs_buffer_open+0x32> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
5692c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5692e: 4879 0006 c9aa pea 6c9aa <CSWTCH.1+0x2f0> <== NOT EXECUTED
56934: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5693a: 508f addql #8,%sp <== NOT EXECUTED
if (stat (name, &st) < 0)
5693c: 486e ffba pea %fp@(-70)
56940: 2f02 movel %d2,%sp@-
56942: 4eb9 0004 6960 jsr 46960 <stat>
56948: 508f addql #8,%sp
5694a: 4a80 tstl %d0
5694c: 6c3c bges 5698a <rtems_rfs_buffer_open+0x80> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
5694e: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
56952: 42a7 clrl %sp@- <== NOT EXECUTED
56954: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5695a: 508f addql #8,%sp <== NOT EXECUTED
5695c: 4a00 tstb %d0 <== NOT EXECUTED
5695e: 6700 00c6 beqw 56a26 <rtems_rfs_buffer_open+0x11c> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
56962: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
if (stat (name, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
56968: 2040 moveal %d0,%a0 <== NOT EXECUTED
5696a: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
5696c: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
56972: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56974: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56976: 4879 0006 c9cf pea 6c9cf <CSWTCH.1+0x315> <== NOT EXECUTED
5697c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56982: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
56986: 6000 009e braw 56a26 <rtems_rfs_buffer_open+0x11c> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
5698a: 202e ffc6 movel %fp@(-58),%d0
5698e: 0280 0000 f000 andil #61440,%d0
56994: 0c80 0000 6000 cmpil #24576,%d0
5699a: 6724 beqs 569c0 <rtems_rfs_buffer_open+0xb6> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
5699c: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
569a0: 42a7 clrl %sp@- <== NOT EXECUTED
569a2: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
569a8: 508f addql #8,%sp <== NOT EXECUTED
569aa: 4a00 tstb %d0 <== NOT EXECUTED
569ac: 677c beqs 56a2a <rtems_rfs_buffer_open+0x120> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
569ae: 2f02 movel %d2,%sp@- <== NOT EXECUTED
569b0: 4879 0006 c9fd pea 6c9fd <CSWTCH.1+0x343> <== NOT EXECUTED
569b6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
569bc: 508f addql #8,%sp <== NOT EXECUTED
569be: 606a bras 56a2a <rtems_rfs_buffer_open+0x120> <== NOT EXECUTED
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
569c0: 2f2e ffd4 movel %fp@(-44),%sp@-
569c4: 2f2e ffd0 movel %fp@(-48),%sp@-
569c8: 4eb9 0004 44ba jsr 444ba <rtems_disk_obtain>
if (!fs->disk)
569ce: 508f addql #8,%sp
569d0: 41f9 0004 f5ec lea 4f5ec <rtems_rfs_trace>,%a0
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
569d6: 2540 000c movel %d0,%a2@(12)
if (!fs->disk)
569da: 661e bnes 569fa <rtems_rfs_buffer_open+0xf0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
569dc: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
569e0: 42a7 clrl %sp@- <== NOT EXECUTED
569e2: 4e90 jsr %a0@ <== NOT EXECUTED
569e4: 508f addql #8,%sp <== NOT EXECUTED
569e6: 4a00 tstb %d0 <== NOT EXECUTED
569e8: 6740 beqs 56a2a <rtems_rfs_buffer_open+0x120> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
569ea: 4879 0006 ca31 pea 6ca31 <CSWTCH.1+0x377> <== NOT EXECUTED
569f0: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
569f6: 588f addql #4,%sp <== NOT EXECUTED
569f8: 6030 bras 56a2a <rtems_rfs_buffer_open+0x120> <== NOT EXECUTED
}
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
569fa: 4878 0020 pea 20 <OPER2+0xc>
569fe: 42a7 clrl %sp@-
56a00: 4e90 jsr %a0@
56a02: 508f addql #8,%sp
56a04: 4a00 tstb %d0
56a06: 6726 beqs 56a2e <rtems_rfs_buffer_open+0x124> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
56a08: 206a 000c moveal %a2@(12),%a0 <== NOT EXECUTED
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
56a0c: 2f28 0024 movel %a0@(36),%sp@- <== NOT EXECUTED
56a10: 2f28 001c movel %a0@(28),%sp@- <== NOT EXECUTED
56a14: 4879 0006 ca60 pea 6ca60 <CSWTCH.1+0x3a6> <== NOT EXECUTED
56a1a: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56a20: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
56a24: 6008 bras 56a2e <rtems_rfs_buffer_open+0x124> <== NOT EXECUTED
if (stat (name, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
return ENOENT;
56a26: 7002 moveq #2,%d0 <== NOT EXECUTED
56a28: 6006 bras 56a30 <rtems_rfs_buffer_open+0x126> <== NOT EXECUTED
fs->disk = rtems_disk_obtain (st.st_rdev);
if (!fs->disk)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
return EIO;
56a2a: 7005 moveq #5,%d0 <== NOT EXECUTED
56a2c: 6002 bras 56a30 <rtems_rfs_buffer_open+0x126> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
56a2e: 4280 clrl %d0
}
56a30: 242e ffb0 movel %fp@(-80),%d2
56a34: 246e ffb4 moveal %fp@(-76),%a2
56a38: 4e5e unlk %fp <== NOT EXECUTED
00056b4a <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
56b4a: 4e56 0000 linkw %fp,#0
56b4e: 2f0a movel %a2,%sp@-
56b50: 246e 0008 moveal %fp@(8),%a2
56b54: 2f02 movel %d2,%sp@-
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
56b56: 4878 0400 pea 400 <D_BIAS+0x2>
56b5a: 42a7 clrl %sp@-
56b5c: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56b62: 508f addql #8,%sp
56b64: 4a00 tstb %d0
56b66: 6712 beqs 56b7a <rtems_rfs_buffer_setblksize+0x30><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
56b68: 2f2e 000c movel %fp@(12),%sp@- <== NOT EXECUTED
56b6c: 4879 0006 cb29 pea 6cb29 <CSWTCH.1+0x46f> <== NOT EXECUTED
56b72: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56b78: 508f addql #8,%sp <== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
56b7a: 2f0a movel %a2,%sp@-
56b7c: 4eb9 0005 6aca jsr 56aca <rtems_rfs_buffers_release>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
56b82: 588f addql #4,%sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
56b84: 2400 movel %d0,%d2
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
56b86: 6f2e bles 56bb6 <rtems_rfs_buffer_setblksize+0x6c><== ALWAYS TAKEN
56b88: 4878 0400 pea 400 <D_BIAS+0x2> <== NOT EXECUTED
56b8c: 42a7 clrl %sp@- <== NOT EXECUTED
56b8e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
56b94: 508f addql #8,%sp <== NOT EXECUTED
56b96: 4a00 tstb %d0 <== NOT EXECUTED
56b98: 671c beqs 56bb6 <rtems_rfs_buffer_setblksize+0x6c><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
56b9a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56b9c: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
56ba2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56ba4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56ba6: 4879 0006 cb58 pea 6cb58 <CSWTCH.1+0x49e> <== NOT EXECUTED
56bac: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56bb2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
56bb6: 2f0a movel %a2,%sp@-
56bb8: 4eb9 0005 6a3c jsr 56a3c <rtems_rfs_buffer_sync>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
56bbe: 588f addql #4,%sp
rc = rtems_rfs_buffers_release (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
56bc0: 2400 movel %d0,%d2
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
56bc2: 6f2e bles 56bf2 <rtems_rfs_buffer_setblksize+0xa8><== ALWAYS TAKEN
56bc4: 4878 0400 pea 400 <D_BIAS+0x2> <== NOT EXECUTED
56bc8: 42a7 clrl %sp@- <== NOT EXECUTED
56bca: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
56bd0: 508f addql #8,%sp <== NOT EXECUTED
56bd2: 4a00 tstb %d0 <== NOT EXECUTED
56bd4: 671c beqs 56bf2 <rtems_rfs_buffer_setblksize+0xa8><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
56bd6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56bd8: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
56bde: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56be0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56be2: 4879 0006 cb95 pea 6cb95 <CSWTCH.1+0x4db> <== NOT EXECUTED
56be8: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56bee: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
56bf2: 206a 000c moveal %a2@(12),%a0
56bf6: 486e 000c pea %fp@(12)
56bfa: 2f3c 8004 4204 movel #-2147204604,%sp@-
56c00: 2f08 movel %a0,%sp@-
56c02: 2068 0028 moveal %a0@(40),%a0
56c06: 4e90 jsr %a0@
if (rc < 0)
56c08: 4fef 000c lea %sp@(12),%sp
56c0c: 4a80 tstl %d0
56c0e: 6c0a bges 56c1a <rtems_rfs_buffer_setblksize+0xd0><== ALWAYS TAKEN
rc = errno;
56c10: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
56c16: 2040 moveal %d0,%a0 <== NOT EXECUTED
56c18: 2010 movel %a0@,%d0 <== NOT EXECUTED
#endif
return rc;
}
56c1a: 242e fff8 movel %fp@(-8),%d2
56c1e: 246e fffc moveal %fp@(-4),%a2
56c22: 4e5e unlk %fp <== NOT EXECUTED
00056a3c <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
56a3c: 4e56 0000 linkw %fp,#0
56a40: 2f0a movel %a2,%sp@-
56a42: 246e 0008 moveal %fp@(8),%a2
56a46: 2f02 movel %d2,%sp@-
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
56a48: 4878 0020 pea 20 <OPER2+0xc>
56a4c: 42a7 clrl %sp@-
56a4e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56a54: 508f addql #8,%sp
56a56: 4a00 tstb %d0
56a58: 670e beqs 56a68 <rtems_rfs_buffer_sync+0x2c> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-sync: syncing\n");
56a5a: 4879 0006 ca90 pea 6ca90 <CSWTCH.1+0x3d6> <== NOT EXECUTED
56a60: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
56a66: 588f addql #4,%sp <== NOT EXECUTED
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
56a68: 206a 000c moveal %a2@(12),%a0
56a6c: 2f28 0004 movel %a0@(4),%sp@-
56a70: 2f10 movel %a0@,%sp@-
56a72: 4eb9 0005 1726 jsr 51726 <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL)
56a78: 508f addql #8,%sp
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
56a7a: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
56a7c: 672e beqs 56aac <rtems_rfs_buffer_sync+0x70> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
56a7e: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
56a82: 42a7 clrl %sp@- <== NOT EXECUTED
56a84: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
56a8a: 508f addql #8,%sp <== NOT EXECUTED
56a8c: 4a00 tstb %d0 <== NOT EXECUTED
56a8e: 6720 beqs 56ab0 <rtems_rfs_buffer_sync+0x74> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
56a90: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56a92: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
56a98: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56a9a: 4879 0006 cab0 pea 6cab0 <CSWTCH.1+0x3f6> <== NOT EXECUTED
56aa0: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56aa6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
56aaa: 6004 bras 56ab0 <rtems_rfs_buffer_sync+0x74> <== NOT EXECUTED
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
int result = 0;
56aac: 4282 clrl %d2
56aae: 6002 bras 56ab2 <rtems_rfs_buffer_sync+0x76>
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
56ab0: 7405 moveq #5,%d2 <== NOT EXECUTED
}
rtems_disk_release (fs->disk);
56ab2: 2f2a 000c movel %a2@(12),%sp@-
56ab6: 4eb9 0004 4522 jsr 44522 <rtems_disk_release>
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
56abc: 246e fffc moveal %fp@(-4),%a2
56ac0: 2002 movel %d2,%d0
56ac2: 242e fff8 movel %fp@(-8),%d2
56ac6: 4e5e unlk %fp <== NOT EXECUTED
00056aca <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
56aca: 4e56 fff4 linkw %fp,#-12
56ace: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
56ad2: 4878 0040 pea 40 <DBL_MANT_DIG+0xb>
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
56ad6: 246e 0008 moveal %fp@(8),%a2
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
56ada: 42a7 clrl %sp@-
56adc: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56ae2: 508f addql #8,%sp
56ae4: 4a00 tstb %d0
56ae6: 671c beqs 56b04 <rtems_rfs_buffers_release+0x3a> <== ALWAYS TAKEN
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
56ae8: 2f2a 006c movel %a2@(108),%sp@- <== NOT EXECUTED
56aec: 2f2a 005c movel %a2@(92),%sp@- <== NOT EXECUTED
56af0: 2f2a 004c movel %a2@(76),%sp@- <== NOT EXECUTED
56af4: 4879 0006 cae0 pea 6cae0 <CSWTCH.1+0x426> <== NOT EXECUTED
56afa: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56b00: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
56b04: 42a7 clrl %sp@-
56b06: 486a 005c pea %a2@(92)
56b0a: 47fa f914 lea %pc@(56420 <rtems_rfs_release_chain>),%a3
56b0e: 486a 0050 pea %a2@(80)
56b12: 4e93 jsr %a3@
56b14: 4fef 000c lea %sp@(12),%sp
56b18: 2400 movel %d0,%d2
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
56b1a: 4878 0001 pea 1 <ADD>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
56b1e: 4680 notl %d0
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
56b20: 486a 006c pea %a2@(108)
56b24: 486a 0060 pea %a2@(96)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
56b28: d080 addl %d0,%d0
56b2a: 9180 subxl %d0,%d0
56b2c: c480 andl %d0,%d2
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
56b2e: 4e93 jsr %a3@
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
56b30: 4fef 000c lea %sp@(12),%sp
56b34: 4a80 tstl %d0
56b36: 6f06 bles 56b3e <rtems_rfs_buffers_release+0x74> <== ALWAYS TAKEN
56b38: 4a82 tstl %d2 <== NOT EXECUTED
56b3a: 6602 bnes 56b3e <rtems_rfs_buffers_release+0x74> <== NOT EXECUTED
56b3c: 2400 movel %d0,%d2 <== NOT EXECUTED
rrc = rc;
return rrc;
}
56b3e: 2002 movel %d2,%d0
56b40: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
56b46: 4e5e unlk %fp <== NOT EXECUTED
00057150 <rtems_rfs_dir_add_entry>:
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
57150: 4e56 ff6c linkw %fp,#-148
57154: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
57158: 2f3c 2000 0000 movel #536870912,%sp@-
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
5715e: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
57162: 42a7 clrl %sp@-
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
57164: 286e 000c moveal %fp@(12),%a4
57168: 2e2e 0010 movel %fp@(16),%d7
5716c: 282e 0014 movel %fp@(20),%d4
57170: 2c2e 0018 movel %fp@(24),%d6
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
57174: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
5717a: 508f addql #8,%sp
5717c: 4a00 tstb %d0
5717e: 673e beqs 571be <rtems_rfs_dir_add_entry+0x6e> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
57180: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
57184: 2447 moveal %d7,%a2 <== NOT EXECUTED
57186: 4879 0006 ced6 pea 6ced6 <CSWTCH.1+0x81c> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
5718c: 4282 clrl %d2 <== NOT EXECUTED
printf ("%c", name[c]);
5718e: 4bf9 0005 c1b0 lea 5c1b0 <putchar>,%a5 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
57194: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
5719a: 508f addql #8,%sp <== NOT EXECUTED
5719c: 600c bras 571aa <rtems_rfs_dir_add_entry+0x5a> <== NOT EXECUTED
5719e: 5282 addql #1,%d2 <== NOT EXECUTED
printf ("%c", name[c]);
571a0: 101a moveb %a2@+,%d0 <== NOT EXECUTED
571a2: 49c0 extbl %d0 <== NOT EXECUTED
571a4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
571a6: 4e95 jsr %a5@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
571a8: 588f addql #4,%sp <== NOT EXECUTED
571aa: b882 cmpl %d2,%d4 <== NOT EXECUTED
571ac: 66f0 bnes 5719e <rtems_rfs_dir_add_entry+0x4e> <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
571ae: 2f04 movel %d4,%sp@- <== NOT EXECUTED
571b0: 4879 0006 ceff pea 6ceff <CSWTCH.1+0x845> <== NOT EXECUTED
571b6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
571bc: 508f addql #8,%sp <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
571be: 4bee ff9c lea %fp@(-100),%a5
571c2: 2f0d movel %a5,%sp@-
571c4: 2f0c movel %a4,%sp@-
571c6: 2f0b movel %a3,%sp@-
571c8: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open>
if (rc > 0)
571ce: 4fef 000c lea %sp@(12),%sp
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
571d2: 2600 movel %d0,%d3
if (rc > 0)
571d4: 6e00 02d0 bgtw 574a6 <rtems_rfs_dir_add_entry+0x356>
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
571d8: 2044 moveal %d4,%a0
571da: 41e8 000a lea %a0@(10),%a0
571de: 4201 clrb %d1
handle->bnum = 0;
571e0: 42ae fff4 clrl %fp@(-12)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
571e4: 1d41 fff2 moveb %d1,%fp@(-14)
handle->bnum = 0;
handle->buffer = NULL;
571e8: 42ae fff8 clrl %fp@(-8)
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
571ec: 42ae ffe6 clrl %fp@(-26)
bpos->boff = 0;
571f0: 42ae ffea clrl %fp@(-22)
bpos->block = 0;
571f4: 42ae ffee clrl %fp@(-18)
571f8: 2d48 ff96 movel %a0,%fp@(-106)
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
571fc: 486e fffc pea %fp@(-4)
57200: 486e ffe6 pea %fp@(-26)
57204: 2f0d movel %a5,%sp@-
57206: 2f0b movel %a3,%sp@-
57208: 4eb9 0005 5d1a jsr 55d1a <rtems_rfs_block_map_find>
if (rc > 0)
5720e: 4fef 0010 lea %sp@(16),%sp
57212: 4a80 tstl %d0
57214: 6f00 008e blew 572a4 <rtems_rfs_dir_add_entry+0x154>
{
if (rc != ENXIO)
57218: 7206 moveq #6,%d1
5721a: b280 cmpl %d0,%d1
5721c: 6730 beqs 5724e <rtems_rfs_dir_add_entry+0xfe> <== ALWAYS TAKEN
5721e: 2600 movel %d0,%d3 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
57220: 2f3c 2000 0000 movel #536870912,%sp@- <== NOT EXECUTED
57226: 42a7 clrl %sp@- <== NOT EXECUTED
57228: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5722e: 508f addql #8,%sp <== NOT EXECUTED
57230: 4a00 tstb %d0 <== NOT EXECUTED
57232: 6700 0258 beqw 5748c <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
57236: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57238: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
5723e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
57240: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57242: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
57246: 4879 0006 cf0a pea 6cf0a <CSWTCH.1+0x850> <== NOT EXECUTED
5724c: 6048 bras 57296 <rtems_rfs_dir_add_entry+0x146> <== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
5724e: 486e fffc pea %fp@(-4)
57252: 4878 0001 pea 1 <ADD>
57256: 2f0d movel %a5,%sp@-
57258: 2f0b movel %a3,%sp@-
5725a: 4eb9 0005 5eb6 jsr 55eb6 <rtems_rfs_block_map_grow>
if (rc > 0)
57260: 4fef 0010 lea %sp@(16),%sp
57264: 4a80 tstl %d0
57266: 6f40 bles 572a8 <rtems_rfs_dir_add_entry+0x158>
57268: 2600 movel %d0,%d3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
5726a: 2f3c 2000 0000 movel #536870912,%sp@-
57270: 42a7 clrl %sp@-
57272: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
57278: 508f addql #8,%sp
5727a: 4a00 tstb %d0
5727c: 6700 020e beqw 5748c <rtems_rfs_dir_add_entry+0x33c>
printf ("rtems-rfs: dir-add-entry: "
57280: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57282: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
57288: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5728a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5728c: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
57290: 4879 0006 cf4f pea 6cf4f <CSWTCH.1+0x895> <== NOT EXECUTED
57296: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5729c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
572a0: 6000 01ea braw 5748c <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
572a4: 7401 moveq #1,%d2
572a6: 6002 bras 572aa <rtems_rfs_dir_add_entry+0x15a>
"block map grow failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
read = false;
572a8: 4202 clrb %d2
}
bpos.bno++;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
572aa: 7001 moveq #1,%d0
}
read = false;
}
bpos.bno++;
572ac: 52ae ffe6 addql #1,%fp@(-26)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
572b0: c082 andl %d2,%d0
572b2: 2f00 movel %d0,%sp@-
572b4: 2f2e fffc movel %fp@(-4),%sp@-
572b8: 486e fff2 pea %fp@(-14)
572bc: 2f0b movel %a3,%sp@-
572be: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
572c4: 4fef 0010 lea %sp@(16),%sp
572c8: 4a80 tstl %d0
572ca: 6f30 bles 572fc <rtems_rfs_dir_add_entry+0x1ac> <== ALWAYS TAKEN
572cc: 2600 movel %d0,%d3 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
572ce: 2f3c 2000 0000 movel #536870912,%sp@- <== NOT EXECUTED
572d4: 42a7 clrl %sp@- <== NOT EXECUTED
572d6: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
572dc: 508f addql #8,%sp <== NOT EXECUTED
572de: 4a00 tstb %d0 <== NOT EXECUTED
572e0: 6700 01aa beqw 5748c <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
572e4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
572e6: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
572ec: 2f00 movel %d0,%sp@- <== NOT EXECUTED
572ee: 2f03 movel %d3,%sp@- <== NOT EXECUTED
572f0: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
572f4: 4879 0006 cf94 pea 6cf94 <CSWTCH.1+0x8da> <== NOT EXECUTED
572fa: 609a bras 57296 <rtems_rfs_dir_add_entry+0x146> <== NOT EXECUTED
"block buffer req failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
entry = rtems_rfs_buffer_data (&buffer);
572fc: 206e fff8 moveal %fp@(-8),%a0
57300: 2468 001e moveal %a0@(30),%a2
if (!read)
57304: 4a02 tstb %d2
57306: 6614 bnes 5731c <rtems_rfs_dir_add_entry+0x1cc>
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
57308: 2f2b 0008 movel %a3@(8),%sp@-
5730c: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
57310: 2f0a movel %a2,%sp@-
57312: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
57318: 4fef 000c lea %sp@(12),%sp
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
5731c: 222b 0008 movel %a3@(8),%d1
57320: 2041 moveal %d1,%a0
57322: 41e8 fff6 lea %a0@(-10),%a0
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
57326: 4285 clrl %d5
57328: 2241 moveal %d1,%a1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
5732a: 6000 0156 braw 57482 <rtems_rfs_dir_add_entry+0x332>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
5732e: 4282 clrl %d2
57330: 142a 0008 moveb %a2@(8),%d2
57334: 4280 clrl %d0
57336: 102a 0009 moveb %a2@(9),%d0
eino = rtems_rfs_dir_entry_ino (entry);
5733a: 122a 0002 moveb %a2@(2),%d1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
5733e: e18a lsll #8,%d2
eino = rtems_rfs_dir_entry_ino (entry);
57340: 1612 moveb %a2@,%d3
57342: 1d41 ff9b moveb %d1,%fp@(-101)
57346: 122a 0003 moveb %a2@(3),%d1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
5734a: 8480 orl %d0,%d2
eino = rtems_rfs_dir_entry_ino (entry);
5734c: 1d41 ff95 moveb %d1,%fp@(-107)
57350: 102a 0001 moveb %a2@(1),%d0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
57354: 0c82 0000 ffff cmpil #65535,%d2
5735a: 6600 009e bnew 573fa <rtems_rfs_dir_add_entry+0x2aa>
5735e: 2209 movel %a1,%d1
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
57360: 9285 subl %d5,%d1
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
57362: b2ae ff96 cmpl %fp@(-106),%d1
57366: 6300 fe94 blsw 571fc <rtems_rfs_dir_add_entry+0xac>
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
5736a: 2f04 movel %d4,%sp@-
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
5736c: 4283 clrl %d3
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
5736e: 2f07 movel %d7,%sp@-
rtems_rfs_dir_set_entry_hash (entry, hash);
57370: 343c 0018 movew #24,%d2
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
57374: 4eb9 0005 b400 jsr 5b400 <rtems_rfs_dir_hash>
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
5737a: 1546 0003 moveb %d6,%a2@(3)
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
5737e: 2200 movel %d0,%d1
57380: e4a9 lsrl %d2,%d1
57382: 1541 0004 moveb %d1,%a2@(4)
57386: 2200 movel %d0,%d1
57388: 4241 clrw %d1
5738a: 4841 swap %d1
5738c: 1540 0007 moveb %d0,%a2@(7)
57390: 1541 0005 moveb %d1,%a2@(5)
57394: 2200 movel %d0,%d1
rtems_rfs_dir_set_entry_ino (entry, ino);
57396: 2006 movel %d6,%d0
57398: e4a8 lsrl %d2,%d0
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
5739a: e089 lsrl #8,%d1
rtems_rfs_dir_set_entry_ino (entry, ino);
5739c: 1480 moveb %d0,%a2@
5739e: 2006 movel %d6,%d0
573a0: 4240 clrw %d0
573a2: 4840 swap %d0
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
573a4: 1541 0006 moveb %d1,%a2@(6)
rtems_rfs_dir_set_entry_ino (entry, ino);
573a8: 1540 0001 moveb %d0,%a2@(1)
573ac: 2006 movel %d6,%d0
573ae: e088 lsrl #8,%d0
573b0: 1540 0002 moveb %d0,%a2@(2)
rtems_rfs_dir_set_entry_length (entry,
573b4: 2004 movel %d4,%d0
573b6: 0680 0000 000a addil #10,%d0
573bc: 2200 movel %d0,%d1
573be: e089 lsrl #8,%d1
573c0: 1540 0009 moveb %d0,%a2@(9)
573c4: 1541 0008 moveb %d1,%a2@(8)
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
573c8: 2f04 movel %d4,%sp@-
573ca: 2f07 movel %d7,%sp@-
573cc: 486a 000a pea %a2@(10)
573d0: 4eb9 0005 bf8c jsr 5bf8c <memcpy>
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
573d6: 486e fff2 pea %fp@(-14)
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
573da: 7001 moveq #1,%d0
rtems_rfs_buffer_handle_close (fs, &buffer);
573dc: 2f0b movel %a3,%sp@-
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
573de: 1d40 fff2 moveb %d0,%fp@(-14)
rtems_rfs_buffer_handle_close (fs, &buffer);
573e2: 4eba f8cc jsr %pc@(56cb0 <rtems_rfs_buffer_handle_close>)
rtems_rfs_block_map_close (fs, &map);
573e6: 486e ff9c pea %fp@(-100)
573ea: 2f0b movel %a3,%sp@-
573ec: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close>
return 0;
573f2: 4fef 0024 lea %sp@(36),%sp
573f6: 6000 00ae braw 574a6 <rtems_rfs_dir_add_entry+0x356>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
573fa: 7218 moveq #24,%d1
573fc: 0280 0000 00ff andil #255,%d0
57402: e3ab lsll %d1,%d3
57404: 4281 clrl %d1
57406: 122e ff95 moveb %fp@(-107),%d1
5740a: 4840 swap %d0
5740c: 4240 clrw %d0
5740e: 8680 orl %d0,%d3
57410: 4280 clrl %d0
57412: 102e ff9b moveb %fp@(-101),%d0
57416: 8681 orl %d1,%d3
57418: e188 lsll #8,%d0
5741a: 8680 orl %d0,%d3
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
5741c: 700a moveq #10,%d0
5741e: b082 cmpl %d2,%d0
57420: 6c10 bges 57432 <rtems_rfs_dir_add_entry+0x2e2> <== NEVER TAKEN
57422: b4ab 0018 cmpl %a3@(24),%d2
57426: 640a bccs 57432 <rtems_rfs_dir_add_entry+0x2e2> <== NEVER TAKEN
57428: 4a83 tstl %d3
5742a: 6706 beqs 57432 <rtems_rfs_dir_add_entry+0x2e2> <== NEVER TAKEN
5742c: b6ab 0010 cmpl %a3@(16),%d3
57430: 634c blss 5747e <rtems_rfs_dir_add_entry+0x32e> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
57432: 2f3c 2000 0000 movel #536870912,%sp@- <== NOT EXECUTED
57438: 42a7 clrl %sp@- <== NOT EXECUTED
5743a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57440: 508f addql #8,%sp <== NOT EXECUTED
57442: 4a00 tstb %d0 <== NOT EXECUTED
57444: 671a beqs 57460 <rtems_rfs_dir_add_entry+0x310> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
57446: 2f05 movel %d5,%sp@- <== NOT EXECUTED
57448: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5744a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5744c: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
57450: 4879 0006 cfdb pea 6cfdb <CSWTCH.1+0x921> <== NOT EXECUTED
57456: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5745c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
57460: 486e fff2 pea %fp@(-14) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return EIO;
57464: 7605 moveq #5,%d3 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
57466: 2f0b movel %a3,%sp@- <== NOT EXECUTED
57468: 4eba f846 jsr %pc@(56cb0 <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
5746c: 486e ff9c pea %fp@(-100) <== NOT EXECUTED
57470: 2f0b movel %a3,%sp@- <== NOT EXECUTED
57472: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
return EIO;
57478: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5747c: 6028 bras 574a6 <rtems_rfs_dir_add_entry+0x356> <== NOT EXECUTED
}
entry += elength;
5747e: d5c2 addal %d2,%a2
offset += elength;
57480: da82 addl %d2,%d5
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
57482: b1c5 cmpal %d5,%a0
57484: 6200 fea8 bhiw 5732e <rtems_rfs_dir_add_entry+0x1de>
57488: 6000 fd72 braw 571fc <rtems_rfs_dir_add_entry+0xac> <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
5748c: 486e fff2 pea %fp@(-14)
57490: 2f0b movel %a3,%sp@-
57492: 4eba f81c jsr %pc@(56cb0 <rtems_rfs_buffer_handle_close>)
rtems_rfs_block_map_close (fs, &map);
57496: 486e ff9c pea %fp@(-100)
5749a: 2f0b movel %a3,%sp@-
5749c: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close>
return rc;
574a2: 4fef 0010 lea %sp@(16),%sp
}
574a6: 2003 movel %d3,%d0
574a8: 4cee 3cfc ff6c moveml %fp@(-148),%d2-%d7/%a2-%a5
574ae: 4e5e unlk %fp <== NOT EXECUTED
000574b2 <rtems_rfs_dir_del_entry>:
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
574b2: 4e56 ff78 linkw %fp,#-136
574b6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
574ba: 2f3c 4000 0000 movel #1073741824,%sp@-
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
574c0: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
574c4: 42a7 clrl %sp@-
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
574c6: 286e 000c moveal %fp@(12),%a4
574ca: 2a6e 0010 moveal %fp@(16),%a5
574ce: 2e2e 0014 movel %fp@(20),%d7
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
574d2: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
574d8: 508f addql #8,%sp
574da: 4a00 tstb %d0
574dc: 6718 beqs 574f6 <rtems_rfs_dir_del_entry+0x44> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
574de: 2f07 movel %d7,%sp@- <== NOT EXECUTED
574e0: 2f0d movel %a5,%sp@- <== NOT EXECUTED
574e2: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
574e6: 4879 0006 d023 pea 6d023 <CSWTCH.1+0x969> <== NOT EXECUTED
574ec: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
574f2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
574f6: 260e movel %fp,%d3
574f8: 0683 ffff ffa8 addil #-88,%d3
574fe: 2f03 movel %d3,%sp@-
57500: 2f0c movel %a4,%sp@-
57502: 2f0a movel %a2,%sp@-
57504: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open>
if (rc > 0)
5750a: 4fef 000c lea %sp@(12),%sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
5750e: 2400 movel %d0,%d2
if (rc > 0)
57510: 6e00 02fa bgtw 5780c <rtems_rfs_dir_del_entry+0x35a>
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
57514: 280e movel %fp,%d4
57516: 5984 subql #4,%d4
57518: 2f04 movel %d4,%sp@-
5751a: 2f07 movel %d7,%sp@-
5751c: 42a7 clrl %sp@-
5751e: 2f03 movel %d3,%sp@-
57520: 2f0a movel %a2,%sp@-
57522: 4eb9 0005 5e06 jsr 55e06 <rtems_rfs_block_map_seek>
if (rc > 0)
57528: 4fef 0014 lea %sp@(20),%sp
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
5752c: 2400 movel %d0,%d2
if (rc > 0)
5752e: 6f1a bles 5754a <rtems_rfs_dir_del_entry+0x98> <== ALWAYS TAKEN
{
if (rc == ENXIO)
57530: 7006 moveq #6,%d0 <== NOT EXECUTED
57532: b082 cmpl %d2,%d0 <== NOT EXECUTED
57534: 6602 bnes 57538 <rtems_rfs_dir_del_entry+0x86> <== NOT EXECUTED
rc = ENOENT;
57536: 7402 moveq #2,%d2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
57538: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
5753c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5753e: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
57544: 508f addql #8,%sp <== NOT EXECUTED
57546: 6000 02c4 braw 5780c <rtems_rfs_dir_del_entry+0x35a> <== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
5754a: 4a87 tstl %d7
5754c: 57c0 seq %d0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
5754e: 4201 clrb %d1
handle->bnum = 0;
57550: 42ae fff4 clrl %fp@(-12)
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
57554: 4282 clrl %d2
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
57556: 1d41 fff2 moveb %d1,%fp@(-14)
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
5755a: 2200 movel %d0,%d1
5755c: 4481 negl %d1
handle->bnum = 0;
handle->buffer = NULL;
5755e: 42ae fff8 clrl %fp@(-8)
57562: 1d41 ffa7 moveb %d1,%fp@(-89)
while (rc == 0)
57566: 6000 0280 braw 577e8 <rtems_rfs_dir_del_entry+0x336>
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
5756a: 4878 0001 pea 1 <ADD>
5756e: 2f2e fffc movel %fp@(-4),%sp@-
57572: 486e fff2 pea %fp@(-14)
57576: 2f0a movel %a2,%sp@-
57578: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
5757e: 4fef 0010 lea %sp@(16),%sp
57582: 4a80 tstl %d0
57584: 6f3c bles 575c2 <rtems_rfs_dir_del_entry+0x110> <== ALWAYS TAKEN
57586: 2c00 movel %d0,%d6 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
57588: 2f3c 4000 0000 movel #1073741824,%sp@- <== NOT EXECUTED
5758e: 42a7 clrl %sp@- <== NOT EXECUTED
57590: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57596: 508f addql #8,%sp <== NOT EXECUTED
57598: 4a00 tstb %d0 <== NOT EXECUTED
5759a: 6700 0254 beqw 577f0 <rtems_rfs_dir_del_entry+0x33e> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
5759e: 2f06 movel %d6,%sp@- <== NOT EXECUTED
575a0: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
575a6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
575a8: 2f06 movel %d6,%sp@- <== NOT EXECUTED
575aa: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
575ae: 4879 0006 d05c pea 6d05c <CSWTCH.1+0x9a2> <== NOT EXECUTED
575b4: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
575ba: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
575be: 6000 0230 braw 577f0 <rtems_rfs_dir_del_entry+0x33e> <== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
575c2: 4a2e ffa7 tstb %fp@(-89)
575c6: 660a bnes 575d2 <rtems_rfs_dir_del_entry+0x120> <== NEVER TAKEN
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
575c8: 2207 movel %d7,%d1
575ca: 4c6a 1005 0008 remul %a2@(8),%d5,%d1
575d0: 6002 bras 575d4 <rtems_rfs_dir_del_entry+0x122>
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
eoffset = 0;
575d2: 4285 clrl %d5 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
575d4: 206e fff8 moveal %fp@(-8),%a0
575d8: 2240 moveal %d0,%a1
575da: 2668 001e moveal %a0@(30),%a3
575de: d7c5 addal %d5,%a3
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
575e0: 222a 0008 movel %a2@(8),%d1
575e4: 2041 moveal %d1,%a0
575e6: 41e8 fff6 lea %a0@(-10),%a0
575ea: 6000 01d0 braw 577bc <rtems_rfs_dir_del_entry+0x30a>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
575ee: 4283 clrl %d3
575f0: 162b 0008 moveb %a3@(8),%d3
575f4: 4280 clrl %d0
575f6: 102b 0009 moveb %a3@(9),%d0
575fa: e18b lsll #8,%d3
eino = rtems_rfs_dir_entry_ino (entry);
575fc: 1813 moveb %a3@,%d4
575fe: 1c2b 0001 moveb %a3@(1),%d6
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
57602: 8680 orl %d0,%d3
eino = rtems_rfs_dir_entry_ino (entry);
57604: 102b 0002 moveb %a3@(2),%d0
57608: 1d40 ffa3 moveb %d0,%fp@(-93)
5760c: 102b 0003 moveb %a3@(3),%d0
57610: 1d40 ffa2 moveb %d0,%fp@(-94)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
57614: 0c83 0000 ffff cmpil #65535,%d3
5761a: 6700 01a6 beqw 577c2 <rtems_rfs_dir_del_entry+0x310>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
5761e: 7018 moveq #24,%d0
57620: 0286 0000 00ff andil #255,%d6
57626: e1ac lsll %d0,%d4
57628: 4280 clrl %d0
5762a: 102e ffa2 moveb %fp@(-94),%d0
5762e: 4846 swap %d6
57630: 4246 clrw %d6
57632: 8886 orl %d6,%d4
57634: 8880 orl %d0,%d4
57636: 102e ffa3 moveb %fp@(-93),%d0
5763a: e188 lsll #8,%d0
5763c: 8880 orl %d0,%d4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
5763e: 700a moveq #10,%d0
57640: b083 cmpl %d3,%d0
57642: 6c10 bges 57654 <rtems_rfs_dir_del_entry+0x1a2> <== NEVER TAKEN
57644: b6aa 0018 cmpl %a2@(24),%d3
57648: 640a bccs 57654 <rtems_rfs_dir_del_entry+0x1a2> <== NEVER TAKEN
5764a: 4a84 tstl %d4
5764c: 6706 beqs 57654 <rtems_rfs_dir_del_entry+0x1a2> <== NEVER TAKEN
5764e: b8aa 0010 cmpl %a2@(16),%d4
57652: 6338 blss 5768c <rtems_rfs_dir_del_entry+0x1da> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
57654: 2f3c 4000 0000 movel #1073741824,%sp@- <== NOT EXECUTED
5765a: 42a7 clrl %sp@- <== NOT EXECUTED
5765c: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57662: 508f addql #8,%sp <== NOT EXECUTED
57664: 4a00 tstb %d0 <== NOT EXECUTED
57666: 6700 01b0 beqw 57818 <rtems_rfs_dir_del_entry+0x366> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
5766a: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5766c: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
57670: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57672: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57674: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
57678: 4879 0006 d0a3 pea 6d0a3 <CSWTCH.1+0x9e9> <== NOT EXECUTED
5767e: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57684: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
57688: 6000 018e braw 57818 <rtems_rfs_dir_del_entry+0x366> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
5768c: b88d cmpl %a5,%d4
5768e: 6600 0122 bnew 577b2 <rtems_rfs_dir_del_entry+0x300>
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
57692: 2005 movel %d5,%d0
57694: 2801 movel %d1,%d4
57696: d083 addl %d3,%d0
57698: 9880 subl %d0,%d4
memmove (entry, entry + elength, remaining);
5769a: 2f04 movel %d4,%sp@-
5769c: 4873 3800 pea %a3@(00000000,%d3:l)
576a0: 2f0b movel %a3,%sp@-
576a2: 4eb9 0005 bffc jsr 5bffc <memmove>
memset (entry + remaining, 0xff, elength);
576a8: 2f03 movel %d3,%sp@-
576aa: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
576ae: 4873 4800 pea %a3@(00000000,%d4:l)
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
576b2: 4283 clrl %d3
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
memmove (entry, entry + elength, remaining);
memset (entry + remaining, 0xff, elength);
576b4: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
576ba: 4280 clrl %d0
576bc: 162b 0008 moveb %a3@(8),%d3
576c0: 102b 0009 moveb %a3@(9),%d0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
576c4: 2f3c 4000 0000 movel #1073741824,%sp@-
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
576ca: e18b lsll #8,%d3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
576cc: 42a7 clrl %sp@-
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
576ce: 8680 orl %d0,%d3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
576d0: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
576d6: 4fef 0020 lea %sp@(32),%sp
576da: 4a00 tstb %d0
576dc: 6744 beqs 57722 <rtems_rfs_dir_del_entry+0x270> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-del-entry: "
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
576de: 222e ffb6 movel %fp@(-74),%d1 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
576e2: 660c bnes 576f0 <rtems_rfs_dir_del_entry+0x23e> <== NOT EXECUTED
576e4: 203c 0006 be89 movel #441993,%d0 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
576ea: 4aae ffae tstl %fp@(-82) <== NOT EXECUTED
576ee: 6716 beqs 57706 <rtems_rfs_dir_del_entry+0x254> <== NOT EXECUTED
576f0: 206e ffae moveal %fp@(-82),%a0 <== NOT EXECUTED
576f4: 5388 subql #1,%a0 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
576f6: 203c 0006 c27c movel #443004,%d0 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
576fc: b1c1 cmpal %d1,%a0 <== NOT EXECUTED
576fe: 6606 bnes 57706 <rtems_rfs_dir_del_entry+0x254> <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
57700: 203c 0006 be89 movel #441993,%d0 <== NOT EXECUTED
57706: 2f00 movel %d0,%sp@- <== NOT EXECUTED
57708: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5770a: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
5770e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57710: 2f0d movel %a5,%sp@- <== NOT EXECUTED
57712: 4879 0006 d0ef pea 6d0ef <CSWTCH.1+0xa35> <== NOT EXECUTED
57718: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5771e: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
57722: 0c83 0000 ffff cmpil #65535,%d3
57728: 6666 bnes 57790 <rtems_rfs_dir_del_entry+0x2de>
5772a: 4a85 tstl %d5
5772c: 6662 bnes 57790 <rtems_rfs_dir_del_entry+0x2de> <== ALWAYS TAKEN
(eoffset == 0) && rtems_rfs_block_map_last (&map))
5772e: 202e ffb6 movel %fp@(-74),%d0 <== NOT EXECUTED
57732: 6606 bnes 5773a <rtems_rfs_dir_del_entry+0x288> <== NOT EXECUTED
57734: 4aae ffae tstl %fp@(-82) <== NOT EXECUTED
57738: 670a beqs 57744 <rtems_rfs_dir_del_entry+0x292> <== NOT EXECUTED
5773a: 222e ffae movel %fp@(-82),%d1 <== NOT EXECUTED
5773e: 5381 subql #1,%d1 <== NOT EXECUTED
57740: b280 cmpl %d0,%d1 <== NOT EXECUTED
57742: 664c bnes 57790 <rtems_rfs_dir_del_entry+0x2de> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
57744: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
57748: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
5774c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5774e: 4eb9 0005 6172 jsr 56172 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
57754: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
(eoffset == 0) && rtems_rfs_block_map_last (&map))
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
57758: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
5775a: 6f34 bles 57790 <rtems_rfs_dir_del_entry+0x2de> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
5775c: 2f3c 4000 0000 movel #1073741824,%sp@- <== NOT EXECUTED
57762: 42a7 clrl %sp@- <== NOT EXECUTED
57764: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5776a: 508f addql #8,%sp <== NOT EXECUTED
5776c: 4a00 tstb %d0 <== NOT EXECUTED
5776e: 6720 beqs 57790 <rtems_rfs_dir_del_entry+0x2de> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
57770: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57772: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
57778: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5777a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5777c: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
57780: 4879 0006 d14e pea 6d14e <CSWTCH.1+0xa94> <== NOT EXECUTED
57786: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5778c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
57790: 486e fff2 pea %fp@(-14)
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
57794: 7201 moveq #1,%d1
rtems_rfs_buffer_handle_close (fs, &buffer);
57796: 2f0a movel %a2,%sp@-
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
57798: 1d41 fff2 moveb %d1,%fp@(-14)
rtems_rfs_buffer_handle_close (fs, &buffer);
5779c: 4eba f512 jsr %pc@(56cb0 <rtems_rfs_buffer_handle_close>)
rtems_rfs_block_map_close (fs, &map);
577a0: 486e ffa8 pea %fp@(-88)
577a4: 2f0a movel %a2,%sp@-
577a6: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close>
return 0;
577ac: 4fef 0010 lea %sp@(16),%sp
577b0: 605a bras 5780c <rtems_rfs_dir_del_entry+0x35a>
}
if (!search)
577b2: 4a2e ffa7 tstb %fp@(-89) <== NOT EXECUTED
577b6: 6760 beqs 57818 <rtems_rfs_dir_del_entry+0x366> <== NOT EXECUTED
{
rc = EIO;
break;
}
entry += elength;
577b8: d7c3 addal %d3,%a3 <== NOT EXECUTED
eoffset += elength;
577ba: da83 addl %d3,%d5 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
577bc: b1c5 cmpal %d5,%a0
577be: 6200 fe2e bhiw 575ee <rtems_rfs_dir_del_entry+0x13c>
577c2: 2009 movel %a1,%d0 <== NOT EXECUTED
entry += elength;
eoffset += elength;
}
if (rc == 0)
577c4: 6620 bnes 577e6 <rtems_rfs_dir_del_entry+0x334> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
577c6: 486e fffc pea %fp@(-4) <== NOT EXECUTED
577ca: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
577ce: 2f0a movel %a2,%sp@- <== NOT EXECUTED
577d0: 4eb9 0005 5e84 jsr 55e84 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
577d6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
eoffset += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
577da: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc == ENXIO)
577dc: 7006 moveq #6,%d0 <== NOT EXECUTED
577de: b082 cmpl %d2,%d0 <== NOT EXECUTED
577e0: 6606 bnes 577e8 <rtems_rfs_dir_del_entry+0x336> <== NOT EXECUTED
rc = ENOENT;
577e2: 7402 moveq #2,%d2 <== NOT EXECUTED
577e4: 6008 bras 577ee <rtems_rfs_dir_del_entry+0x33c> <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
577e6: 2400 movel %d0,%d2 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
577e8: 4a82 tstl %d2
577ea: 6700 fd7e beqw 5756a <rtems_rfs_dir_del_entry+0xb8>
577ee: 2c02 movel %d2,%d6 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
577f0: 486e fff2 pea %fp@(-14) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
577f4: 2406 movel %d6,%d2 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
577f6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
577f8: 4eba f4b6 jsr %pc@(56cb0 <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
577fc: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
57800: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57802: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
57808: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
5780c: 2002 movel %d2,%d0
5780e: 4cee 3cfc ff78 moveml %fp@(-136),%d2-%d7/%a2-%a5
57814: 4e5e unlk %fp
57816: 4e75 rts
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
57818: 7005 moveq #5,%d0 <== NOT EXECUTED
5781a: 60ca bras 577e6 <rtems_rfs_dir_del_entry+0x334> <== NOT EXECUTED
00057b5a <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
57b5a: 4e56 ff7c linkw %fp,#-132 <== NOT EXECUTED
57b5e: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
57b62: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
57b68: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
57b6c: 42a7 clrl %sp@- <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
57b6e: 266e 000c moveal %fp@(12),%a3 <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
57b72: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57b78: 508f addql #8,%sp <== NOT EXECUTED
57b7a: 4a00 tstb %d0 <== NOT EXECUTED
57b7c: 6712 beqs 57b90 <rtems_rfs_dir_empty+0x36> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
57b7e: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
57b82: 4879 0006 d26e pea 6d26e <CSWTCH.1+0xbb4> <== NOT EXECUTED
57b88: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57b8e: 508f addql #8,%sp <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
57b90: 260e movel %fp,%d3 <== NOT EXECUTED
57b92: 0683 ffff ffa8 addil #-88,%d3 <== NOT EXECUTED
57b98: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57b9a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
57b9c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57b9e: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
57ba4: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
57ba8: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
57baa: 6e00 019a bgtw 57d46 <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
57bae: 280e movel %fp,%d4 <== NOT EXECUTED
57bb0: 5984 subql #4,%d4 <== NOT EXECUTED
57bb2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57bb4: 42a7 clrl %sp@- <== NOT EXECUTED
57bb6: 42a7 clrl %sp@- <== NOT EXECUTED
57bb8: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57bba: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57bbc: 4eb9 0005 5e06 jsr 55e06 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
57bc2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
57bc6: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
57bc8: 6f10 bles 57bda <rtems_rfs_dir_empty+0x80> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
57bca: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57bcc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57bce: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
57bd4: 508f addql #8,%sp <== NOT EXECUTED
57bd6: 6000 016e braw 57d46 <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
57bda: 2e0e movel %fp,%d7 <== NOT EXECUTED
57bdc: 0687 ffff fff2 addil #-14,%d7 <== NOT EXECUTED
57be2: 2c3c 0005 66f8 movel #354040,%d6 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
57be8: 4bf9 0004 f5ec lea 4f5ec <rtems_rfs_trace>,%a5 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
57bee: 49f9 0005 c170 lea 5c170 <printf>,%a4 <== NOT EXECUTED
57bf4: 4200 clrb %d0 <== NOT EXECUTED
handle->bnum = 0;
57bf6: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
57bfa: 1d40 fff2 moveb %d0,%fp@(-14) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
57bfe: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
57c02: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
57c06: 2046 moveal %d6,%a0 <== NOT EXECUTED
57c08: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
57c0c: 2f07 movel %d7,%sp@- <== NOT EXECUTED
57c0e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57c10: 4e90 jsr %a0@ <== NOT EXECUTED
if (rc > 0)
57c12: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
57c16: 4a80 tstl %d0 <== NOT EXECUTED
57c18: 6e00 0110 bgtw 57d2a <rtems_rfs_dir_empty+0x1d0> <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
57c1c: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
offset = 0;
57c20: 4285 clrl %d5 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
57c22: 226a 0008 moveal %a2@(8),%a1 <== NOT EXECUTED
57c26: 43e9 fff6 lea %a1@(-10),%a1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
57c2a: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
57c2e: 6000 00c2 braw 57cf2 <rtems_rfs_dir_empty+0x198> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
57c32: 4283 clrl %d3 <== NOT EXECUTED
57c34: 1628 0008 moveb %a0@(8),%d3 <== NOT EXECUTED
57c38: 4281 clrl %d1 <== NOT EXECUTED
57c3a: 1228 0009 moveb %a0@(9),%d1 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
57c3e: 1428 0002 moveb %a0@(2),%d2 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
57c42: e18b lsll #8,%d3 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
57c44: 1810 moveb %a0@,%d4 <== NOT EXECUTED
57c46: 1d42 ffa7 moveb %d2,%fp@(-89) <== NOT EXECUTED
57c4a: 1428 0003 moveb %a0@(3),%d2 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
57c4e: 8681 orl %d1,%d3 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
57c50: 1d42 ffa6 moveb %d2,%fp@(-90) <== NOT EXECUTED
57c54: 1228 0001 moveb %a0@(1),%d1 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
57c58: 0c83 0000 ffff cmpil #65535,%d3 <== NOT EXECUTED
57c5e: 6700 0098 beqw 57cf8 <rtems_rfs_dir_empty+0x19e> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
57c62: 7418 moveq #24,%d2 <== NOT EXECUTED
57c64: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
57c6a: e5ac lsll %d2,%d4 <== NOT EXECUTED
57c6c: 4282 clrl %d2 <== NOT EXECUTED
57c6e: 142e ffa6 moveb %fp@(-90),%d2 <== NOT EXECUTED
57c72: 4841 swap %d1 <== NOT EXECUTED
57c74: 4241 clrw %d1 <== NOT EXECUTED
57c76: 8881 orl %d1,%d4 <== NOT EXECUTED
57c78: 4281 clrl %d1 <== NOT EXECUTED
57c7a: 122e ffa7 moveb %fp@(-89),%d1 <== NOT EXECUTED
57c7e: 8882 orl %d2,%d4 <== NOT EXECUTED
57c80: e189 lsll #8,%d1 <== NOT EXECUTED
57c82: 8881 orl %d1,%d4 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
57c84: 720a moveq #10,%d1 <== NOT EXECUTED
57c86: b283 cmpl %d3,%d1 <== NOT EXECUTED
57c88: 6c10 bges 57c9a <rtems_rfs_dir_empty+0x140> <== NOT EXECUTED
57c8a: b6aa 0018 cmpl %a2@(24),%d3 <== NOT EXECUTED
57c8e: 640a bccs 57c9a <rtems_rfs_dir_empty+0x140> <== NOT EXECUTED
57c90: 4a84 tstl %d4 <== NOT EXECUTED
57c92: 6706 beqs 57c9a <rtems_rfs_dir_empty+0x140> <== NOT EXECUTED
57c94: b8aa 0010 cmpl %a2@(16),%d4 <== NOT EXECUTED
57c98: 6326 blss 57cc0 <rtems_rfs_dir_empty+0x166> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
57c9a: 42a7 clrl %sp@- <== NOT EXECUTED
57c9c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
57ca0: 4e95 jsr %a5@ <== NOT EXECUTED
57ca2: 508f addql #8,%sp <== NOT EXECUTED
57ca4: 4a00 tstb %d0 <== NOT EXECUTED
57ca6: 6750 beqs 57cf8 <rtems_rfs_dir_empty+0x19e> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
57ca8: 2f05 movel %d5,%sp@- <== NOT EXECUTED
57caa: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57cac: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57cae: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
57cb2: 4879 0006 d28d pea 6d28d <CSWTCH.1+0xbd3> <== NOT EXECUTED
57cb8: 4e94 jsr %a4@ <== NOT EXECUTED
57cba: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
57cbe: 6038 bras 57cf8 <rtems_rfs_dir_empty+0x19e> <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
57cc0: 740b moveq #11,%d2 <== NOT EXECUTED
57cc2: b483 cmpl %d3,%d2 <== NOT EXECUTED
57cc4: 660c bnes 57cd2 <rtems_rfs_dir_empty+0x178> <== NOT EXECUTED
57cc6: 4281 clrl %d1 <== NOT EXECUTED
57cc8: 1228 000a moveb %a0@(10),%d1 <== NOT EXECUTED
57ccc: 143c 002e moveb #46,%d2 <== NOT EXECUTED
57cd0: 6018 bras 57cea <rtems_rfs_dir_empty+0x190> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
57cd2: 720c moveq #12,%d1 <== NOT EXECUTED
57cd4: b283 cmpl %d3,%d1 <== NOT EXECUTED
57cd6: 6648 bnes 57d20 <rtems_rfs_dir_empty+0x1c6> <== NOT EXECUTED
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
57cd8: 4281 clrl %d1 <== NOT EXECUTED
57cda: 1228 000a moveb %a0@(10),%d1 <== NOT EXECUTED
57cde: 742e moveq #46,%d2 <== NOT EXECUTED
57ce0: b481 cmpl %d1,%d2 <== NOT EXECUTED
57ce2: 663c bnes 57d20 <rtems_rfs_dir_empty+0x1c6> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
57ce4: 4281 clrl %d1 <== NOT EXECUTED
57ce6: 1228 000b moveb %a0@(11),%d1 <== NOT EXECUTED
57cea: b481 cmpl %d1,%d2 <== NOT EXECUTED
57cec: 6632 bnes 57d20 <rtems_rfs_dir_empty+0x1c6> <== NOT EXECUTED
{
empty = false;
break;
}
entry += elength;
57cee: d1c3 addal %d3,%a0 <== NOT EXECUTED
offset += elength;
57cf0: da83 addl %d3,%d5 <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
57cf2: b3c5 cmpal %d5,%a1 <== NOT EXECUTED
57cf4: 6200 ff3c bhiw 57c32 <rtems_rfs_dir_empty+0xd8> <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
57cf8: 486e fffc pea %fp@(-4) <== NOT EXECUTED
57cfc: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
57d00: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57d02: 4eb9 0005 5e84 jsr 55e84 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc > 0)
57d08: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57d0c: 4a80 tstl %d0 <== NOT EXECUTED
57d0e: 6f00 fef2 blew 57c02 <rtems_rfs_dir_empty+0xa8> <== NOT EXECUTED
57d12: 2400 movel %d0,%d2 <== NOT EXECUTED
{
if (rc == ENXIO)
57d14: 7006 moveq #6,%d0 <== NOT EXECUTED
57d16: b082 cmpl %d2,%d0 <== NOT EXECUTED
57d18: 56c0 sne %d0 <== NOT EXECUTED
57d1a: 49c0 extbl %d0 <== NOT EXECUTED
57d1c: c480 andl %d0,%d2 <== NOT EXECUTED
57d1e: 600c bras 57d2c <rtems_rfs_dir_empty+0x1d2> <== NOT EXECUTED
57d20: 2400 movel %d0,%d2 <== NOT EXECUTED
break;
}
}
}
if ((rc == 0) && !empty)
57d22: 6608 bnes 57d2c <rtems_rfs_dir_empty+0x1d2> <== NOT EXECUTED
rc = ENOTEMPTY;
57d24: 143c 005a moveb #90,%d2 <== NOT EXECUTED
57d28: 6002 bras 57d2c <rtems_rfs_dir_empty+0x1d2> <== NOT EXECUTED
57d2a: 2400 movel %d0,%d2 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
57d2c: 486e fff2 pea %fp@(-14) <== NOT EXECUTED
57d30: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57d32: 4eba ef7c jsr %pc@(56cb0 <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
57d36: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
57d3a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57d3c: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
57d42: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
57d46: 2002 movel %d2,%d0 <== NOT EXECUTED
57d48: 4cee 3cfc ff7c moveml %fp@(-132),%d2-%d7/%a2-%a5 <== NOT EXECUTED
57d4e: 4e5e unlk %fp <== NOT EXECUTED
...
0005b400 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
5b400: 4e56 ffec linkw %fp,#-20
break;
case 0 : return c; /* zero length requires no mixing */
}
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
5b404: 206e 0008 moveal %fp@(8),%a0
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
5b408: 48d7 007c moveml %d2-%d6,%sp@
5b40c: 282e 000c movel %fp@(12),%d4
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
5b410: 2004 movel %d4,%d0
5b412: 0680 dfdf 169f addil #-539027809,%d0
5b418: 2200 movel %d0,%d1
5b41a: 2240 moveal %d0,%a1
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
5b41c: 6000 00f2 braw 5b510 <rtems_rfs_dir_hash+0x110>
{
a += k[0];
5b420: 4282 clrl %d2
5b422: 1410 moveb %a0@,%d2
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
5b424: 4283 clrl %d3
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
5b426: 43f1 2800 lea %a1@(00000000,%d2:l),%a1
a += ((uint32_t)k[1])<<8;
5b42a: 1428 0001 moveb %a0@(1),%d2
a += ((uint32_t)k[2])<<16;
5b42e: 1628 0002 moveb %a0@(2),%d3
a += ((uint32_t)k[3])<<24;
5b432: 7a18 moveq #24,%d5
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
5b434: 7c1c moveq #28,%d6
length -= 12;
5b436: 0684 ffff fff4 addil #-12,%d4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
5b43c: e18a lsll #8,%d2
a += ((uint32_t)k[2])<<16;
5b43e: 4843 swap %d3
5b440: 4243 clrw %d3
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
5b442: d489 addl %a1,%d2
a += ((uint32_t)k[2])<<16;
5b444: d483 addl %d3,%d2
a += ((uint32_t)k[3])<<24;
5b446: 4283 clrl %d3
5b448: 1628 0003 moveb %a0@(3),%d3
5b44c: ebab lsll %d5,%d3
5b44e: d483 addl %d3,%d2
b += k[4];
5b450: 4283 clrl %d3
5b452: 1628 0004 moveb %a0@(4),%d3
5b456: d283 addl %d3,%d1
b += ((uint32_t)k[5])<<8;
5b458: 1628 0005 moveb %a0@(5),%d3
5b45c: e18b lsll #8,%d3
5b45e: d283 addl %d3,%d1
b += ((uint32_t)k[6])<<16;
5b460: 4283 clrl %d3
5b462: 1628 0006 moveb %a0@(6),%d3
5b466: 4843 swap %d3
5b468: 4243 clrw %d3
5b46a: d283 addl %d3,%d1
b += ((uint32_t)k[7])<<24;
5b46c: 4283 clrl %d3
5b46e: 1628 0007 moveb %a0@(7),%d3
5b472: ebab lsll %d5,%d3
5b474: d283 addl %d3,%d1
c += k[8];
5b476: 4283 clrl %d3
5b478: 1628 0008 moveb %a0@(8),%d3
5b47c: d083 addl %d3,%d0
c += ((uint32_t)k[9])<<8;
5b47e: 1628 0009 moveb %a0@(9),%d3
5b482: e18b lsll #8,%d3
5b484: d083 addl %d3,%d0
c += ((uint32_t)k[10])<<16;
5b486: 4283 clrl %d3
5b488: 1628 000a moveb %a0@(10),%d3
5b48c: 4843 swap %d3
5b48e: 4243 clrw %d3
5b490: d083 addl %d3,%d0
c += ((uint32_t)k[11])<<24;
5b492: 4283 clrl %d3
5b494: 1628 000b moveb %a0@(11),%d3
mix(a,b,c);
length -= 12;
k += 12;
5b498: 41e8 000c lea %a0@(12),%a0
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
5b49c: ebab lsll %d5,%d3
5b49e: d083 addl %d3,%d0
mix(a,b,c);
5b4a0: 2600 movel %d0,%d3
5b4a2: 2a00 movel %d0,%d5
5b4a4: ecad lsrl %d6,%d5
5b4a6: 9480 subl %d0,%d2
5b4a8: 1c3c 001a moveb #26,%d6
5b4ac: e98b lsll #4,%d3
5b4ae: 8685 orl %d5,%d3
5b4b0: 2a00 movel %d0,%d5
5b4b2: da81 addl %d1,%d5
5b4b4: b782 eorl %d3,%d2
5b4b6: 2002 movel %d2,%d0
5b4b8: 2602 movel %d2,%d3
5b4ba: ecab lsrl %d6,%d3
5b4bc: 9282 subl %d2,%d1
5b4be: 1c3c 0018 moveb #24,%d6
5b4c2: d485 addl %d5,%d2
5b4c4: ed88 lsll #6,%d0
5b4c6: 8083 orl %d3,%d0
5b4c8: b380 eorl %d1,%d0
5b4ca: 2200 movel %d0,%d1
5b4cc: 2600 movel %d0,%d3
5b4ce: ecab lsrl %d6,%d3
5b4d0: 9a80 subl %d0,%d5
5b4d2: d082 addl %d2,%d0
5b4d4: 1c3c 000d moveb #13,%d6
5b4d8: e189 lsll #8,%d1
5b4da: 8283 orl %d3,%d1
5b4dc: bb81 eorl %d5,%d1
5b4de: 7a13 moveq #19,%d5
5b4e0: 2601 movel %d1,%d3
5b4e2: 9481 subl %d1,%d2
5b4e4: 4843 swap %d3
5b4e6: b583 eorl %d2,%d3
5b4e8: 2401 movel %d1,%d2
5b4ea: d480 addl %d0,%d2
5b4ec: 2203 movel %d3,%d1
5b4ee: 9083 subl %d3,%d0
5b4f0: 2243 moveal %d3,%a1
5b4f2: d3c2 addal %d2,%a1
5b4f4: eba9 lsll %d5,%d1
5b4f6: 2a03 movel %d3,%d5
5b4f8: ecad lsrl %d6,%d5
5b4fa: 8285 orl %d5,%d1
5b4fc: 7a1c moveq #28,%d5
5b4fe: b181 eorl %d0,%d1
5b500: 2001 movel %d1,%d0
5b502: 2601 movel %d1,%d3
5b504: eaab lsrl %d5,%d3
5b506: 9481 subl %d1,%d2
5b508: d289 addl %a1,%d1
5b50a: e988 lsll #4,%d0
5b50c: 8083 orl %d3,%d0
5b50e: b580 eorl %d2,%d0
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
5b510: 7c0c moveq #12,%d6
5b512: bc84 cmpl %d4,%d6
5b514: 6500 ff0a bcsw 5b420 <rtems_rfs_dir_hash+0x20>
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
5b518: 5384 subql #1,%d4
5b51a: 740b moveq #11,%d2
5b51c: b484 cmpl %d4,%d2
5b51e: 6500 0118 bcsw 5b638 <rtems_rfs_dir_hash+0x238>
5b522: 343b 4a08 movew %pc@(5b52c <rtems_rfs_dir_hash+0x12c>,%d4:l:2),%d2
5b526: 48c2 extl %d2
5b528: 4efb 2802 jmp %pc@(5b52c <rtems_rfs_dir_hash+0x12c>,%d2:l)
5b52c: 0090 0086 007a oril #8781946,%d0 <== NOT EXECUTED
5b532: 006c .short 0x006c <== NOT EXECUTED
5b534: 0064 .short 0x0064 <== NOT EXECUTED
5b536: 005a .short 0x005a <== NOT EXECUTED
5b538: 004e .short 0x004e <== NOT EXECUTED
5b53a: 0042 .short 0x0042 <== NOT EXECUTED
5b53c: 003a .short 0x003a <== NOT EXECUTED
5b53e: 0030 .short 0x0030 <== NOT EXECUTED
5b540: 0024 .short 0x0024 <== NOT EXECUTED
5b542: 0018 .short 0x0018 <== NOT EXECUTED
{
case 12: c+=((uint32_t)k[11])<<24;
5b544: 4282 clrl %d2
5b546: 1428 000b moveb %a0@(11),%d2
5b54a: 7618 moveq #24,%d3
5b54c: e7aa lsll %d3,%d2
5b54e: d082 addl %d2,%d0
case 11: c+=((uint32_t)k[10])<<16;
5b550: 4282 clrl %d2
5b552: 1428 000a moveb %a0@(10),%d2
5b556: 4842 swap %d2
5b558: 4242 clrw %d2
5b55a: d082 addl %d2,%d0
case 10: c+=((uint32_t)k[9])<<8;
5b55c: 4282 clrl %d2
5b55e: 1428 0009 moveb %a0@(9),%d2
5b562: e18a lsll #8,%d2
5b564: d082 addl %d2,%d0
case 9 : c+=k[8];
5b566: 4282 clrl %d2
5b568: 1428 0008 moveb %a0@(8),%d2
5b56c: d082 addl %d2,%d0
case 8 : b+=((uint32_t)k[7])<<24;
5b56e: 4282 clrl %d2
5b570: 1428 0007 moveb %a0@(7),%d2
5b574: 7818 moveq #24,%d4
5b576: e9aa lsll %d4,%d2
5b578: d282 addl %d2,%d1
case 7 : b+=((uint32_t)k[6])<<16;
5b57a: 4282 clrl %d2
5b57c: 1428 0006 moveb %a0@(6),%d2
5b580: 4842 swap %d2
5b582: 4242 clrw %d2
5b584: d282 addl %d2,%d1
case 6 : b+=((uint32_t)k[5])<<8;
5b586: 4282 clrl %d2
5b588: 1428 0005 moveb %a0@(5),%d2
5b58c: e18a lsll #8,%d2
5b58e: d282 addl %d2,%d1
case 5 : b+=k[4];
5b590: 4282 clrl %d2
5b592: 1428 0004 moveb %a0@(4),%d2
5b596: d282 addl %d2,%d1
case 4 : a+=((uint32_t)k[3])<<24;
5b598: 4282 clrl %d2
5b59a: 1428 0003 moveb %a0@(3),%d2
5b59e: 7a18 moveq #24,%d5
5b5a0: ebaa lsll %d5,%d2
5b5a2: 43f1 2800 lea %a1@(00000000,%d2:l),%a1
case 3 : a+=((uint32_t)k[2])<<16;
5b5a6: 4282 clrl %d2
5b5a8: 1428 0002 moveb %a0@(2),%d2
5b5ac: 4842 swap %d2
5b5ae: 4242 clrw %d2
5b5b0: d3c2 addal %d2,%a1
case 2 : a+=((uint32_t)k[1])<<8;
5b5b2: 4282 clrl %d2
5b5b4: 1428 0001 moveb %a0@(1),%d2
5b5b8: e18a lsll #8,%d2
5b5ba: d3c2 addal %d2,%a1
break;
case 0 : return c;
}
}
final(a,b,c);
5b5bc: 2801 movel %d1,%d4
5b5be: 7a0e moveq #14,%d5
5b5c0: 2601 movel %d1,%d3
5b5c2: 7c12 moveq #18,%d6
5b5c4: ecab lsrl %d6,%d3
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
5b5c6: 4282 clrl %d2
break;
case 0 : return c;
}
}
final(a,b,c);
5b5c8: 1c3c 000b moveb #11,%d6
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
5b5cc: 1410 moveb %a0@,%d2
5b5ce: d489 addl %a1,%d2
break;
case 0 : return c;
}
}
final(a,b,c);
5b5d0: ebac lsll %d5,%d4
5b5d2: b380 eorl %d1,%d0
5b5d4: 1a3c 0015 moveb #21,%d5
5b5d8: 8684 orl %d4,%d3
5b5da: 9083 subl %d3,%d0
5b5dc: 2600 movel %d0,%d3
5b5de: 2800 movel %d0,%d4
5b5e0: eaac lsrl %d5,%d4
5b5e2: 1a3c 001c moveb #28,%d5
5b5e6: edab lsll %d6,%d3
5b5e8: b182 eorl %d0,%d2
5b5ea: 1c3c 0019 moveb #25,%d6
5b5ee: 8684 orl %d4,%d3
5b5f0: 9483 subl %d3,%d2
5b5f2: 2602 movel %d2,%d3
5b5f4: 2802 movel %d2,%d4
5b5f6: ee8c lsrl #7,%d4
5b5f8: edab lsll %d6,%d3
5b5fa: b581 eorl %d2,%d1
5b5fc: 1c3c 000e moveb #14,%d6
5b600: 8684 orl %d4,%d3
5b602: 9283 subl %d3,%d1
5b604: 2601 movel %d1,%d3
5b606: 4843 swap %d3
5b608: b380 eorl %d1,%d0
5b60a: 9083 subl %d3,%d0
5b60c: 2600 movel %d0,%d3
5b60e: 2800 movel %d0,%d4
5b610: eaac lsrl %d5,%d4
5b612: 1a3c 0018 moveb #24,%d5
5b616: e98b lsll #4,%d3
5b618: b182 eorl %d0,%d2
5b61a: 8684 orl %d4,%d3
5b61c: 7812 moveq #18,%d4
5b61e: 9483 subl %d3,%d2
5b620: 2602 movel %d2,%d3
5b622: b581 eorl %d2,%d1
5b624: edab lsll %d6,%d3
5b626: e8aa lsrl %d4,%d2
5b628: 8682 orl %d2,%d3
5b62a: 9283 subl %d3,%d1
5b62c: 2401 movel %d1,%d2
5b62e: b380 eorl %d1,%d0
5b630: ebaa lsll %d5,%d2
5b632: e089 lsrl #8,%d1
5b634: 8481 orl %d1,%d2
5b636: 9082 subl %d2,%d0
return c;
}
5b638: 4cd7 007c moveml %sp@,%d2-%d6
5b63c: 4e5e unlk %fp <== NOT EXECUTED
00056cda <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
56cda: 4e56 ff70 linkw %fp,#-144
56cde: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56ce2: 2f3c 0400 0000 movel #67108864,%sp@-
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
56ce8: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56cec: 42a7 clrl %sp@-
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
56cee: 266e 000c moveal %fp@(12),%a3
56cf2: 2e2e 0014 movel %fp@(20),%d7
56cf6: 286e 0018 moveal %fp@(24),%a4
56cfa: 2a6e 001c moveal %fp@(28),%a5
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56cfe: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56d04: 508f addql #8,%sp
56d06: 4a00 tstb %d0
56d08: 6746 beqs 56d50 <rtems_rfs_dir_lookup_ino+0x76> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
56d0a: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
56d0e: 4282 clrl %d2 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
56d10: 4879 0006 cc2e pea 6cc2e <CSWTCH.1+0x574> <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
56d16: 283c 0005 c1b0 movel #377264,%d4 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
56d1c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56d22: 262e 0010 movel %fp@(16),%d3 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
56d26: 508f addql #8,%sp <== NOT EXECUTED
56d28: 6012 bras 56d3c <rtems_rfs_dir_lookup_ino+0x62> <== NOT EXECUTED
printf ("%c", name[c]);
56d2a: 2043 moveal %d3,%a0 <== NOT EXECUTED
56d2c: 5283 addql #1,%d3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
56d2e: 5282 addql #1,%d2 <== NOT EXECUTED
printf ("%c", name[c]);
56d30: 1018 moveb %a0@+,%d0 <== NOT EXECUTED
56d32: 2044 moveal %d4,%a0 <== NOT EXECUTED
56d34: 49c0 extbl %d0 <== NOT EXECUTED
56d36: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56d38: 4e90 jsr %a0@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
56d3a: 588f addql #4,%sp <== NOT EXECUTED
56d3c: be82 cmpl %d2,%d7 <== NOT EXECUTED
56d3e: 6eea bgts 56d2a <rtems_rfs_dir_lookup_ino+0x50> <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
56d40: 2f07 movel %d7,%sp@- <== NOT EXECUTED
56d42: 4879 0006 cc65 pea 6cc65 <CSWTCH.1+0x5ab> <== NOT EXECUTED
56d48: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56d4e: 508f addql #8,%sp <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
56d50: 4294 clrl %a4@
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
56d52: 260e movel %fp,%d3
56d54: 0683 ffff ffa8 addil #-88,%d3
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
56d5a: 4295 clrl %a5@
rc = rtems_rfs_block_map_open (fs, inode, &map);
56d5c: 2f03 movel %d3,%sp@-
56d5e: 2f0b movel %a3,%sp@-
56d60: 2f0a movel %a2,%sp@-
56d62: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open>
if (rc > 0)
56d68: 4fef 000c lea %sp@(12),%sp
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
56d6c: 2400 movel %d0,%d2
if (rc > 0)
56d6e: 6f3a bles 56daa <rtems_rfs_dir_lookup_ino+0xd0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56d70: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
56d76: 42a7 clrl %sp@- <== NOT EXECUTED
56d78: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
56d7e: 508f addql #8,%sp <== NOT EXECUTED
56d80: 4a00 tstb %d0 <== NOT EXECUTED
56d82: 6700 03a2 beqw 57126 <rtems_rfs_dir_lookup_ino+0x44c> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
56d86: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56d88: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
56d8e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56d90: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56d92: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
56d96: 4879 0006 cc6f pea 6cc6f <CSWTCH.1+0x5b5> <== NOT EXECUTED
56d9c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56da2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
56da6: 6000 037e braw 57126 <rtems_rfs_dir_lookup_ino+0x44c> <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
56daa: 2f07 movel %d7,%sp@-
56dac: 2f2e 0010 movel %fp@(16),%sp@-
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
56db0: 280e movel %fp,%d4
56db2: 5984 subql #4,%d4
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
56db4: 4200 clrb %d0
handle->bnum = 0;
56db6: 42ae fff4 clrl %fp@(-12)
handle->buffer = NULL;
56dba: 42ae fff8 clrl %fp@(-8)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
56dbe: 1d40 fff2 moveb %d0,%fp@(-14)
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
56dc2: 4eb9 0005 b400 jsr 5b400 <rtems_rfs_dir_hash>
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
56dc8: 2f04 movel %d4,%sp@-
56dca: 42a7 clrl %sp@-
56dcc: 42a7 clrl %sp@-
56dce: 2f03 movel %d3,%sp@-
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
56dd0: 2d40 ffa4 movel %d0,%fp@(-92)
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
56dd4: 2f0a movel %a2,%sp@-
56dd6: 4eb9 0005 5e06 jsr 55e06 <rtems_rfs_block_map_seek>
if (rc > 0)
56ddc: 4fef 001c lea %sp@(28),%sp
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
56de0: 2400 movel %d0,%d2
if (rc > 0)
56de2: 6f00 02d6 blew 570ba <rtems_rfs_dir_lookup_ino+0x3e0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56de6: 2f3c 0400 0000 movel #67108864,%sp@-
56dec: 42a7 clrl %sp@-
56dee: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56df4: 508f addql #8,%sp
56df6: 4a00 tstb %d0
56df8: 671c beqs 56e16 <rtems_rfs_dir_lookup_ino+0x13c> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
56dfa: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56dfc: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
56e02: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56e04: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56e06: 4879 0006 ccae pea 6ccae <CSWTCH.1+0x5f4> <== NOT EXECUTED
56e0c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56e12: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
56e16: 7206 moveq #6,%d1
56e18: b282 cmpl %d2,%d1
56e1a: 6600 02f0 bnew 5710c <rtems_rfs_dir_lookup_ino+0x432>
rc = ENOENT;
56e1e: 7402 moveq #2,%d2
56e20: 6000 02ea braw 5710c <rtems_rfs_dir_lookup_ino+0x432>
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56e24: 2046 moveal %d6,%a0
56e26: 2f3c 0400 0000 movel #67108864,%sp@-
56e2c: 42a7 clrl %sp@-
56e2e: 4e90 jsr %a0@
56e30: 508f addql #8,%sp
56e32: 4a00 tstb %d0
56e34: 6716 beqs 56e4c <rtems_rfs_dir_lookup_ino+0x172> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
56e36: 2f2e ffb6 movel %fp@(-74),%sp@- <== NOT EXECUTED
56e3a: 2045 moveal %d5,%a0 <== NOT EXECUTED
56e3c: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56e40: 4879 0006 cce8 pea 6cce8 <CSWTCH.1+0x62e> <== NOT EXECUTED
56e46: 4e90 jsr %a0@ <== NOT EXECUTED
56e48: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
56e4c: 4878 0001 pea 1 <ADD>
56e50: 2f2e fffc movel %fp@(-4),%sp@-
56e54: 486e fff2 pea %fp@(-14)
56e58: 2f0b movel %a3,%sp@-
56e5a: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
56e60: 4fef 0010 lea %sp@(16),%sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
56e64: 2800 movel %d0,%d4
if (rc > 0)
56e66: 6f40 bles 56ea8 <rtems_rfs_dir_lookup_ino+0x1ce> <== ALWAYS TAKEN
56e68: 244b moveal %a3,%a2 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56e6a: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
56e70: 42a7 clrl %sp@- <== NOT EXECUTED
56e72: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
56e78: 508f addql #8,%sp <== NOT EXECUTED
56e7a: 4a00 tstb %d0 <== NOT EXECUTED
56e7c: 6700 0264 beqw 570e2 <rtems_rfs_dir_lookup_ino+0x408> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
56e80: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56e82: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
56e88: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56e8a: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56e8c: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56e90: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56e94: 4879 0006 cd20 pea 6cd20 <CSWTCH.1+0x666> <== NOT EXECUTED
56e9a: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56ea0: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
56ea4: 6000 023c braw 570e2 <rtems_rfs_dir_lookup_ino+0x408> <== NOT EXECUTED
/*
* Search the block to see if the name matches. A hash of 0xffff or 0x0
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
56ea8: 206e fff8 moveal %fp@(-8),%a0
map.bpos.boff = 0;
56eac: 42ae ffba clrl %fp@(-70)
/*
* Search the block to see if the name matches. A hash of 0xffff or 0x0
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
56eb0: 2468 001e moveal %a0@(30),%a2
56eb4: 2d42 ff9a movel %d2,%fp@(-102)
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
56eb8: 6000 0190 braw 5704a <rtems_rfs_dir_lookup_ino+0x370>
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
56ebc: 4283 clrl %d3
56ebe: 162a 0008 moveb %a2@(8),%d3
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
56ec2: 102a 0004 moveb %a2@(4),%d0
elength = rtems_rfs_dir_entry_length (entry);
56ec6: e18b lsll #8,%d3
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
56ec8: 122a 0005 moveb %a2@(5),%d1
56ecc: 3240 moveaw %d0,%a1
56ece: 102a 0007 moveb %a2@(7),%d0
56ed2: 3041 moveaw %d1,%a0
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
56ed4: 7218 moveq #24,%d1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
56ed6: 1d40 ffa2 moveb %d0,%fp@(-94)
elength = rtems_rfs_dir_entry_length (entry);
56eda: 4280 clrl %d0
56edc: 102a 0009 moveb %a2@(9),%d0
56ee0: 8680 orl %d0,%d3
*ino = rtems_rfs_dir_entry_ino (entry);
56ee2: 1012 moveb %a2@,%d0
56ee4: e3a8 lsll %d1,%d0
56ee6: 4281 clrl %d1
56ee8: 122a 0001 moveb %a2@(1),%d1
56eec: 4841 swap %d1
56eee: 4241 clrw %d1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
56ef0: 142a 0006 moveb %a2@(6),%d2
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
56ef4: 8081 orl %d1,%d0
56ef6: 4281 clrl %d1
56ef8: 122a 0003 moveb %a2@(3),%d1
56efc: 8081 orl %d1,%d0
56efe: 122a 0002 moveb %a2@(2),%d1
56f02: e189 lsll #8,%d1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
56f04: 1d42 ffa3 moveb %d2,%fp@(-93)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
56f08: 8081 orl %d1,%d0
56f0a: 2a80 movel %d0,%a5@
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
56f0c: 0c83 0000 ffff cmpil #65535,%d3
56f12: 6700 0148 beqw 5705c <rtems_rfs_dir_lookup_ino+0x382>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
56f16: 740a moveq #10,%d2
56f18: b483 cmpl %d3,%d2
56f1a: 6c10 bges 56f2c <rtems_rfs_dir_lookup_ino+0x252> <== NEVER TAKEN
56f1c: b6ab 0018 cmpl %a3@(24),%d3
56f20: 640a bccs 56f2c <rtems_rfs_dir_lookup_ino+0x252> <== NEVER TAKEN
56f22: 4a80 tstl %d0
56f24: 6706 beqs 56f2c <rtems_rfs_dir_lookup_ino+0x252> <== NEVER TAKEN
56f26: b0ab 0010 cmpl %a3@(16),%d0
56f2a: 6332 blss 56f5e <rtems_rfs_dir_lookup_ino+0x284> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56f2c: 2046 moveal %d6,%a0 <== NOT EXECUTED
56f2e: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
56f34: 42a7 clrl %sp@- <== NOT EXECUTED
56f36: 4e90 jsr %a0@ <== NOT EXECUTED
56f38: 508f addql #8,%sp <== NOT EXECUTED
56f3a: 4a00 tstb %d0 <== NOT EXECUTED
56f3c: 6700 01f4 beqw 57132 <rtems_rfs_dir_lookup_ino+0x458> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
56f40: 2f2e ffba movel %fp@(-70),%sp@- <== NOT EXECUTED
56f44: 2045 moveal %d5,%a0 <== NOT EXECUTED
56f46: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
56f48: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56f4a: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56f4e: 4879 0006 cd62 pea 6cd62 <CSWTCH.1+0x6a8> <== NOT EXECUTED
56f54: 4e90 jsr %a0@ <== NOT EXECUTED
56f56: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
56f5a: 6000 01d6 braw 57132 <rtems_rfs_dir_lookup_ino+0x458> <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
56f5e: 7218 moveq #24,%d1
56f60: 2009 movel %a1,%d0
56f62: 3408 movew %a0,%d2
56f64: e3a8 lsll %d1,%d0
56f66: 4281 clrl %d1
56f68: 1202 moveb %d2,%d1
56f6a: 4841 swap %d1
56f6c: 4241 clrw %d1
56f6e: 8081 orl %d1,%d0
56f70: 4281 clrl %d1
56f72: 122e ffa2 moveb %fp@(-94),%d1
56f76: 8081 orl %d1,%d0
56f78: 122e ffa3 moveb %fp@(-93),%d1
56f7c: e189 lsll #8,%d1
56f7e: 8081 orl %d1,%d0
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
56f80: b0ae ffa4 cmpl %fp@(-92),%d0
56f84: 6600 00be bnew 57044 <rtems_rfs_dir_lookup_ino+0x36a>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
56f88: 2046 moveal %d6,%a0
56f8a: 2f3c 0800 0000 movel #134217728,%sp@-
56f90: 42a7 clrl %sp@-
56f92: 4e90 jsr %a0@
56f94: 508f addql #8,%sp
56f96: 4a00 tstb %d0
56f98: 6742 beqs 56fdc <rtems_rfs_dir_lookup_ino+0x302> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: "
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
56f9a: 4280 clrl %d0 <== NOT EXECUTED
56f9c: 1012 moveb %a2@,%d0 <== NOT EXECUTED
56f9e: 7218 moveq #24,%d1 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
56fa0: 2045 moveal %d5,%a0 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
56fa2: e3a8 lsll %d1,%d0 <== NOT EXECUTED
56fa4: 4281 clrl %d1 <== NOT EXECUTED
56fa6: 122a 0001 moveb %a2@(1),%d1 <== NOT EXECUTED
56faa: 4841 swap %d1 <== NOT EXECUTED
56fac: 4241 clrw %d1 <== NOT EXECUTED
56fae: 8081 orl %d1,%d0 <== NOT EXECUTED
56fb0: 4281 clrl %d1 <== NOT EXECUTED
56fb2: 122a 0003 moveb %a2@(3),%d1 <== NOT EXECUTED
56fb6: 8081 orl %d1,%d0 <== NOT EXECUTED
56fb8: 122a 0002 moveb %a2@(2),%d1 <== NOT EXECUTED
56fbc: e189 lsll #8,%d1 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
56fbe: 8081 orl %d1,%d0 <== NOT EXECUTED
56fc0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56fc2: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56fc4: 2f2e ffba movel %fp@(-70),%sp@- <== NOT EXECUTED
56fc8: 2f2e ffb6 movel %fp@(-74),%sp@- <== NOT EXECUTED
56fcc: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56fd0: 4879 0006 cdac pea 6cdac <CSWTCH.1+0x6f2> <== NOT EXECUTED
56fd6: 4e90 jsr %a0@ <== NOT EXECUTED
56fd8: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
56fdc: 2f07 movel %d7,%sp@-
56fde: 2f2e 0010 movel %fp@(16),%sp@-
56fe2: 486a 000a pea %a2@(10)
56fe6: 4eb9 0005 bf04 jsr 5bf04 <memcmp>
56fec: 4fef 000c lea %sp@(12),%sp
56ff0: 4a80 tstl %d0
56ff2: 6650 bnes 57044 <rtems_rfs_dir_lookup_ino+0x36a> <== NEVER TAKEN
{
*offset = rtems_rfs_block_map_pos (fs, &map);
56ff4: 486e ffb6 pea %fp@(-74)
56ff8: 244b moveal %a3,%a2
56ffa: 264c moveal %a4,%a3
56ffc: 284d moveal %a5,%a4
56ffe: 2f0a movel %a2,%sp@-
57000: 2a6e ff9e moveal %fp@(-98),%a5
57004: 242e ff9a movel %fp@(-102),%d2
57008: 4eb9 0005 5908 jsr 55908 <rtems_rfs_block_get_pos>
5700e: 2a81 movel %d1,%a5@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
57010: 2f3c 1000 0000 movel #268435456,%sp@-
57016: 42a7 clrl %sp@-
57018: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
5701e: 4fef 0010 lea %sp@(16),%sp
57022: 4a00 tstb %d0
57024: 6700 00e6 beqw 5710c <rtems_rfs_dir_lookup_ino+0x432>
printf ("rtems-rfs: dir-lookup-ino: "
57028: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
5702a: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
5702c: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
57030: 4879 0006 ce0a pea 6ce0a <CSWTCH.1+0x750> <== NOT EXECUTED
57036: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5703c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
57040: 6000 00ca braw 5710c <rtems_rfs_dir_lookup_ino+0x432> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
57044: d7ae ffba addl %d3,%fp@(-70)
entry += elength;
57048: d5c3 addal %d3,%a2
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
5704a: 202b 0008 movel %a3@(8),%d0
5704e: 0680 ffff fff6 addil #-10,%d0
57054: b0ae ffba cmpl %fp@(-70),%d0
57058: 6200 fe62 bhiw 56ebc <rtems_rfs_dir_lookup_ino+0x1e2>
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
5705c: 4a84 tstl %d4
5705e: 6656 bnes 570b6 <rtems_rfs_dir_lookup_ino+0x3dc> <== NEVER TAKEN
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
57060: 486e fffc pea %fp@(-4)
57064: 486e ffa8 pea %fp@(-88)
57068: 2f0b movel %a3,%sp@-
5706a: 4eb9 0005 5e84 jsr 55e84 <rtems_rfs_block_map_next_block>
if ((rc > 0) && (rc != ENXIO))
57070: 4fef 000c lea %sp@(12),%sp
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
57074: 2400 movel %d0,%d2
if ((rc > 0) && (rc != ENXIO))
57076: 6f58 bles 570d0 <rtems_rfs_dir_lookup_ino+0x3f6> <== NEVER TAKEN
57078: 7006 moveq #6,%d0
5707a: b082 cmpl %d2,%d0
5707c: 6732 beqs 570b0 <rtems_rfs_dir_lookup_ino+0x3d6> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
5707e: 2046 moveal %d6,%a0 <== NOT EXECUTED
57080: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
57086: 42a7 clrl %sp@- <== NOT EXECUTED
57088: 4e90 jsr %a0@ <== NOT EXECUTED
5708a: 508f addql #8,%sp <== NOT EXECUTED
5708c: 4a00 tstb %d0 <== NOT EXECUTED
5708e: 6740 beqs 570d0 <rtems_rfs_dir_lookup_ino+0x3f6> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
57090: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57092: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
57098: 2045 moveal %d5,%a0 <== NOT EXECUTED
5709a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5709c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5709e: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
570a2: 4879 0006 ce51 pea 6ce51 <CSWTCH.1+0x797> <== NOT EXECUTED
570a8: 4e90 jsr %a0@ <== NOT EXECUTED
570aa: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
570ae: 6020 bras 570d0 <rtems_rfs_dir_lookup_ino+0x3f6> <== NOT EXECUTED
570b0: 244b moveal %a3,%a2
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
570b2: 7402 moveq #2,%d2
570b4: 602a bras 570e0 <rtems_rfs_dir_lookup_ino+0x406>
570b6: 2404 movel %d4,%d2 <== NOT EXECUTED
570b8: 6016 bras 570d0 <rtems_rfs_dir_lookup_ino+0x3f6> <== NOT EXECUTED
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
570ba: 2d4d ff9e movel %a5,%fp@(-98)
570be: 2a4c moveal %a4,%a5
570c0: 284b moveal %a3,%a4
570c2: 264a moveal %a2,%a3
570c4: 2c3c 0004 f5ec movel #325100,%d6
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
570ca: 2a3c 0005 c170 movel #377200,%d5
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
570d0: 4a82 tstl %d2
570d2: 660a bnes 570de <rtems_rfs_dir_lookup_ino+0x404> <== NEVER TAKEN
570d4: 4aae fffc tstl %fp@(-4)
570d8: 6600 fd4a bnew 56e24 <rtems_rfs_dir_lookup_ino+0x14a>
570dc: 6058 bras 57136 <rtems_rfs_dir_lookup_ino+0x45c> <== NOT EXECUTED
570de: 244b moveal %a3,%a2 <== NOT EXECUTED
570e0: 2802 movel %d2,%d4
570e2: 2404 movel %d4,%d2
570e4: 6026 bras 5710c <rtems_rfs_dir_lookup_ino+0x432>
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
570e6: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
570ea: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
570f0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
570f2: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
570f6: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
570fa: 4879 0006 ce9c pea 6ce9c <CSWTCH.1+0x7e2> <== NOT EXECUTED
57100: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57106: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
5710a: 7405 moveq #5,%d2 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
5710c: 486e fff2 pea %fp@(-14)
57110: 2f0a movel %a2,%sp@-
57112: 4eba fb9c jsr %pc@(56cb0 <rtems_rfs_buffer_handle_close>)
rtems_rfs_block_map_close (fs, &map);
57116: 486e ffa8 pea %fp@(-88)
5711a: 2f0a movel %a2,%sp@-
5711c: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close>
return rc;
57122: 4fef 0010 lea %sp@(16),%sp
}
57126: 2002 movel %d2,%d0
57128: 4cee 3cfc ff70 moveml %fp@(-144),%d2-%d7/%a2-%a5
5712e: 4e5e unlk %fp
57130: 4e75 rts
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
57132: 7805 moveq #5,%d4 <== NOT EXECUTED
57134: 6080 bras 570b6 <rtems_rfs_dir_lookup_ino+0x3dc> <== NOT EXECUTED
57136: 244b moveal %a3,%a2 <== NOT EXECUTED
57138: 264c moveal %a4,%a3 <== NOT EXECUTED
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
5713a: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
57140: 42a7 clrl %sp@- <== NOT EXECUTED
57142: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57148: 508f addql #8,%sp <== NOT EXECUTED
5714a: 4a00 tstb %d0 <== NOT EXECUTED
5714c: 67bc beqs 5710a <rtems_rfs_dir_lookup_ino+0x430> <== NOT EXECUTED
5714e: 6096 bras 570e6 <rtems_rfs_dir_lookup_ino+0x40c> <== NOT EXECUTED
0005781c <rtems_rfs_dir_read>:
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
5781c: 4e56 ff80 linkw %fp,#-128 <== NOT EXECUTED
57820: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
57824: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
5782a: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
5782e: 42a7 clrl %sp@- <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
57830: 266e 0018 moveal %fp@(24),%a3 <== NOT EXECUTED
57834: 286e 001c moveal %fp@(28),%a4 <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
57838: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5783e: 508f addql #8,%sp <== NOT EXECUTED
57840: 4a00 tstb %d0 <== NOT EXECUTED
57842: 6720 beqs 57864 <rtems_rfs_dir_read+0x48> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
57844: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
57848: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
5784c: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
57850: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
57854: 4879 0006 d195 pea 6d195 <CSWTCH.1+0xadb> <== NOT EXECUTED
5785a: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57860: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
57864: 4294 clrl %a4@ <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
57866: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
5786a: 2f2e 000c movel %fp@(12),%sp@- <== NOT EXECUTED
5786e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57870: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
57876: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
rc = rtems_rfs_block_map_open (fs, dir, &map);
5787a: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
5787c: 6e00 02d0 bgtw 57b4e <rtems_rfs_dir_read+0x332> <== NOT EXECUTED
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
57880: 2a2a 0008 movel %a2@(8),%d5 <== NOT EXECUTED
57884: 4284 clrl %d4 <== NOT EXECUTED
57886: 2f05 movel %d5,%sp@- <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
57888: 2404 movel %d4,%d2 <== NOT EXECUTED
5788a: 2605 movel %d5,%d3 <== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
5788c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5788e: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
57892: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
57896: 4eb9 0006 848c jsr 6848c <__moddi3> <== NOT EXECUTED
5789c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
578a0: 9681 subl %d1,%d3 <== NOT EXECUTED
578a2: 9580 subxl %d0,%d2 <== NOT EXECUTED
578a4: 2002 movel %d2,%d0 <== NOT EXECUTED
578a6: 2203 movel %d3,%d1 <== NOT EXECUTED
578a8: 4282 clrl %d2 <== NOT EXECUTED
578aa: 760a moveq #10,%d3 <== NOT EXECUTED
578ac: 9681 subl %d1,%d3 <== NOT EXECUTED
578ae: 9580 subxl %d0,%d2 <== NOT EXECUTED
578b0: 6d38 blts 578ea <rtems_rfs_dir_read+0xce> <== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
578b2: 2f05 movel %d5,%sp@- <== NOT EXECUTED
578b4: 4282 clrl %d2 <== NOT EXECUTED
578b6: 7601 moveq #1,%d3 <== NOT EXECUTED
578b8: 2f04 movel %d4,%sp@- <== NOT EXECUTED
578ba: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
578be: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
578c2: 4eb9 0006 8044 jsr 68044 <__divdi3> <== NOT EXECUTED
578c8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
578cc: 2e85 movel %d5,%sp@ <== NOT EXECUTED
578ce: d681 addl %d1,%d3 <== NOT EXECUTED
578d0: d580 addxl %d0,%d2 <== NOT EXECUTED
578d2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
578d4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
578d6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
578d8: 4eb9 0006 7f94 jsr 67f94 <__muldi3> <== NOT EXECUTED
578de: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
578e2: 2d40 0010 movel %d0,%fp@(16) <== NOT EXECUTED
578e6: 2d41 0014 movel %d1,%fp@(20) <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
578ea: 280e movel %fp,%d4 <== NOT EXECUTED
578ec: 5984 subql #4,%d4 <== NOT EXECUTED
578ee: 260e movel %fp,%d3 <== NOT EXECUTED
578f0: 0683 ffff ffa8 addil #-88,%d3 <== NOT EXECUTED
578f6: 2f04 movel %d4,%sp@- <== NOT EXECUTED
578f8: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
578fc: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
57900: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57902: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57904: 4eb9 0005 5e06 jsr 55e06 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
5790a: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
5790e: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
57910: 6f18 bles 5792a <rtems_rfs_dir_read+0x10e> <== NOT EXECUTED
{
if (rc == ENXIO)
57912: 7006 moveq #6,%d0 <== NOT EXECUTED
57914: b082 cmpl %d2,%d0 <== NOT EXECUTED
57916: 6602 bnes 5791a <rtems_rfs_dir_read+0xfe> <== NOT EXECUTED
rc = ENOENT;
57918: 7402 moveq #2,%d2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
5791a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5791c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5791e: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
57924: 508f addql #8,%sp <== NOT EXECUTED
57926: 6000 0226 braw 57b4e <rtems_rfs_dir_read+0x332> <== NOT EXECUTED
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
5792a: 2c0e movel %fp,%d6 <== NOT EXECUTED
5792c: 0686 ffff fff2 addil #-14,%d6 <== NOT EXECUTED
57932: 2e3c 0005 66f8 movel #354040,%d7 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
57938: 4201 clrb %d1 <== NOT EXECUTED
handle->bnum = 0;
5793a: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
5793e: 243c 0005 c170 movel #377200,%d2 <== NOT EXECUTED
handle->buffer = NULL;
57944: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
57948: 1d41 fff2 moveb %d1,%fp@(-14) <== NOT EXECUTED
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
5794c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
57950: 2047 moveal %d7,%a0 <== NOT EXECUTED
57952: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
57956: 2f06 movel %d6,%sp@- <== NOT EXECUTED
57958: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5795a: 4e90 jsr %a0@ <== NOT EXECUTED
if (rc > 0)
5795c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
57960: 4a80 tstl %d0 <== NOT EXECUTED
57962: 6f08 bles 5796c <rtems_rfs_dir_read+0x150> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &buffer);
57964: 2f06 movel %d6,%sp@- <== NOT EXECUTED
57966: 2400 movel %d0,%d2 <== NOT EXECUTED
57968: 6000 01ce braw 57b38 <rtems_rfs_dir_read+0x31c> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
5796c: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
57970: 4283 clrl %d3 <== NOT EXECUTED
57972: 4281 clrl %d1 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
57974: 4284 clrl %d4 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
57976: 2a2e ffba movel %fp@(-70),%d5 <== NOT EXECUTED
5797a: 2a68 001e moveal %a0@(30),%a5 <== NOT EXECUTED
5797e: dbc5 addal %d5,%a5 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
57980: 162d 0008 moveb %a5@(8),%d3 <== NOT EXECUTED
57984: 122d 0009 moveb %a5@(9),%d1 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
57988: 1815 moveb %a5@,%d4 <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
5798a: e18b lsll #8,%d3 <== NOT EXECUTED
5798c: 8681 orl %d1,%d3 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
5798e: 7218 moveq #24,%d1 <== NOT EXECUTED
57990: e3ac lsll %d1,%d4 <== NOT EXECUTED
57992: 4281 clrl %d1 <== NOT EXECUTED
57994: 122d 0001 moveb %a5@(1),%d1 <== NOT EXECUTED
57998: 4841 swap %d1 <== NOT EXECUTED
5799a: 4241 clrw %d1 <== NOT EXECUTED
5799c: 8881 orl %d1,%d4 <== NOT EXECUTED
5799e: 4281 clrl %d1 <== NOT EXECUTED
579a0: 122d 0003 moveb %a5@(3),%d1 <== NOT EXECUTED
579a4: 8881 orl %d1,%d4 <== NOT EXECUTED
579a6: 122d 0002 moveb %a5@(2),%d1 <== NOT EXECUTED
579aa: e189 lsll #8,%d1 <== NOT EXECUTED
579ac: 8881 orl %d1,%d4 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
579ae: 0c83 0000 ffff cmpil #65535,%d3 <== NOT EXECUTED
579b4: 6700 0120 beqw 57ad6 <rtems_rfs_dir_read+0x2ba> <== NOT EXECUTED
579b8: 2400 movel %d0,%d2 <== NOT EXECUTED
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
579ba: 700a moveq #10,%d0 <== NOT EXECUTED
579bc: b083 cmpl %d3,%d0 <== NOT EXECUTED
579be: 6c10 bges 579d0 <rtems_rfs_dir_read+0x1b4> <== NOT EXECUTED
579c0: b6aa 0018 cmpl %a2@(24),%d3 <== NOT EXECUTED
579c4: 640a bccs 579d0 <rtems_rfs_dir_read+0x1b4> <== NOT EXECUTED
579c6: 4a84 tstl %d4 <== NOT EXECUTED
579c8: 6706 beqs 579d0 <rtems_rfs_dir_read+0x1b4> <== NOT EXECUTED
579ca: b8aa 0010 cmpl %a2@(16),%d4 <== NOT EXECUTED
579ce: 633a blss 57a0a <rtems_rfs_dir_read+0x1ee> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
579d0: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
579d6: 42a7 clrl %sp@- <== NOT EXECUTED
579d8: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
579de: 508f addql #8,%sp <== NOT EXECUTED
579e0: 4a00 tstb %d0 <== NOT EXECUTED
579e2: 6700 014a beqw 57b2e <rtems_rfs_dir_read+0x312> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
579e6: 2f2e ffba movel %fp@(-70),%sp@- <== NOT EXECUTED
579ea: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
579ee: 2f04 movel %d4,%sp@- <== NOT EXECUTED
579f0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
579f2: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
579f6: 4879 0006 d1bf pea 6d1bf <CSWTCH.1+0xb05> <== NOT EXECUTED
579fc: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57a02: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
57a06: 6000 0126 braw 57b2e <rtems_rfs_dir_read+0x312> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
57a0a: 4878 0110 pea 110 <DBL_MANT_DIG+0xdb> <== NOT EXECUTED
57a0e: 42a7 clrl %sp@- <== NOT EXECUTED
57a10: 2f0b movel %a3,%sp@- <== NOT EXECUTED
57a12: 4eb9 0005 c0e4 jsr 5c0e4 <memset> <== NOT EXECUTED
*length += elength;
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
57a18: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
57a1c: 202e 0010 movel %fp@(16),%d0 <== NOT EXECUTED
57a20: 222e 0014 movel %fp@(20),%d1 <== NOT EXECUTED
57a24: 2740 0004 movel %d0,%a3@(4) <== NOT EXECUTED
57a28: 2741 0008 movel %d1,%a3@(8) <== NOT EXECUTED
dirent->d_reclen = sizeof (struct dirent);
57a2c: 323c 0110 movew #272,%d1 <== NOT EXECUTED
*length += elength;
57a30: 2003 movel %d3,%d0 <== NOT EXECUTED
57a32: d094 addl %a4@,%d0 <== NOT EXECUTED
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
57a34: 3741 000c movew %d1,%a3@(12) <== NOT EXECUTED
*length += elength;
57a38: 2880 movel %d0,%a4@ <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
57a3a: 222a 0008 movel %a2@(8),%d1 <== NOT EXECUTED
57a3e: 9285 subl %d5,%d1 <== NOT EXECUTED
57a40: 2a01 movel %d1,%d5 <== NOT EXECUTED
57a42: 9a83 subl %d3,%d5 <== NOT EXECUTED
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
57a44: 720a moveq #10,%d1 <== NOT EXECUTED
57a46: b285 cmpl %d5,%d1 <== NOT EXECUTED
57a48: 6d04 blts 57a4e <rtems_rfs_dir_read+0x232> <== NOT EXECUTED
*length += remaining;
57a4a: da80 addl %d0,%d5 <== NOT EXECUTED
57a4c: 2885 movel %d5,%a4@ <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
57a4e: 0683 ffff fff6 addil #-10,%d3 <== NOT EXECUTED
57a54: 0c83 0000 00ff cmpil #255,%d3 <== NOT EXECUTED
57a5a: 6f06 bles 57a62 <rtems_rfs_dir_read+0x246> <== NOT EXECUTED
57a5c: 263c 0000 00ff movel #255,%d3 <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
57a62: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57a64: 486d 000a pea %a5@(10) <== NOT EXECUTED
57a68: 280b movel %a3,%d4 <== NOT EXECUTED
57a6a: 0684 0000 0010 addil #16,%d4 <== NOT EXECUTED
57a70: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57a72: 4eb9 0005 bf8c jsr 5bf8c <memcpy> <== NOT EXECUTED
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
57a78: 4280 clrl %d0 <== NOT EXECUTED
57a7a: 1015 moveb %a5@,%d0 <== NOT EXECUTED
57a7c: 7218 moveq #24,%d1 <== NOT EXECUTED
57a7e: e3a8 lsll %d1,%d0 <== NOT EXECUTED
57a80: 4281 clrl %d1 <== NOT EXECUTED
57a82: 122d 0001 moveb %a5@(1),%d1 <== NOT EXECUTED
57a86: 4841 swap %d1 <== NOT EXECUTED
57a88: 4241 clrw %d1 <== NOT EXECUTED
57a8a: 8081 orl %d1,%d0 <== NOT EXECUTED
57a8c: 4281 clrl %d1 <== NOT EXECUTED
57a8e: 122d 0003 moveb %a5@(3),%d1 <== NOT EXECUTED
57a92: 8081 orl %d1,%d0 <== NOT EXECUTED
57a94: 122d 0002 moveb %a5@(2),%d1 <== NOT EXECUTED
57a98: e189 lsll #8,%d1 <== NOT EXECUTED
dirent->d_namlen = elength;
57a9a: 3743 000e movew %d3,%a3@(14) <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
57a9e: 8081 orl %d1,%d0 <== NOT EXECUTED
57aa0: 2680 movel %d0,%a3@ <== NOT EXECUTED
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
57aa2: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
57aa8: 42a7 clrl %sp@- <== NOT EXECUTED
57aaa: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57ab0: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
57ab4: 4a00 tstb %d0 <== NOT EXECUTED
57ab6: 677c beqs 57b34 <rtems_rfs_dir_read+0x318> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIdoff_t " ino:%ld name=%s\n",
57ab8: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57aba: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
57abc: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
57ac0: 2f2b 0004 movel %a3@(4),%sp@- <== NOT EXECUTED
57ac4: 4879 0006 d203 pea 6d203 <CSWTCH.1+0xb49> <== NOT EXECUTED
57aca: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57ad0: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
57ad4: 605e bras 57b34 <rtems_rfs_dir_read+0x318> <== NOT EXECUTED
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
57ad6: 262a 0008 movel %a2@(8),%d3 <== NOT EXECUTED
57ada: 9685 subl %d5,%d3 <== NOT EXECUTED
57adc: d794 addl %d3,%a4@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
57ade: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
57ae4: 42a7 clrl %sp@- <== NOT EXECUTED
57ae6: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57aec: 508f addql #8,%sp <== NOT EXECUTED
57aee: 4a00 tstb %d0 <== NOT EXECUTED
57af0: 6718 beqs 57b0a <rtems_rfs_dir_read+0x2ee> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
57af2: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
57af4: 2042 moveal %d2,%a0 <== NOT EXECUTED
57af6: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
57afa: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
57afe: 4879 0006 d238 pea 6d238 <CSWTCH.1+0xb7e> <== NOT EXECUTED
57b04: 4e90 jsr %a0@ <== NOT EXECUTED
57b06: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
57b0a: 486e fffc pea %fp@(-4) <== NOT EXECUTED
57b0e: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
57b12: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57b14: 4eb9 0005 5e84 jsr 55e84 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
57b1a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57b1e: 7206 moveq #6,%d1 <== NOT EXECUTED
57b20: b280 cmpl %d0,%d1 <== NOT EXECUTED
57b22: 670e beqs 57b32 <rtems_rfs_dir_read+0x316> <== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
57b24: 4a80 tstl %d0 <== NOT EXECUTED
57b26: 6700 fe24 beqw 5794c <rtems_rfs_dir_read+0x130> <== NOT EXECUTED
57b2a: 2400 movel %d0,%d2 <== NOT EXECUTED
57b2c: 6006 bras 57b34 <rtems_rfs_dir_read+0x318> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04" PRIx32 "\n",
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
57b2e: 7405 moveq #5,%d2 <== NOT EXECUTED
57b30: 6002 bras 57b34 <rtems_rfs_dir_read+0x318> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
57b32: 7402 moveq #2,%d2 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
57b34: 486e fff2 pea %fp@(-14) <== NOT EXECUTED
57b38: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57b3a: 4eba f174 jsr %pc@(56cb0 <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
57b3e: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
57b42: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57b44: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
57b4a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
57b4e: 2002 movel %d2,%d0 <== NOT EXECUTED
57b50: 4cee 3cfc ff80 moveml %fp@(-128),%d2-%d7/%a2-%a5 <== NOT EXECUTED
57b56: 4e5e unlk %fp <== NOT EXECUTED
00057d54 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
57d54: 4e56 fff0 linkw %fp,#-16
57d58: 48d7 041c moveml %d2-%d4/%a2,%sp@
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57d5c: 42a7 clrl %sp@-
57d5e: 4878 0010 pea 10 <INVALID_OPERATION>
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
57d62: 262e 0008 movel %fp@(8),%d3
57d66: 246e 000c moveal %fp@(12),%a2
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57d6a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
57d70: 508f addql #8,%sp
57d72: 4a00 tstb %d0
57d74: 6716 beqs 57d8c <rtems_rfs_file_close+0x38> <== ALWAYS TAKEN
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
57d76: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
57d7a: 2f28 0014 movel %a0@(20),%sp@- <== NOT EXECUTED
57d7e: 4879 0006 d2d1 pea 6d2d1 <CSWTCH.1+0xc17> <== NOT EXECUTED
57d84: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57d8a: 508f addql #8,%sp <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
57d8c: 206a 001a moveal %a2@(26),%a0
57d90: 2028 0008 movel %a0@(8),%d0
57d94: 6f06 bles 57d9c <rtems_rfs_file_close+0x48> <== NEVER TAKEN
handle->shared->references--;
57d96: 5380 subql #1,%d0
57d98: 2140 0008 movel %d0,%a0@(8)
if (handle->shared->references == 0)
57d9c: 4aa8 0008 tstl %a0@(8)
57da0: 6600 01bc bnew 57f5e <rtems_rfs_file_close+0x20a>
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
57da4: 4aa8 0018 tstl %a0@(24)
57da8: 6614 bnes 57dbe <rtems_rfs_file_close+0x6a> <== NEVER TAKEN
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
57daa: 4868 000c pea %a0@(12)
57dae: 2f03 movel %d3,%sp@-
57db0: 4eb9 0004 d73c jsr 4d73c <rtems_rfs_inode_load>
if (rrc == 0)
57db6: 508f addql #8,%sp
handle->shared->references--;
if (handle->shared->references == 0)
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
57db8: 2400 movel %d0,%d2
if (rrc == 0)
57dba: 6600 00e2 bnew 57e9e <rtems_rfs_file_close+0x14a>
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
handle->shared->atime);
57dbe: 206a 001a moveal %a2@(26),%a0
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
57dc2: 7418 moveq #24,%d2
if (rrc == 0)
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
57dc4: 2028 0084 movel %a0@(132),%d0
57dc8: 2200 movel %d0,%d1
57dca: e4a9 lsrl %d2,%d1
57dcc: 2268 0018 moveal %a0@(24),%a1
57dd0: 1341 0010 moveb %d1,%a1@(16)
57dd4: 2200 movel %d0,%d1
57dd6: 2268 0018 moveal %a0@(24),%a1
57dda: 4241 clrw %d1
57ddc: 4841 swap %d1
57dde: 1341 0011 moveb %d1,%a1@(17)
57de2: 2200 movel %d0,%d1
57de4: e089 lsrl #8,%d1
57de6: 2268 0018 moveal %a0@(24),%a1
57dea: 1341 0012 moveb %d1,%a1@(18)
57dee: 2268 0018 moveal %a0@(24),%a1
57df2: 1340 0013 moveb %d0,%a1@(19)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
57df6: 7001 moveq #1,%d0
57df8: 1140 001c moveb %d0,%a0@(28)
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
57dfc: 206a 001a moveal %a2@(26),%a0
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
57e00: 2028 0088 movel %a0@(136),%d0
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
57e04: 2200 movel %d0,%d1
57e06: e4a9 lsrl %d2,%d1
57e08: 2268 0018 moveal %a0@(24),%a1
57e0c: 1341 0014 moveb %d1,%a1@(20)
57e10: 2200 movel %d0,%d1
57e12: 2268 0018 moveal %a0@(24),%a1
57e16: 4241 clrw %d1
57e18: 4841 swap %d1
57e1a: 1341 0015 moveb %d1,%a1@(21)
57e1e: 2200 movel %d0,%d1
57e20: e089 lsrl #8,%d1
57e22: 2268 0018 moveal %a0@(24),%a1
57e26: 1341 0016 moveb %d1,%a1@(22)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
57e2a: 7201 moveq #1,%d1
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
57e2c: 2268 0018 moveal %a0@(24),%a1
57e30: 1340 0017 moveb %d0,%a1@(23)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
57e34: 1141 001c moveb %d1,%a0@(28)
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
handle->shared->ctime);
57e38: 206a 001a moveal %a2@(26),%a0
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
57e3c: 2028 008c movel %a0@(140),%d0
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
57e40: 2200 movel %d0,%d1
57e42: e4a9 lsrl %d2,%d1
57e44: 2268 0018 moveal %a0@(24),%a1
57e48: 1341 0018 moveb %d1,%a1@(24)
57e4c: 2200 movel %d0,%d1
57e4e: 2268 0018 moveal %a0@(24),%a1
57e52: 4241 clrw %d1
57e54: 4841 swap %d1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
57e56: 7401 moveq #1,%d2
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
57e58: 1341 0019 moveb %d1,%a1@(25)
57e5c: 2200 movel %d0,%d1
57e5e: e089 lsrl #8,%d1
57e60: 2268 0018 moveal %a0@(24),%a1
57e64: 1341 001a moveb %d1,%a1@(26)
57e68: 2268 0018 moveal %a0@(24),%a1
57e6c: 1340 001b moveb %d0,%a1@(27)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
57e70: 1142 001c moveb %d2,%a0@(28)
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
57e74: 206a 001a moveal %a2@(26),%a0
57e78: 2028 007c movel %a0@(124),%d0
57e7c: b0a8 0038 cmpl %a0@(56),%d0
57e80: 660a bnes 57e8c <rtems_rfs_file_close+0x138>
57e82: 2228 003c movel %a0@(60),%d1
57e86: b2a8 0080 cmpl %a0@(128),%d1
57e8a: 6710 beqs 57e9c <rtems_rfs_file_close+0x148> <== ALWAYS TAKEN
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
57e8c: 2140 0038 movel %d0,%a0@(56)
map->dirty = true;
57e90: 7401 moveq #1,%d2
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
57e92: 2168 0080 003c movel %a0@(128),%a0@(60)
map->dirty = true;
57e98: 1142 0032 moveb %d2,%a0@(50)
57e9c: 4282 clrl %d2
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
57e9e: 206a 001a moveal %a2@(26),%a0
57ea2: 41e8 0032 lea %a0@(50),%a0
57ea6: 2f08 movel %a0,%sp@-
57ea8: 2f03 movel %d3,%sp@-
57eaa: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close>
if (rc > 0)
57eb0: 508f addql #8,%sp
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
57eb2: 2800 movel %d0,%d4
if (rc > 0)
57eb4: 6f3c bles 57ef2 <rtems_rfs_file_close+0x19e> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57eb6: 42a7 clrl %sp@- <== NOT EXECUTED
57eb8: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
57ebc: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57ec2: 508f addql #8,%sp <== NOT EXECUTED
57ec4: 4a00 tstb %d0 <== NOT EXECUTED
57ec6: 6724 beqs 57eec <rtems_rfs_file_close+0x198> <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
57ec8: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57eca: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
57ed0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
57ed2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
57ed4: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
57ed8: 2f28 0014 movel %a0@(20),%sp@- <== NOT EXECUTED
57edc: 4879 0006 d2f8 pea 6d2f8 <CSWTCH.1+0xc3e> <== NOT EXECUTED
57ee2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57ee8: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
57eec: 4a82 tstl %d2 <== NOT EXECUTED
57eee: 6602 bnes 57ef2 <rtems_rfs_file_close+0x19e> <== NOT EXECUTED
57ef0: 2404 movel %d4,%d2 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
57ef2: 206a 001a moveal %a2@(26),%a0
57ef6: 41e8 000c lea %a0@(12),%a0
57efa: 2f08 movel %a0,%sp@-
57efc: 2f03 movel %d3,%sp@-
57efe: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
if (rc > 0)
57f04: 508f addql #8,%sp
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
57f06: 2800 movel %d0,%d4
if (rc > 0)
57f08: 6f3c bles 57f46 <rtems_rfs_file_close+0x1f2> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57f0a: 42a7 clrl %sp@- <== NOT EXECUTED
57f0c: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
57f10: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57f16: 508f addql #8,%sp <== NOT EXECUTED
57f18: 4a00 tstb %d0 <== NOT EXECUTED
57f1a: 6724 beqs 57f40 <rtems_rfs_file_close+0x1ec> <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
57f1c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57f1e: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
57f24: 2f00 movel %d0,%sp@- <== NOT EXECUTED
57f26: 2f04 movel %d4,%sp@- <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
57f28: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
57f2c: 2f28 0014 movel %a0@(20),%sp@- <== NOT EXECUTED
57f30: 4879 0006 d331 pea 6d331 <CSWTCH.1+0xc77> <== NOT EXECUTED
57f36: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57f3c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
57f40: 4a82 tstl %d2 <== NOT EXECUTED
57f42: 6602 bnes 57f46 <rtems_rfs_file_close+0x1f2> <== NOT EXECUTED
57f44: 2404 movel %d4,%d2 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
57f46: 2f2a 001a movel %a2@(26),%sp@-
57f4a: 4eb9 0004 9a3c jsr 49a3c <_Chain_Extract>
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
57f50: 2f2a 001a movel %a2@(26),%sp@-
57f54: 4eb9 0004 54d0 jsr 454d0 <free>
57f5a: 508f addql #8,%sp
57f5c: 6002 bras 57f60 <rtems_rfs_file_close+0x20c>
rtems_rfs_file_handle* handle)
{
int rrc;
int rc;
rrc = 0;
57f5e: 4282 clrl %d2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
57f60: 486a 0004 pea %a2@(4)
57f64: 2f03 movel %d3,%sp@-
57f66: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
if ((rrc == 0) && (rc > 0))
rrc = rc;
if (rrc > 0)
57f6c: 508f addql #8,%sp
handle->dirty = false;
57f6e: 4200 clrb %d0
handle->bnum = 0;
57f70: 42aa 0006 clrl %a2@(6)
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
57f74: 1540 0004 moveb %d0,%a2@(4)
handle->bnum = 0;
handle->buffer = NULL;
57f78: 42aa 000a clrl %a2@(10)
57f7c: 4a82 tstl %d2
57f7e: 6f2e bles 57fae <rtems_rfs_file_close+0x25a> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57f80: 42a7 clrl %sp@- <== NOT EXECUTED
57f82: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
57f86: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
57f8c: 508f addql #8,%sp <== NOT EXECUTED
57f8e: 4a00 tstb %d0 <== NOT EXECUTED
57f90: 671c beqs 57fae <rtems_rfs_file_close+0x25a> <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
57f92: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57f94: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
57f9a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
57f9c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57f9e: 4879 0006 d36c pea 6d36c <CSWTCH.1+0xcb2> <== NOT EXECUTED
57fa4: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
57faa: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
free (handle);
57fae: 2f0a movel %a2,%sp@-
57fb0: 4eb9 0004 54d0 jsr 454d0 <free>
return rrc;
}
57fb6: 2002 movel %d2,%d0
57fb8: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
57fbe: 4e5e unlk %fp <== NOT EXECUTED
000586d6 <rtems_rfs_file_get_shared>:
rtems_rfs_file_shared*
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
586d6: 4e56 0000 linkw %fp,#0
586da: 226e 0008 moveal %fp@(8),%a1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
586de: 2069 0070 moveal %a1@(112),%a0
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
586e2: 43e9 0074 lea %a1@(116),%a1
586e6: 202e 000c movel %fp@(12),%d0
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
586ea: 6008 bras 586f4 <rtems_rfs_file_get_shared+0x1e>
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
586ec: b0a8 0014 cmpl %a0@(20),%d0 <== NOT EXECUTED
586f0: 670a beqs 586fc <rtems_rfs_file_get_shared+0x26> <== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
586f2: 2050 moveal %a0@,%a0 <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
586f4: b3c8 cmpal %a0,%a1
586f6: 66f4 bnes 586ec <rtems_rfs_file_get_shared+0x16> <== NEVER TAKEN
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
586f8: 4280 clrl %d0
586fa: 6002 bras 586fe <rtems_rfs_file_get_shared+0x28>
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
586fc: 2008 movel %a0,%d0 <== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
586fe: 4e5e unlk %fp <== NOT EXECUTED
00058188 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
58188: 4e56 ffe8 linkw %fp,#-24
5818c: 48d7 047c moveml %d2-%d6/%a2,%sp@
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
58190: 42a7 clrl %sp@-
58192: 4878 0020 pea 20 <OPER2+0xc>
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
58196: 246e 0008 moveal %fp@(8),%a2
5819a: 282e 000c movel %fp@(12),%d4
5819e: 162e 0013 moveb %fp@(19),%d3
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
581a2: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
581a8: 508f addql #8,%sp
581aa: 4a00 tstb %d0
581ac: 6724 beqs 581d2 <rtems_rfs_file_io_end+0x4a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
581ae: 203c 0006 a20c movel #434700,%d0 <== NOT EXECUTED
581b4: 4a03 tstb %d3 <== NOT EXECUTED
581b6: 6706 beqs 581be <rtems_rfs_file_io_end+0x36> <== NOT EXECUTED
581b8: 203c 0006 c2e8 movel #443112,%d0 <== NOT EXECUTED
581be: 2f04 movel %d4,%sp@- <== NOT EXECUTED
581c0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
581c2: 4879 0006 d444 pea 6d444 <CSWTCH.1+0xd8a> <== NOT EXECUTED
581c8: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
581ce: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
581d2: 4aaa 000a tstl %a2@(10)
581d6: 6758 beqs 58230 <rtems_rfs_file_io_end+0xa8> <== NEVER TAKEN
{
if (!read)
581d8: 4a03 tstb %d3
581da: 6606 bnes 581e2 <rtems_rfs_file_io_end+0x5a>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
581dc: 7001 moveq #1,%d0
581de: 1540 0004 moveb %d0,%a2@(4)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
581e2: 486a 0004 pea %a2@(4)
581e6: 206a 001a moveal %a2@(26),%a0
581ea: 2f28 0090 movel %a0@(144),%sp@-
581ee: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
581f4: 508f addql #8,%sp
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
{
if (!read)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
581f6: 2400 movel %d0,%d2
rtems_rfs_file_buffer (handle));
if (rc > 0)
581f8: 6f38 bles 58232 <rtems_rfs_file_io_end+0xaa> <== ALWAYS TAKEN
{
printf (
581fa: 2f00 movel %d0,%sp@- <== NOT EXECUTED
581fc: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
58202: 588f addql #4,%sp <== NOT EXECUTED
58204: 223c 0006 a20c movel #434700,%d1 <== NOT EXECUTED
5820a: 4a03 tstb %d3 <== NOT EXECUTED
5820c: 6706 beqs 58214 <rtems_rfs_file_io_end+0x8c> <== NOT EXECUTED
5820e: 223c 0006 c2e8 movel #443112,%d1 <== NOT EXECUTED
58214: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58216: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58218: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5821a: 2f01 movel %d1,%sp@- <== NOT EXECUTED
5821c: 4879 0006 d46c pea 6d46c <CSWTCH.1+0xdb2> <== NOT EXECUTED
58222: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
"rtems-rfs: file-io: end: error on release: %s size=%zu: %d: %s\n",
read ? "read" : "write", size, rc, strerror (rc));
return rc;
58228: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
5822c: 6000 0118 braw 58346 <rtems_rfs_file_io_end+0x1be> <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
58230: 4282 clrl %d2 <== NOT EXECUTED
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
58232: 206a 001a moveal %a2@(26),%a0
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
58236: d8aa 0012 addl %a2@(18),%d4
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
5823a: 2268 0090 moveal %a0@(144),%a1
5823e: 2029 0008 movel %a1@(8),%d0
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
58242: 2544 0012 movel %d4,%a2@(18)
if (handle->bpos.boff >=
58246: b084 cmpl %d4,%d0
58248: 620a bhis 58254 <rtems_rfs_file_io_end+0xcc> <== ALWAYS TAKEN
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
5824a: 9880 subl %d0,%d4 <== NOT EXECUTED
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
5824c: 52aa 000e addql #1,%a2@(14) <== NOT EXECUTED
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
58250: 2544 0012 movel %d4,%a2@(18) <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
58254: 4a03 tstb %d3
58256: 6634 bnes 5828c <rtems_rfs_file_io_end+0x104>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
58258: 202a 000e movel %a2@(14),%d0
}
length = false;
mtime = false;
if (!read &&
5825c: 6706 beqs 58264 <rtems_rfs_file_io_end+0xdc> <== ALWAYS TAKEN
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
5825e: 4aa8 0038 tstl %a0@(56) <== NOT EXECUTED
58262: 6718 beqs 5827c <rtems_rfs_file_io_end+0xf4> <== NOT EXECUTED
58264: 2228 0038 movel %a0@(56),%d1
58268: b280 cmpl %d0,%d1
5826a: 6310 blss 5827c <rtems_rfs_file_io_end+0xf4> <== NEVER TAKEN
5826c: 5381 subql #1,%d1
5826e: b280 cmpl %d0,%d1
58270: 661a bnes 5828c <rtems_rfs_file_io_end+0x104> <== NEVER TAKEN
58272: 2228 003c movel %a0@(60),%d1
58276: b2aa 0012 cmpl %a2@(18),%d1
5827a: 6410 bccs 5828c <rtems_rfs_file_io_end+0x104>
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
5827c: 216a 0012 003c movel %a2@(18),%a0@(60)
map->dirty = true;
58282: 7001 moveq #1,%d0
rtems_rfs_file_bpos (handle)))
{
rtems_rfs_block_map_set_size_offset (rtems_rfs_file_map (handle),
handle->bpos.boff);
length = true;
mtime = true;
58284: 7c01 moveq #1,%d6
58286: 1140 0032 moveb %d0,%a0@(50)
5828a: 6002 bras 5828e <rtems_rfs_file_io_end+0x106>
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
}
length = false;
mtime = false;
5828c: 4206 clrb %d6
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
5828e: 2012 movel %a2@,%d0
58290: 2a00 movel %d0,%d5
58292: 4685 notl %d5
58294: 7201 moveq #1,%d1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
58296: 4284 clrl %d4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
58298: ca81 andl %d1,%d5
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
5829a: 0800 0001 btst #1,%d0
5829e: 6602 bnes 582a2 <rtems_rfs_file_io_end+0x11a> <== NEVER TAKEN
582a0: 1806 moveb %d6,%d4
length = rtems_rfs_file_update_length (handle) && length;
582a2: 44c0 movew %d0,%ccr
582a4: 6708 beqs 582ae <rtems_rfs_file_io_end+0x126> <== NEVER TAKEN
582a6: 0286 0000 00ff andil #255,%d6
582ac: 6002 bras 582b0 <rtems_rfs_file_io_end+0x128>
582ae: 4286 clrl %d6 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
582b0: 42a7 clrl %sp@-
582b2: 4878 0020 pea 20 <OPER2+0xc>
582b6: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
582bc: 508f addql #8,%sp
582be: 4a00 tstb %d0
582c0: 6740 beqs 58302 <rtems_rfs_file_io_end+0x17a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
582c2: 4a06 tstb %d6 <== NOT EXECUTED
582c4: 6706 beqs 582cc <rtems_rfs_file_io_end+0x144> <== NOT EXECUTED
582c6: 307c 004c moveaw #76,%a0 <== NOT EXECUTED
582ca: 6004 bras 582d0 <rtems_rfs_file_io_end+0x148> <== NOT EXECUTED
582cc: 307c 002d moveaw #45,%a0 <== NOT EXECUTED
582d0: 4a04 tstb %d4 <== NOT EXECUTED
582d2: 6704 beqs 582d8 <rtems_rfs_file_io_end+0x150> <== NOT EXECUTED
582d4: 724d moveq #77,%d1 <== NOT EXECUTED
582d6: 6002 bras 582da <rtems_rfs_file_io_end+0x152> <== NOT EXECUTED
582d8: 722d moveq #45,%d1 <== NOT EXECUTED
582da: 4a05 tstb %d5 <== NOT EXECUTED
582dc: 6704 beqs 582e2 <rtems_rfs_file_io_end+0x15a> <== NOT EXECUTED
582de: 7041 moveq #65,%d0 <== NOT EXECUTED
582e0: 6002 bras 582e4 <rtems_rfs_file_io_end+0x15c> <== NOT EXECUTED
582e2: 702d moveq #45,%d0 <== NOT EXECUTED
582e4: 2f08 movel %a0,%sp@- <== NOT EXECUTED
582e6: 2f01 movel %d1,%sp@- <== NOT EXECUTED
582e8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
582ea: 2f2a 0012 movel %a2@(18),%sp@- <== NOT EXECUTED
582ee: 2f2a 000e movel %a2@(14),%sp@- <== NOT EXECUTED
582f2: 4879 0006 d4ae pea 6d4ae <CSWTCH.1+0xdf4> <== NOT EXECUTED
582f8: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
582fe: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
58302: 4a05 tstb %d5
58304: 6604 bnes 5830a <rtems_rfs_file_io_end+0x182> <== ALWAYS TAKEN
58306: 4a04 tstb %d4 <== NOT EXECUTED
58308: 6728 beqs 58332 <rtems_rfs_file_io_end+0x1aa> <== NOT EXECUTED
{
time_t now = time (NULL);
5830a: 42a7 clrl %sp@-
5830c: 4eb9 0005 f394 jsr 5f394 <time>
if (read && atime)
58312: 588f addql #4,%sp
58314: 4a03 tstb %d3
58316: 670e beqs 58326 <rtems_rfs_file_io_end+0x19e>
58318: 4a05 tstb %d5
5831a: 6716 beqs 58332 <rtems_rfs_file_io_end+0x1aa> <== NEVER TAKEN
handle->shared->atime = now;
5831c: 206a 001a moveal %a2@(26),%a0
58320: 2140 0084 movel %d0,%a0@(132)
58324: 600c bras 58332 <rtems_rfs_file_io_end+0x1aa>
if (!read && mtime)
58326: 4a04 tstb %d4
58328: 6708 beqs 58332 <rtems_rfs_file_io_end+0x1aa>
handle->shared->mtime = now;
5832a: 206a 001a moveal %a2@(26),%a0
5832e: 2140 0088 movel %d0,%a0@(136)
}
if (length)
58332: 4a06 tstb %d6
58334: 6710 beqs 58346 <rtems_rfs_file_io_end+0x1be>
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
58336: 206a 001a moveal %a2@(26),%a0
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
5833a: 2168 0038 007c movel %a0@(56),%a0@(124)
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
58340: 2168 003c 0080 movel %a0@(60),%a0@(128)
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
58346: 2002 movel %d2,%d0
58348: 4cee 047c ffe8 moveml %fp@(-24),%d2-%d6/%a2
5834e: 4e5e unlk %fp <== NOT EXECUTED
00058352 <rtems_rfs_file_io_release>:
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
58352: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
58356: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
5835a: 4aa8 000a tstl %a0@(10) <== NOT EXECUTED
5835e: 6716 beqs 58376 <rtems_rfs_file_io_release+0x24> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
58360: 4868 0004 pea %a0@(4) <== NOT EXECUTED
58364: 2068 001a moveal %a0@(26),%a0 <== NOT EXECUTED
58368: 2f28 0090 movel %a0@(144),%sp@- <== NOT EXECUTED
5836c: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
58372: 508f addql #8,%sp <== NOT EXECUTED
58374: 6002 bras 58378 <rtems_rfs_file_io_release+0x26> <== NOT EXECUTED
}
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
int rc = 0;
58376: 4280 clrl %d0 <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
rtems_rfs_file_buffer (handle));
return rc;
}
58378: 4e5e unlk %fp <== NOT EXECUTED
00057fc2 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
57fc2: 4e56 ffec linkw %fp,#-20
57fc6: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
57fca: 42a7 clrl %sp@-
57fcc: 4878 0020 pea 20 <OPER2+0xc>
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
57fd0: 246e 0008 moveal %fp@(8),%a2
57fd4: 266e 000c moveal %fp@(12),%a3
57fd8: 142e 0013 moveb %fp@(19),%d2
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
57fdc: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
57fe2: 508f addql #8,%sp
57fe4: 4a00 tstb %d0
57fe6: 672e beqs 58016 <rtems_rfs_file_io_start+0x54> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
57fe8: 206a 0012 moveal %a2@(18),%a0 <== NOT EXECUTED
57fec: 222a 000e movel %a2@(14),%d1 <== NOT EXECUTED
57ff0: 203c 0006 a20c movel #434700,%d0 <== NOT EXECUTED
57ff6: 4a02 tstb %d2 <== NOT EXECUTED
57ff8: 6706 beqs 58000 <rtems_rfs_file_io_start+0x3e> <== NOT EXECUTED
57ffa: 203c 0006 c2e8 movel #443112,%d0 <== NOT EXECUTED
58000: 2f08 movel %a0,%sp@- <== NOT EXECUTED
58002: 2f01 movel %d1,%sp@- <== NOT EXECUTED
58004: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58006: 4879 0006 d393 pea 6d393 <CSWTCH.1+0xcd9> <== NOT EXECUTED
5800c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
58012: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
58016: 4aaa 000a tstl %a2@(10)
5801a: 6600 0106 bnew 58122 <rtems_rfs_file_io_start+0x160>
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
rtems_rfs_file_map (handle),
5801e: 206a 001a moveal %a2@(26),%a0
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
58022: 486e fffc pea %fp@(-4)
58026: 486a 000e pea %a2@(14)
5802a: 4868 0032 pea %a0@(50)
5802e: 2f28 0090 movel %a0@(144),%sp@-
58032: 4eb9 0005 5d1a jsr 55d1a <rtems_rfs_block_map_find>
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
58038: 4fef 0010 lea %sp@(16),%sp
5803c: 4a80 tstl %d0
5803e: 6f60 bles 580a0 <rtems_rfs_file_io_start+0xde> <== ALWAYS TAKEN
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
58040: 7206 moveq #6,%d1 <== NOT EXECUTED
58042: 4a02 tstb %d2 <== NOT EXECUTED
58044: 670c beqs 58052 <rtems_rfs_file_io_start+0x90> <== NOT EXECUTED
58046: b280 cmpl %d0,%d1 <== NOT EXECUTED
58048: 6600 0134 bnew 5817e <rtems_rfs_file_io_start+0x1bc> <== NOT EXECUTED
{
*available = 0;
5804c: 4293 clrl %a3@ <== NOT EXECUTED
5804e: 6000 012c braw 5817c <rtems_rfs_file_io_start+0x1ba> <== NOT EXECUTED
return 0;
}
if (rc != ENXIO)
58052: b280 cmpl %d0,%d1 <== NOT EXECUTED
58054: 6600 0128 bnew 5817e <rtems_rfs_file_io_start+0x1bc> <== NOT EXECUTED
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
58058: 42a7 clrl %sp@- <== NOT EXECUTED
5805a: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
5805e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58064: 508f addql #8,%sp <== NOT EXECUTED
58066: 4a00 tstb %d0 <== NOT EXECUTED
58068: 670e beqs 58078 <rtems_rfs_file_io_start+0xb6> <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: grow\n");
5806a: 4879 0006 d3be pea 6d3be <CSWTCH.1+0xd04> <== NOT EXECUTED
58070: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
58076: 588f addql #4,%sp <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
rtems_rfs_file_map (handle),
58078: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
5807c: 486e fffc pea %fp@(-4) <== NOT EXECUTED
58080: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58084: 4868 0032 pea %a0@(50) <== NOT EXECUTED
58088: 2f28 0090 movel %a0@(144),%sp@- <== NOT EXECUTED
5808c: 4eb9 0005 5eb6 jsr 55eb6 <rtems_rfs_block_map_grow> <== NOT EXECUTED
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
58092: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58096: 4a80 tstl %d0 <== NOT EXECUTED
58098: 6e00 00e4 bgtw 5817e <rtems_rfs_file_io_start+0x1bc> <== NOT EXECUTED
return rc;
request_read = false;
5809c: 4203 clrb %d3 <== NOT EXECUTED
5809e: 6024 bras 580c4 <rtems_rfs_file_io_start+0x102> <== NOT EXECUTED
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
580a0: 4a02 tstb %d2
580a2: 661a bnes 580be <rtems_rfs_file_io_start+0xfc>
580a4: 4aaa 0012 tstl %a2@(18)
580a8: 6618 bnes 580c2 <rtems_rfs_file_io_start+0x100> <== NEVER TAKEN
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
580aa: 206a 001a moveal %a2@(26),%a0
580ae: 2068 0090 moveal %a0@(144),%a0
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
580b2: 2068 0008 moveal %a0@(8),%a0
580b6: b1d3 cmpal %a3@,%a0
580b8: 52c3 shi %d3
580ba: 4483 negl %d3
580bc: 6006 bras 580c4 <rtems_rfs_file_io_start+0x102>
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
580be: 1602 moveb %d2,%d3
580c0: 6002 bras 580c4 <rtems_rfs_file_io_start+0x102>
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
580c2: 7601 moveq #1,%d3 <== NOT EXECUTED
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
580c4: 42a7 clrl %sp@-
580c6: 4878 0020 pea 20 <OPER2+0xc>
580ca: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
580d0: 508f addql #8,%sp
580d2: 4a00 tstb %d0
580d4: 6726 beqs 580fc <rtems_rfs_file_io_start+0x13a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
580d6: 203c 0006 c27c movel #443004,%d0 <== NOT EXECUTED
580dc: 4a03 tstb %d3 <== NOT EXECUTED
580de: 6706 beqs 580e6 <rtems_rfs_file_io_start+0x124> <== NOT EXECUTED
580e0: 203c 0006 be89 movel #441993,%d0 <== NOT EXECUTED
580e6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
580e8: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
580ec: 4879 0006 d3de pea 6d3de <CSWTCH.1+0xd24> <== NOT EXECUTED
580f2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
580f8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
580fc: 0283 0000 00ff andil #255,%d3
58102: 2f03 movel %d3,%sp@-
58104: 2f2e fffc movel %fp@(-4),%sp@-
58108: 486a 0004 pea %a2@(4)
5810c: 206a 001a moveal %a2@(26),%a0
58110: 2f28 0090 movel %a0@(144),%sp@-
58114: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
5811a: 4fef 0010 lea %sp@(16),%sp
5811e: 4a80 tstl %d0
58120: 6e5c bgts 5817e <rtems_rfs_file_io_start+0x1bc> <== NEVER TAKEN
58122: 206a 001a moveal %a2@(26),%a0
return rc;
}
if (read
58126: 4a02 tstb %d2
58128: 671c beqs 58146 <rtems_rfs_file_io_start+0x184>
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
5812a: 2028 0040 movel %a0@(64),%d0
5812e: 6606 bnes 58136 <rtems_rfs_file_io_start+0x174> <== NEVER TAKEN
58130: 4aa8 0038 tstl %a0@(56)
58134: 670a beqs 58140 <rtems_rfs_file_io_start+0x17e> <== NEVER TAKEN
58136: 2228 0038 movel %a0@(56),%d1
5813a: 5381 subql #1,%d1
5813c: b280 cmpl %d0,%d1
5813e: 6606 bnes 58146 <rtems_rfs_file_io_start+0x184> <== NEVER TAKEN
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
58140: 2428 003c movel %a0@(60),%d2
58144: 6608 bnes 5814e <rtems_rfs_file_io_start+0x18c> <== ALWAYS TAKEN
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
58146: 2068 0090 moveal %a0@(144),%a0
5814a: 2428 0008 movel %a0@(8),%d2
*available = size - rtems_rfs_file_block_offset (handle);
5814e: 2002 movel %d2,%d0
58150: 90aa 0012 subl %a2@(18),%d0
58154: 2680 movel %d0,%a3@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
58156: 42a7 clrl %sp@-
58158: 4878 0020 pea 20 <OPER2+0xc>
5815c: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
58162: 508f addql #8,%sp
58164: 4a00 tstb %d0
58166: 6714 beqs 5817c <rtems_rfs_file_io_start+0x1ba> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
58168: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5816a: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
5816c: 4879 0006 d414 pea 6d414 <CSWTCH.1+0xd5a> <== NOT EXECUTED
58172: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
58178: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
*available, size);
return 0;
5817c: 4280 clrl %d0
}
5817e: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
58184: 4e5e unlk %fp <== NOT EXECUTED
00058702 <rtems_rfs_file_open>:
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
58702: 4e56 ffe4 linkw %fp,#-28
58706: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
5870a: 42a7 clrl %sp@-
5870c: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
58710: 286e 0008 moveal %fp@(8),%a4
58714: 262e 000c movel %fp@(12),%d3
58718: 2a6e 0014 moveal %fp@(20),%a5
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
5871c: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
58722: 508f addql #8,%sp
58724: 4a00 tstb %d0
58726: 6710 beqs 58738 <rtems_rfs_file_open+0x36> <== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
58728: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5872a: 4879 0006 d524 pea 6d524 <CSWTCH.1+0xe6a> <== NOT EXECUTED
58730: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
58736: 508f addql #8,%sp <== NOT EXECUTED
*file = NULL;
58738: 4295 clrl %a5@
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
5873a: 4878 001e pea 1e <OPER2+0xa>
5873e: 283c 0004 5af0 movel #285424,%d4
58744: 2044 moveal %d4,%a0
58746: 4e90 jsr %a0@
if (!handle)
58748: 588f addql #4,%sp
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
5874a: 2440 moveal %d0,%a2
if (!handle)
5874c: 4a80 tstl %d0
5874e: 6700 02b0 beqw 58a00 <rtems_rfs_file_open+0x2fe>
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
58752: 4878 001e pea 1e <OPER2+0xa>
58756: 243c 0005 c0e4 movel #377060,%d2
5875c: 2042 moveal %d2,%a0
5875e: 42a7 clrl %sp@-
58760: 2f00 movel %d0,%sp@-
58762: 4e90 jsr %a0@
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
58764: 4200 clrb %d0
/*
* Scan the file system data list of open files for this ino. If found up
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
58766: 2f03 movel %d3,%sp@-
58768: 1540 0004 moveb %d0,%a2@(4)
5876c: 2f0c movel %a4,%sp@-
handle->bnum = 0;
5876e: 42aa 0006 clrl %a2@(6)
handle->buffer = NULL;
58772: 42aa 000a clrl %a2@(10)
58776: 4eb9 0005 86d6 jsr 586d6 <rtems_rfs_file_get_shared>
if (shared)
5877c: 4fef 0014 lea %sp@(20),%sp
/*
* Scan the file system data list of open files for this ino. If found up
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
58780: 2640 moveal %d0,%a3
if (shared)
58782: 4a80 tstl %d0
58784: 6724 beqs 587aa <rtems_rfs_file_open+0xa8> <== ALWAYS TAKEN
{
shared->references++;
58786: 52ab 0008 addql #1,%a3@(8) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
5878a: 42a7 clrl %sp@- <== NOT EXECUTED
5878c: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
58790: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58796: 508f addql #8,%sp <== NOT EXECUTED
58798: 4a00 tstb %d0 <== NOT EXECUTED
5879a: 6700 0256 beqw 589f2 <rtems_rfs_file_open+0x2f0> <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
5879e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
587a0: 4879 0006 d543 pea 6d543 <CSWTCH.1+0xe89> <== NOT EXECUTED
587a6: 6000 0242 braw 589ea <rtems_rfs_file_open+0x2e8> <== NOT EXECUTED
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
587aa: 4878 0094 pea 94 <DBL_MANT_DIG+0x5f>
587ae: 2044 moveal %d4,%a0
587b0: 4e90 jsr %a0@
if (!shared)
587b2: 588f addql #4,%sp
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
587b4: 2640 moveal %d0,%a3
if (!shared)
587b6: 4a80 tstl %d0
587b8: 662a bnes 587e4 <rtems_rfs_file_open+0xe2> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
587ba: 486a 0004 pea %a2@(4) <== NOT EXECUTED
587be: 2f0c movel %a4,%sp@- <== NOT EXECUTED
587c0: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
587c6: 4200 clrb %d0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
587c8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
587ca: 1540 0004 moveb %d0,%a2@(4) <== NOT EXECUTED
handle->bnum = 0;
587ce: 42aa 0006 clrl %a2@(6) <== NOT EXECUTED
handle->buffer = NULL;
587d2: 42aa 000a clrl %a2@(10) <== NOT EXECUTED
587d6: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return ENOMEM;
587dc: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
587e0: 6000 021e braw 58a00 <rtems_rfs_file_open+0x2fe> <== NOT EXECUTED
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
587e4: 4878 0094 pea 94 <DBL_MANT_DIG+0x5f>
587e8: 2042 moveal %d2,%a0
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
587ea: 280b movel %a3,%d4
587ec: 0684 0000 000c addil #12,%d4
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
587f2: 42a7 clrl %sp@-
587f4: 2f00 movel %d0,%sp@-
587f6: 4e90 jsr %a0@
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
587f8: 4878 0001 pea 1 <ADD>
587fc: 2f04 movel %d4,%sp@-
587fe: 2f03 movel %d3,%sp@-
58800: 2f0c movel %a4,%sp@-
58802: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
58808: 4fef 001c lea %sp@(28),%sp
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
5880c: 2400 movel %d0,%d2
if (rc > 0)
5880e: 6f5e bles 5886e <rtems_rfs_file_open+0x16c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
58810: 42a7 clrl %sp@- <== NOT EXECUTED
58812: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
58816: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5881c: 508f addql #8,%sp <== NOT EXECUTED
5881e: 4a00 tstb %d0 <== NOT EXECUTED
58820: 671c beqs 5883e <rtems_rfs_file_open+0x13c> <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
58822: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58824: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
5882a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5882c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5882e: 4879 0006 d569 pea 6d569 <CSWTCH.1+0xeaf> <== NOT EXECUTED
58834: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5883a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
free (shared);
5883e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58840: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
58846: 4e93 jsr %a3@ <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58848: 486a 0004 pea %a2@(4) <== NOT EXECUTED
5884c: 2f0c movel %a4,%sp@- <== NOT EXECUTED
5884e: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
58854: 4200 clrb %d0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
58856: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58858: 1540 0004 moveb %d0,%a2@(4) <== NOT EXECUTED
handle->bnum = 0;
5885c: 42aa 0006 clrl %a2@(6) <== NOT EXECUTED
handle->buffer = NULL;
58860: 42aa 000a clrl %a2@(10) <== NOT EXECUTED
58864: 4e93 jsr %a3@ <== NOT EXECUTED
return rc;
58866: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5886a: 6000 0196 braw 58a02 <rtems_rfs_file_open+0x300> <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
5886e: 486b 0032 pea %a3@(50)
58872: 2f04 movel %d4,%sp@-
58874: 2f0c movel %a4,%sp@-
58876: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open>
if (rc > 0)
5887c: 4fef 000c lea %sp@(12),%sp
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
58880: 2400 movel %d0,%d2
if (rc > 0)
58882: 6f68 bles 588ec <rtems_rfs_file_open+0x1ea> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
58884: 42a7 clrl %sp@- <== NOT EXECUTED
58886: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
5888a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58890: 508f addql #8,%sp <== NOT EXECUTED
58892: 4a00 tstb %d0 <== NOT EXECUTED
58894: 671c beqs 588b2 <rtems_rfs_file_open+0x1b0> <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
58896: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58898: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
5889e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
588a0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
588a2: 4879 0006 d59a pea 6d59a <CSWTCH.1+0xee0> <== NOT EXECUTED
588a8: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
588ae: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
588b2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
588b4: 2f0c movel %a4,%sp@- <== NOT EXECUTED
588b6: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
free (shared);
588bc: 2f0b movel %a3,%sp@- <== NOT EXECUTED
588be: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
588c4: 4e93 jsr %a3@ <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
588c6: 486a 0004 pea %a2@(4) <== NOT EXECUTED
588ca: 2f0c movel %a4,%sp@- <== NOT EXECUTED
588cc: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
588d2: 4201 clrb %d1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
588d4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
588d6: 1541 0004 moveb %d1,%a2@(4) <== NOT EXECUTED
handle->bnum = 0;
588da: 42aa 0006 clrl %a2@(6) <== NOT EXECUTED
handle->buffer = NULL;
588de: 42aa 000a clrl %a2@(10) <== NOT EXECUTED
588e2: 4e93 jsr %a3@ <== NOT EXECUTED
return rc;
588e4: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
588e8: 6000 0118 braw 58a02 <rtems_rfs_file_open+0x300> <== NOT EXECUTED
}
shared->references = 1;
588ec: 7001 moveq #1,%d0
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
588ee: 7218 moveq #24,%d1
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
588f0: 206b 0018 moveal %a3@(24),%a0
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
588f4: 2740 0008 movel %d0,%a3@(8)
588f8: 4280 clrl %d0
588fa: 1028 000c moveb %a0@(12),%d0
588fe: e3a8 lsll %d1,%d0
58900: 4281 clrl %d1
58902: 1228 000d moveb %a0@(13),%d1
58906: 4841 swap %d1
58908: 4241 clrw %d1
5890a: 8081 orl %d1,%d0
5890c: 4281 clrl %d1
5890e: 1228 000f moveb %a0@(15),%d1
58912: 8081 orl %d1,%d0
58914: 1228 000e moveb %a0@(14),%d1
58918: e189 lsll #8,%d1
5891a: 8081 orl %d1,%d0
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
5891c: 4281 clrl %d1
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
5891e: 2740 007c movel %d0,%a3@(124)
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
58922: 4280 clrl %d0
58924: 1028 000a moveb %a0@(10),%d0
58928: 1228 000b moveb %a0@(11),%d1
5892c: e188 lsll #8,%d0
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
5892e: 8081 orl %d1,%d0
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
58930: 7218 moveq #24,%d1
58932: 2740 0080 movel %d0,%a3@(128)
58936: 4280 clrl %d0
58938: 1028 0010 moveb %a0@(16),%d0
5893c: e3a8 lsll %d1,%d0
5893e: 4281 clrl %d1
58940: 1228 0011 moveb %a0@(17),%d1
58944: 4841 swap %d1
58946: 4241 clrw %d1
58948: 8081 orl %d1,%d0
5894a: 4281 clrl %d1
5894c: 1228 0013 moveb %a0@(19),%d1
58950: 8081 orl %d1,%d0
58952: 1228 0012 moveb %a0@(18),%d1
58956: e189 lsll #8,%d1
58958: 8081 orl %d1,%d0
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
5895a: 7218 moveq #24,%d1
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
5895c: 2740 0084 movel %d0,%a3@(132)
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
58960: 4280 clrl %d0
58962: 1028 0014 moveb %a0@(20),%d0
58966: e3a8 lsll %d1,%d0
58968: 4281 clrl %d1
5896a: 1228 0015 moveb %a0@(21),%d1
5896e: 4841 swap %d1
58970: 4241 clrw %d1
58972: 8081 orl %d1,%d0
58974: 4281 clrl %d1
58976: 1228 0017 moveb %a0@(23),%d1
5897a: 8081 orl %d1,%d0
5897c: 1228 0016 moveb %a0@(22),%d1
58980: e189 lsll #8,%d1
58982: 8081 orl %d1,%d0
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
58984: 7218 moveq #24,%d1
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
58986: 2740 0088 movel %d0,%a3@(136)
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
5898a: 4280 clrl %d0
5898c: 1028 0018 moveb %a0@(24),%d0
58990: e3a8 lsll %d1,%d0
58992: 4281 clrl %d1
58994: 1228 0019 moveb %a0@(25),%d1
58998: 4841 swap %d1
5899a: 4241 clrw %d1
5899c: 8081 orl %d1,%d0
5899e: 4281 clrl %d1
589a0: 1228 001b moveb %a0@(27),%d1
589a4: 8081 orl %d1,%d0
589a6: 1228 001a moveb %a0@(26),%d1
589aa: e189 lsll #8,%d1
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
589ac: 274c 0090 movel %a4,%a3@(144)
589b0: 8081 orl %d1,%d0
589b2: 2740 008c movel %d0,%a3@(140)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
589b6: 2f0b movel %a3,%sp@-
589b8: 486c 0070 pea %a4@(112)
589bc: 4eb9 0004 9a04 jsr 49a04 <_Chain_Append>
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
589c2: 42a7 clrl %sp@-
589c4: 2f04 movel %d4,%sp@-
589c6: 2f0c movel %a4,%sp@-
589c8: 4eb9 0004 d890 jsr 4d890 <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
589ce: 42a7 clrl %sp@-
589d0: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
589d4: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
589da: 4fef 001c lea %sp@(28),%sp
589de: 4a00 tstb %d0
589e0: 6710 beqs 589f2 <rtems_rfs_file_open+0x2f0> <== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
589e2: 2f03 movel %d3,%sp@- <== NOT EXECUTED
589e4: 4879 0006 d5cf pea 6d5cf <CSWTCH.1+0xf15> <== NOT EXECUTED
589ea: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
589f0: 508f addql #8,%sp <== NOT EXECUTED
}
handle->flags = flags;
589f2: 24ae 0010 movel %fp@(16),%a2@
handle->shared = shared;
*file = handle;
return 0;
589f6: 4282 clrl %d2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = flags;
handle->shared = shared;
589f8: 254b 001a movel %a3,%a2@(26)
*file = handle;
589fc: 2a8a movel %a2,%a5@
return 0;
589fe: 6002 bras 58a02 <rtems_rfs_file_open+0x300>
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
if (!handle)
return ENOMEM;
58a00: 740c moveq #12,%d2 <== NOT EXECUTED
handle->shared = shared;
*file = handle;
return 0;
}
58a02: 2002 movel %d2,%d0
58a04: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
58a0a: 4e5e unlk %fp
...
0005837c <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
5837c: 4e56 ffec linkw %fp,#-20
58380: 48d7 043c moveml %d2-%d5/%a2,%sp@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
58384: 42a7 clrl %sp@-
58386: 4878 0020 pea 20 <OPER2+0xc>
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
5838a: 246e 0008 moveal %fp@(8),%a2
5838e: 242e 000c movel %fp@(12),%d2
58392: 262e 0010 movel %fp@(16),%d3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
58396: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
5839c: 508f addql #8,%sp
5839e: 4a00 tstb %d0
583a0: 6714 beqs 583b6 <rtems_rfs_file_seek+0x3a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
583a2: 2f03 movel %d3,%sp@- <== NOT EXECUTED
583a4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
583a6: 4879 0006 d4df pea 6d4df <CSWTCH.1+0xe25> <== NOT EXECUTED
583ac: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
583b2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
583b6: 206a 001a moveal %a2@(26),%a0
583ba: 4868 007c pea %a0@(124)
583be: 2f28 0090 movel %a0@(144),%sp@-
583c2: 2802 movel %d2,%d4
583c4: 2a03 movel %d3,%d5
583c6: 4eb9 0005 5988 jsr 55988 <rtems_rfs_block_get_size>
583cc: 508f addql #8,%sp
583ce: 9a81 subl %d1,%d5
583d0: 9980 subxl %d0,%d4
583d2: 641a bccs 583ee <rtems_rfs_file_seek+0x72> <== ALWAYS TAKEN
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
583d4: 486a 000e pea %a2@(14) <== NOT EXECUTED
583d8: 2f03 movel %d3,%sp@- <== NOT EXECUTED
583da: 2f02 movel %d2,%sp@- <== NOT EXECUTED
583dc: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
583e0: 2f28 0090 movel %a0@(144),%sp@- <== NOT EXECUTED
583e4: 4eb9 0005 58b6 jsr 558b6 <rtems_rfs_block_get_bpos> <== NOT EXECUTED
583ea: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
*new_pos = pos;
583ee: 206e 0014 moveal %fp@(20),%a0
return 0;
}
583f2: 4280 clrl %d0
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
*new_pos = pos;
583f4: 2082 movel %d2,%a0@
583f6: 2143 0004 movel %d3,%a0@(4)
return 0;
}
583fa: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
58400: 4e5e unlk %fp <== NOT EXECUTED
00058404 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
58404: 4e56 ffac linkw %fp,#-84
58408: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
5840c: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
58410: 266a 001a moveal %a2@(26),%a3
58414: 41eb 0032 lea %a3@(50),%a0
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
58418: 42a7 clrl %sp@-
5841a: 4878 0020 pea 20 <OPER2+0xc>
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
5841e: 242e 000c movel %fp@(12),%d2
58422: 262e 0010 movel %fp@(16),%d3
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
58426: 2d48 ffd4 movel %a0,%fp@(-44)
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
5842a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
58430: 508f addql #8,%sp
58432: 4a00 tstb %d0
58434: 6714 beqs 5844a <rtems_rfs_file_set_size+0x46> <== ALWAYS TAKEN
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
58436: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58438: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5843a: 4879 0006 d4ff pea 6d4ff <CSWTCH.1+0xe45> <== NOT EXECUTED
58440: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
58446: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5844a: 206a 001a moveal %a2@(26),%a0
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
5844e: 2002 movel %d2,%d0
58450: 8083 orl %d3,%d0
58452: 661a bnes 5846e <rtems_rfs_file_set_size+0x6a>
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
58454: 2f2e ffd4 movel %fp@(-44),%sp@-
58458: 2f28 0090 movel %a0@(144),%sp@-
5845c: 4eb9 0005 6404 jsr 56404 <rtems_rfs_block_map_free_all>
if (rc > 0)
58462: 508f addql #8,%sp
58464: 4a80 tstl %d0
58466: 6e00 0264 bgtw 586cc <rtems_rfs_file_set_size+0x2c8>
5846a: 6000 0238 braw 586a4 <rtems_rfs_file_set_size+0x2a0>
5846e: 4868 007c pea %a0@(124)
58472: 2f28 0090 movel %a0@(144),%sp@-
58476: 4eb9 0005 5988 jsr 55988 <rtems_rfs_block_get_size>
size = rtems_rfs_file_size (handle);
/*
* If the file is same size do nothing else grow or shrink it ?
*/
if (size != new_size)
5847c: 508f addql #8,%sp
5847e: 2800 movel %d0,%d4
58480: 2a01 movel %d1,%d5
58482: 9a83 subl %d3,%d5
58484: 9982 subxl %d2,%d4
58486: 6700 021c beqw 586a4 <rtems_rfs_file_set_size+0x2a0>
5848a: 286a 001a moveal %a2@(26),%a4
{
if (size < new_size)
5848e: 2800 movel %d0,%d4
58490: 2a01 movel %d1,%d5
58492: 9a83 subl %d3,%d5
58494: 9982 subxl %d2,%d4
58496: 6400 0176 bccw 5860e <rtems_rfs_file_set_size+0x20a>
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
5849a: 206c 0090 moveal %a4@(144),%a0
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
5849e: 4bf9 0005 5d1a lea 55d1a <rtems_rfs_block_map_find>,%a5
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
584a4: 2a02 movel %d2,%d5
584a6: 2c03 movel %d3,%d6
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
584a8: 240a movel %a2,%d2
584aa: 5882 addql #4,%d2
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
584ac: 260e movel %fp,%d3
584ae: 5983 subql #4,%d3
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
584b0: 9c81 subl %d1,%d6
584b2: 9b80 subxl %d0,%d5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
584b4: 2868 0008 moveal %a0@(8),%a4
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
584b8: 2d45 ffe8 movel %d5,%fp@(-24)
584bc: 2d46 ffec movel %d6,%fp@(-20)
584c0: 2a2e ffd4 movel %fp@(-44),%d5
584c4: 2d42 ffd4 movel %d2,%fp@(-44)
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
584c8: 4204 clrb %d4
while (count)
584ca: 6000 0132 braw 585fe <rtems_rfs_file_set_size+0x1fa>
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
584ce: 202b 0038 movel %a3@(56),%d0
584d2: 222b 003c movel %a3@(60),%d1
584d6: 2d40 fff0 movel %d0,%fp@(-16)
584da: 2d41 fff4 movel %d1,%fp@(-12)
584de: 42ae fff8 clrl %fp@(-8)
584e2: 4a81 tstl %d1
584e4: 6706 beqs 584ec <rtems_rfs_file_set_size+0xe8>
584e6: 5380 subql #1,%d0
584e8: 2d40 fff0 movel %d0,%fp@(-16)
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
584ec: 2f03 movel %d3,%sp@-
584ee: 486e fff0 pea %fp@(-16)
584f2: 2f05 movel %d5,%sp@-
584f4: 206a 001a moveal %a2@(26),%a0
584f8: 2f28 0090 movel %a0@(144),%sp@-
584fc: 4e95 jsr %a5@
map, &bpos, &block);
if (rc > 0)
584fe: 4fef 0010 lea %sp@(16),%sp
58502: 4a80 tstl %d0
58504: 6f28 bles 5852e <rtems_rfs_file_set_size+0x12a>
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
58506: 7c06 moveq #6,%d6
58508: bc80 cmpl %d0,%d6
5850a: 6600 01c0 bnew 586cc <rtems_rfs_file_set_size+0x2c8>
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
5850e: 2f03 movel %d3,%sp@-
58510: 4878 0001 pea 1 <ADD>
58514: 2f05 movel %d5,%sp@-
58516: 206a 001a moveal %a2@(26),%a0
5851a: 2f28 0090 movel %a0@(144),%sp@-
5851e: 4eb9 0005 5eb6 jsr 55eb6 <rtems_rfs_block_map_grow>
map, 1, &block);
if (rc > 0)
58524: 4fef 0010 lea %sp@(16),%sp
58528: 4a80 tstl %d0
5852a: 6e00 01a0 bgtw 586cc <rtems_rfs_file_set_size+0x2c8>
return rc;
}
if (count < (length - bpos.boff))
5852e: 202e fff4 movel %fp@(-12),%d0
58532: 220c movel %a4,%d1
58534: 9280 subl %d0,%d1
58536: 91c8 subal %a0,%a0
58538: 2d41 ffe4 movel %d1,%fp@(-28)
5853c: 222e ffe8 movel %fp@(-24),%d1
58540: 242e ffec movel %fp@(-20),%d2
58544: 2d48 ffe0 movel %a0,%fp@(-32)
58548: 2c2e ffe0 movel %fp@(-32),%d6
5854c: 2e2e ffe4 movel %fp@(-28),%d7
58550: 9487 subl %d7,%d2
58552: 9386 subxl %d6,%d1
58554: 6414 bccs 5856a <rtems_rfs_file_set_size+0x166>
{
length = count + bpos.boff;
58556: 286e ffec moveal %fp@(-20),%a4
5855a: d9c0 addal %d0,%a4
5855c: 7e01 moveq #1,%d7
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
5855e: 274c 003c movel %a4,%a3@(60)
map->dirty = true;
58562: 1747 0032 moveb %d7,%a3@(50)
read_block = true;
58566: 7801 moveq #1,%d4
58568: 600a bras 58574 <rtems_rfs_file_set_size+0x170>
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
5856a: 42ab 003c clrl %a3@(60)
map->dirty = true;
5856e: 7001 moveq #1,%d0
58570: 1740 0032 moveb %d0,%a3@(50)
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
58574: 7201 moveq #1,%d1
58576: c284 andl %d4,%d1
58578: 2f01 movel %d1,%sp@-
5857a: 2f2e fffc movel %fp@(-4),%sp@-
5857e: 2f2e ffd4 movel %fp@(-44),%sp@-
58582: 206a 001a moveal %a2@(26),%a0
58586: 2f28 0090 movel %a0@(144),%sp@-
5858a: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
58590: 4fef 0010 lea %sp@(16),%sp
58594: 4a80 tstl %d0
58596: 6e00 0134 bgtw 586cc <rtems_rfs_file_set_size+0x2c8>
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
5859a: 202e fff4 movel %fp@(-12),%d0
5859e: 240c movel %a4,%d2
585a0: 9480 subl %d0,%d2
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
585a2: 206a 000a moveal %a2@(10),%a0
memset (dst + bpos.boff, 0, length - bpos.boff);
585a6: 2f02 movel %d2,%sp@-
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
585a8: 7c01 moveq #1,%d6
block, read_block);
if (rc > 0)
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
585aa: 42a7 clrl %sp@-
585ac: d0a8 001e addl %a0@(30),%d0
585b0: 2f00 movel %d0,%sp@-
585b2: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
585b8: 1546 0004 moveb %d6,%a2@(4)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
585bc: 2f2e ffd4 movel %fp@(-44),%sp@-
585c0: 206a 001a moveal %a2@(26),%a0
585c4: 2f28 0090 movel %a0@(144),%sp@-
585c8: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
585ce: 4fef 0014 lea %sp@(20),%sp
585d2: 4a80 tstl %d0
585d4: 6e00 00f6 bgtw 586cc <rtems_rfs_file_set_size+0x2c8>
return rc;
count -= length - bpos.boff;
585d8: 200c movel %a4,%d0
585da: 90ae fff4 subl %fp@(-12),%d0
585de: 91c8 subal %a0,%a0
585e0: 2d40 ffdc movel %d0,%fp@(-36)
585e4: 2d48 ffd8 movel %a0,%fp@(-40)
585e8: 2c2e ffd8 movel %fp@(-40),%d6
585ec: 2e2e ffdc movel %fp@(-36),%d7
585f0: 9fae ffec subl %d7,%fp@(-20)
585f4: 202e ffe8 movel %fp@(-24),%d0
585f8: 9186 subxl %d6,%d0
585fa: 2d40 ffe8 movel %d0,%fp@(-24)
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
585fe: 222e ffe8 movel %fp@(-24),%d1
58602: 82ae ffec orl %fp@(-20),%d1
58606: 6600 fec6 bnew 584ce <rtems_rfs_file_set_size+0xca>
5860a: 6000 0098 braw 586a4 <rtems_rfs_file_set_size+0x2a0>
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
5860e: 2a6c 0090 moveal %a4@(144),%a5 <== NOT EXECUTED
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
58612: 4286 clrl %d6 <== NOT EXECUTED
58614: 2e2d 0008 movel %a5@(8),%d7 <== NOT EXECUTED
58618: 78ff moveq #-1,%d4 <== NOT EXECUTED
5861a: 7aff moveq #-1,%d5 <== NOT EXECUTED
5861c: 2f07 movel %d7,%sp@- <== NOT EXECUTED
5861e: da83 addl %d3,%d5 <== NOT EXECUTED
58620: d982 addxl %d2,%d4 <== NOT EXECUTED
58622: 2f06 movel %d6,%sp@- <== NOT EXECUTED
58624: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58626: 2f04 movel %d4,%sp@- <== NOT EXECUTED
58628: 4eb9 0006 8874 jsr 68874 <__udivdi3> <== NOT EXECUTED
5862e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
58632: 4681 notl %d1 <== NOT EXECUTED
58634: d2ab 0038 addl %a3@(56),%d1 <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
58638: 6716 beqs 58650 <rtems_rfs_file_set_size+0x24c> <== NOT EXECUTED
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
5863a: 2f01 movel %d1,%sp@- <== NOT EXECUTED
5863c: 486c 0032 pea %a4@(50) <== NOT EXECUTED
58640: 2f0d movel %a5,%sp@- <== NOT EXECUTED
58642: 4eb9 0005 6172 jsr 56172 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
58648: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5864c: 4a80 tstl %d0 <== NOT EXECUTED
5864e: 6e7c bgts 586cc <rtems_rfs_file_set_size+0x2c8> <== NOT EXECUTED
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
58650: 2f07 movel %d7,%sp@- <== NOT EXECUTED
58652: 7a01 moveq #1,%d5 <== NOT EXECUTED
58654: 2f06 movel %d6,%sp@- <== NOT EXECUTED
58656: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58658: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5865a: 4eb9 0006 8ca0 jsr 68ca0 <__umoddi3> <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
58660: 206a 000e moveal %a2@(14),%a0 <== NOT EXECUTED
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
58664: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58668: 1745 0032 moveb %d5,%a3@(50) <== NOT EXECUTED
5866c: 202b 0038 movel %a3@(56),%d0 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
58670: 2741 003c movel %d1,%a3@(60) <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
58674: 4a88 tstl %a0 <== NOT EXECUTED
58676: 6704 beqs 5867c <rtems_rfs_file_set_size+0x278> <== NOT EXECUTED
58678: 4a80 tstl %d0 <== NOT EXECUTED
5867a: 6712 beqs 5868e <rtems_rfs_file_set_size+0x28a> <== NOT EXECUTED
5867c: b088 cmpl %a0,%d0 <== NOT EXECUTED
5867e: 630e blss 5868e <rtems_rfs_file_set_size+0x28a> <== NOT EXECUTED
58680: 2240 moveal %d0,%a1 <== NOT EXECUTED
58682: 5389 subql #1,%a1 <== NOT EXECUTED
58684: b3c8 cmpal %a0,%a1 <== NOT EXECUTED
58686: 661c bnes 586a4 <rtems_rfs_file_set_size+0x2a0> <== NOT EXECUTED
58688: b2aa 0012 cmpl %a2@(18),%d1 <== NOT EXECUTED
5868c: 6416 bccs 586a4 <rtems_rfs_file_set_size+0x2a0> <== NOT EXECUTED
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
5868e: 2540 000e movel %d0,%a2@(14) <== NOT EXECUTED
58692: 2541 0012 movel %d1,%a2@(18) <== NOT EXECUTED
58696: 42aa 0016 clrl %a2@(22) <== NOT EXECUTED
5869a: 4a81 tstl %d1 <== NOT EXECUTED
5869c: 6706 beqs 586a4 <rtems_rfs_file_set_size+0x2a0> <== NOT EXECUTED
5869e: 5380 subql #1,%d0 <== NOT EXECUTED
586a0: 2540 000e movel %d0,%a2@(14) <== NOT EXECUTED
rtems_rfs_file_bpos (handle));
}
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
586a4: 286a 001a moveal %a2@(26),%a4
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
586a8: 7002 moveq #2,%d0
586aa: c092 andl %a2@,%d0
rtems_rfs_file_bpos (handle));
}
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
586ac: 296b 0038 007c movel %a3@(56),%a4@(124)
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
586b2: 296b 003c 0080 movel %a3@(60),%a4@(128)
if (rtems_rfs_file_update_mtime (handle))
586b8: 4a80 tstl %d0
586ba: 660e bnes 586ca <rtems_rfs_file_set_size+0x2c6> <== NEVER TAKEN
handle->shared->mtime = time (NULL);
586bc: 42a7 clrl %sp@-
586be: 4eb9 0005 f394 jsr 5f394 <time>
586c4: 588f addql #4,%sp
586c6: 2940 0088 movel %d0,%a4@(136)
return 0;
586ca: 4280 clrl %d0
}
586cc: 4cee 3cfc ffac moveml %fp@(-84),%d2-%d7/%a2-%a5
586d2: 4e5e unlk %fp <== NOT EXECUTED
0004c66c <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
4c66c: 4e56 fefc linkw %fp,#-260
4c670: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4c674: 246e 000c moveal %fp@(12),%a2
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
4c678: 4a2a 0015 tstb %a2@(21)
4c67c: 6712 beqs 4c690 <rtems_rfs_format+0x24> <== ALWAYS TAKEN
printf ("rtems-rfs: format: %s\n", name);
4c67e: 2f2e 0008 movel %fp@(8),%sp@- <== NOT EXECUTED
4c682: 4879 0006 b456 pea 6b456 <ramdisk_ops+0x18> <== NOT EXECUTED
4c688: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4c68e: 508f addql #8,%sp <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
4c690: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
4c694: 240e movel %fp,%d2
4c696: 0682 ffff ff30 addil #-208,%d2
4c69c: 42a7 clrl %sp@-
4c69e: 2f02 movel %d2,%sp@-
4c6a0: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4c6a6: 2042 moveal %d2,%a0
4c6a8: 41e8 0044 lea %a0@(68),%a0
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
4c6ac: 7005 moveq #5,%d0
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
4c6ae: 7202 moveq #2,%d1
4c6b0: 2d48 ff70 movel %a0,%fp@(-144)
head->previous = NULL;
tail->previous = head;
4c6b4: 5988 subql #4,%a0
4c6b6: 2d48 ff78 movel %a0,%fp@(-136)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4c6ba: 41ee ff84 lea %fp@(-124),%a0
4c6be: 2d48 ff80 movel %a0,%fp@(-128)
head->previous = NULL;
tail->previous = head;
4c6c2: 41ee ff80 lea %fp@(-128),%a0
4c6c6: 2d48 ff88 movel %a0,%fp@(-120)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4c6ca: 41ee ff94 lea %fp@(-108),%a0
4c6ce: 2d48 ff90 movel %a0,%fp@(-112)
head->previous = NULL;
tail->previous = head;
4c6d2: 41ee ff90 lea %fp@(-112),%a0
4c6d6: 2d48 ff98 movel %a0,%fp@(-104)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4c6da: 41ee ffa4 lea %fp@(-92),%a0
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4c6de: 2f02 movel %d2,%sp@-
4c6e0: 2f2e 0008 movel %fp@(8),%sp@-
4c6e4: 2d48 ffa0 movel %a0,%fp@(-96)
head->previous = NULL;
tail->previous = head;
4c6e8: 41ee ffa0 lea %fp@(-96),%a0
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
4c6ec: 2d40 ff6c movel %d0,%fp@(-148)
4c6f0: 2d48 ffa8 movel %a0,%fp@(-88)
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
4c6f4: 2d41 ff30 movel %d1,%fp@(-208)
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4c6f8: 4eb9 0005 690a jsr 5690a <rtems_rfs_buffer_open>
if (rc > 0)
4c6fe: 4fef 0014 lea %sp@(20),%sp
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4c702: 2600 movel %d0,%d3
if (rc > 0)
4c704: 6f16 bles 4c71c <rtems_rfs_format+0xb0> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
4c706: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c708: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4c70e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c710: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4c712: 4879 0006 b46d pea 6b46d <ramdisk_ops+0x2f> <== NOT EXECUTED
4c718: 6000 09ea braw 4d104 <rtems_rfs_format+0xa98> <== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
4c71c: 206e ff3c moveal %fp@(-196),%a0
4c720: 4aa8 0024 tstl %a0@(36)
4c724: 660c bnes 4c732 <rtems_rfs_format+0xc6> <== ALWAYS TAKEN
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
4c726: 42a7 clrl %sp@- <== NOT EXECUTED
4c728: 4879 0006 b49c pea 6b49c <ramdisk_ops+0x5e> <== NOT EXECUTED
4c72e: 6000 0492 braw 4cbc2 <rtems_rfs_format+0x556> <== NOT EXECUTED
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
4c732: 2012 movel %a2@,%d0
4c734: 2d40 ff38 movel %d0,%fp@(-200)
if (!fs->block_size)
4c738: 666e bnes 4c7a8 <rtems_rfs_format+0x13c> <== ALWAYS TAKEN
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
4c73a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
if (total_size >= GIGS (1))
4c73c: 4282 clrl %d2 <== NOT EXECUTED
4c73e: 263c 000f ffff movel #1048575,%d3 <== NOT EXECUTED
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
4c744: 4eb9 0005 8a40 jsr 58a40 <rtems_rfs_fs_media_size> <== NOT EXECUTED
if (total_size >= GIGS (1))
4c74a: 588f addql #4,%sp <== NOT EXECUTED
4c74c: 9681 subl %d1,%d3 <== NOT EXECUTED
4c74e: 9580 subxl %d0,%d2 <== NOT EXECUTED
4c750: 6432 bccs 4c784 <rtems_rfs_format+0x118> <== NOT EXECUTED
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
4c752: 7a0c moveq #12,%d5 <== NOT EXECUTED
4c754: 4283 clrl %d3 <== NOT EXECUTED
4c756: 0681 0010 0000 addil #1048576,%d1 <== NOT EXECUTED
4c75c: d183 addxl %d3,%d0 <== NOT EXECUTED
4c75e: 7614 moveq #20,%d3 <== NOT EXECUTED
4c760: 2400 movel %d0,%d2 <== NOT EXECUTED
4c762: 2001 movel %d1,%d0 <== NOT EXECUTED
4c764: e6a8 lsrl %d3,%d0 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
4c766: 163c 0001 moveb #1,%d3 <== NOT EXECUTED
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
4c76a: ebaa lsll %d5,%d2 <== NOT EXECUTED
4c76c: 8480 orl %d0,%d2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
4c76e: 701f moveq #31,%d0 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4c770: 2203 movel %d3,%d1 <== NOT EXECUTED
4c772: e1a9 lsll %d0,%d1 <== NOT EXECUTED
4c774: c282 andl %d2,%d1 <== NOT EXECUTED
4c776: 6604 bnes 4c77c <rtems_rfs_format+0x110> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
4c778: 5380 subql #1,%d0 <== NOT EXECUTED
4c77a: 66f4 bnes 4c770 <rtems_rfs_format+0x104> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
4c77c: 7201 moveq #1,%d1 <== NOT EXECUTED
4c77e: e1a9 lsll %d0,%d1 <== NOT EXECUTED
4c780: 2d41 ff38 movel %d1,%fp@(-200) <== NOT EXECUTED
}
if (fs->block_size < 512)
4c784: 2a3c 0000 01ff movel #511,%d5 <== NOT EXECUTED
4c78a: baae ff38 cmpl %fp@(-200),%d5 <== NOT EXECUTED
4c78e: 6508 bcss 4c798 <rtems_rfs_format+0x12c> <== NOT EXECUTED
fs->block_size = 512;
4c790: 307c 0200 moveaw #512,%a0 <== NOT EXECUTED
4c794: 2d48 ff38 movel %a0,%fp@(-200) <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
4c798: 203c 0000 1000 movel #4096,%d0 <== NOT EXECUTED
4c79e: b0ae ff38 cmpl %fp@(-200),%d0 <== NOT EXECUTED
4c7a2: 6404 bccs 4c7a8 <rtems_rfs_format+0x13c> <== NOT EXECUTED
fs->block_size = (4 * 1024);
4c7a4: 2d40 ff38 movel %d0,%fp@(-200) <== NOT EXECUTED
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
4c7a8: 206e ff3c moveal %fp@(-196),%a0
4c7ac: 202e ff38 movel %fp@(-200),%d0
4c7b0: 2600 movel %d0,%d3
4c7b2: 2228 0024 movel %a0@(36),%d1
4c7b6: 4c41 3002 remul %d1,%d2,%d3
4c7ba: 4a82 tstl %d2
4c7bc: 6718 beqs 4c7d6 <rtems_rfs_format+0x16a> <== ALWAYS TAKEN
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
4c7be: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4c7c0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c7c2: 4879 0006 b4c4 pea 6b4c4 <ramdisk_ops+0x86> <== NOT EXECUTED
4c7c8: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4c7ce: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4c7d2: 6000 093a braw 4d10e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
4c7d6: 222a 0004 movel %a2@(4),%d1
4c7da: e788 lsll #3,%d0
4c7dc: 2d41 ff54 movel %d1,%fp@(-172)
if (!fs->group_blocks)
4c7e0: 6604 bnes 4c7e6 <rtems_rfs_format+0x17a> <== NEVER TAKEN
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
4c7e2: 2d40 ff54 movel %d0,%fp@(-172)
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
4c7e6: b0ae ff54 cmpl %fp@(-172),%d0
4c7ea: 640a bccs 4c7f6 <rtems_rfs_format+0x18a> <== ALWAYS TAKEN
{
printf ("group block count is higher than bits in block\n");
4c7ec: 4879 0006 b502 pea 6b502 <ramdisk_ops+0xc4> <== NOT EXECUTED
4c7f2: 6000 0392 braw 4cb86 <rtems_rfs_format+0x51a> <== NOT EXECUTED
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4c7f6: 486e ff30 pea %fp@(-208)
4c7fa: 4eb9 0005 8a40 jsr 58a40 <rtems_rfs_fs_media_size>
4c800: 242e ff38 movel %fp@(-200),%d2
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c804: 2602 movel %d2,%d3
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4c806: 2f02 movel %d2,%sp@-
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c808: e78b lsll #3,%d3
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4c80a: 42a7 clrl %sp@-
4c80c: 2f01 movel %d1,%sp@-
4c80e: 2f00 movel %d0,%sp@-
4c810: 4eb9 0006 8874 jsr 68874 <__udivdi3>
4c816: 4fef 0010 lea %sp@(16),%sp
4c81a: 2801 movel %d1,%d4
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4c81c: 2f03 movel %d3,%sp@-
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4c81e: 2d41 ff34 movel %d1,%fp@(-204)
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4c822: 2f01 movel %d1,%sp@-
4c824: 4eb9 0004 c5f6 jsr 4c5f6 <rtems_rfs_rup_quotient>
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
4c82a: 222a 0008 movel %a2@(8),%d1
if (!fs->group_inodes)
4c82e: 4fef 000c lea %sp@(12),%sp
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4c832: 2d40 ff50 movel %d0,%fp@(-176)
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
4c836: 2d41 ff58 movel %d1,%fp@(-168)
if (!fs->group_inodes)
4c83a: 6632 bnes 4c86e <rtems_rfs_format+0x202> <== NEVER TAKEN
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
4c83c: 222a 000c movel %a2@(12),%d1
4c840: 6604 bnes 4c846 <rtems_rfs_format+0x1da> <== NEVER TAKEN
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
if (!fs->group_inodes)
{
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
4c842: 123c 0001 moveb #1,%d1
static int
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
4c846: 5384 subql #1,%d4
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
4c848: 4c01 4800 mulsl %d1,%d4
4c84c: 7264 moveq #100,%d1
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
4c84e: 7a38 moveq #56,%d5
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
4c850: 2f00 movel %d0,%sp@-
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
4c852: 4c41 4004 remul %d1,%d4,%d4
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
4c856: 2f04 movel %d4,%sp@-
4c858: 4eb9 0004 c5f6 jsr 4c5f6 <rtems_rfs_rup_quotient>
4c85e: 508f addql #8,%sp
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
4c860: 2202 movel %d2,%d1
4c862: 4c45 1001 remul %d5,%d1,%d1
4c866: 4c01 0800 mulsl %d1,%d0
4c86a: 2d40 ff58 movel %d0,%fp@(-168)
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
4c86e: 7238 moveq #56,%d1
4c870: 4c41 2002 remul %d1,%d2,%d2
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
4c874: 2f02 movel %d2,%sp@-
4c876: 2f2e ff58 movel %fp@(-168),%sp@-
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
4c87a: 2d42 ff5c movel %d2,%fp@(-164)
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
4c87e: 4eb9 0004 c5f6 jsr 4c5f6 <rtems_rfs_rup_quotient>
4c884: 508f addql #8,%sp
fs->inodes_per_block) * fs->inodes_per_block;
4c886: 4c00 2800 mulsl %d0,%d2
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
4c88a: 2d42 ff58 movel %d2,%fp@(-168)
rtems_rfs_rup_quotient (fs->group_inodes,
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
4c88e: b682 cmpl %d2,%d3
4c890: 6404 bccs 4c896 <rtems_rfs_format+0x22a> <== ALWAYS TAKEN
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
4c892: 2d43 ff58 movel %d3,%fp@(-168) <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
4c896: 202a 0010 movel %a2@(16),%d0
4c89a: 2d40 ff48 movel %d0,%fp@(-184)
if (!fs->max_name_length)
4c89e: 6600 087e bnew 4d11e <rtems_rfs_format+0xab2>
{
fs->max_name_length = 512;
4c8a2: 243c 0000 0200 movel #512,%d2
4c8a8: 2d42 ff48 movel %d2,%fp@(-184)
4c8ac: 6000 0870 braw 4d11e <rtems_rfs_format+0xab2>
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
4c8b0: 49ee ff30 lea %fp@(-208),%a4 <== NOT EXECUTED
4c8b4: 47f9 0005 c170 lea 5c170 <printf>,%a3 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4c8ba: 760a moveq #10,%d3 <== NOT EXECUTED
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
4c8bc: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4c8be: 4eb9 0005 8a40 jsr 58a40 <rtems_rfs_fs_media_size> <== NOT EXECUTED
4c8c4: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4c8c6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c8c8: 4879 0006 b531 pea 6b531 <ramdisk_ops+0xf3> <== NOT EXECUTED
4c8ce: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
4c8d0: 206e ff3c moveal %fp@(-196),%a0 <== NOT EXECUTED
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
4c8d4: 2f28 001c movel %a0@(28),%sp@- <== NOT EXECUTED
4c8d8: 4879 0006 b557 pea 6b557 <ramdisk_ops+0x119> <== NOT EXECUTED
4c8de: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
rtems_rfs_fs_media_block_size (&fs));
4c8e0: 206e ff3c moveal %fp@(-196),%a0 <== NOT EXECUTED
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
4c8e4: 2f28 0024 movel %a0@(36),%sp@- <== NOT EXECUTED
4c8e8: 4879 0006 b57e pea 6b57e <ramdisk_ops+0x140> <== NOT EXECUTED
4c8ee: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
4c8f0: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4c8f4: 2e8c movel %a4,%sp@ <== NOT EXECUTED
4c8f6: 4eb9 0005 8a10 jsr 58a10 <rtems_rfs_fs_size> <== NOT EXECUTED
4c8fc: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4c8fe: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c900: 4879 0006 b5a9 pea 6b5a9 <ramdisk_ops+0x16b> <== NOT EXECUTED
4c906: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
4c908: 2f2e ff34 movel %fp@(-204),%sp@- <== NOT EXECUTED
4c90c: 4879 0006 b5c9 pea 6b5c9 <ramdisk_ops+0x18b> <== NOT EXECUTED
4c912: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
4c914: 2f2e ff38 movel %fp@(-200),%sp@- <== NOT EXECUTED
4c918: 4879 0006 b5ea pea 6b5ea <ramdisk_ops+0x1ac> <== NOT EXECUTED
4c91e: 4e93 jsr %a3@ <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c920: 202c 0008 movel %a4@(8),%d0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
4c924: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c928: e788 lsll #3,%d0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
4c92a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c92c: 4879 0006 b60f pea 6b60f <ramdisk_ops+0x1d1> <== NOT EXECUTED
4c932: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
4c934: 4878 0038 pea 38 <DBL_MANT_DIG+0x3> <== NOT EXECUTED
4c938: 4879 0006 b637 pea 6b637 <ramdisk_ops+0x1f9> <== NOT EXECUTED
4c93e: 4e93 jsr %a3@ <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
rtems_rfs_inode_overhead (&fs) % 10);
4c940: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4c942: 4eba fcd6 jsr %pc@(4c61a <rtems_rfs_inode_overhead>) <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4c946: 2a2e ff50 movel %fp@(-176),%d5 <== NOT EXECUTED
4c94a: 41ee ff58 lea %fp@(-168),%a0 <== NOT EXECUTED
4c94e: 4c43 0801 remsl %d3,%d1,%d0 <== NOT EXECUTED
4c952: 4c43 0800 remsl %d3,%d0,%d0 <== NOT EXECUTED
4c956: 2e81 movel %d1,%sp@ <== NOT EXECUTED
4c958: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c95a: 4c10 5800 mulsl %a0@,%d5 <== NOT EXECUTED
4c95e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4c960: 4879 0006 b65c pea 6b65c <ramdisk_ops+0x21e> <== NOT EXECUTED
4c966: 4e93 jsr %a3@ <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
rtems_rfs_inode_overhead (&fs) % 10);
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
4c968: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4c96c: 2eae ff50 movel %fp@(-176),%sp@ <== NOT EXECUTED
4c970: 4879 0006 b687 pea 6b687 <ramdisk_ops+0x249> <== NOT EXECUTED
4c976: 4e93 jsr %a3@ <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
4c978: 2f2e ff54 movel %fp@(-172),%sp@- <== NOT EXECUTED
4c97c: 4879 0006 b6a7 pea 6b6a7 <ramdisk_ops+0x269> <== NOT EXECUTED
4c982: 4e93 jsr %a3@ <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
4c984: 2f2e ff58 movel %fp@(-168),%sp@- <== NOT EXECUTED
4c988: 4879 0006 b6ce pea 6b6ce <ramdisk_ops+0x290> <== NOT EXECUTED
4c98e: 4e93 jsr %a3@ <== NOT EXECUTED
4c990: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
4c994: 2f2e ff38 movel %fp@(-200),%sp@-
4c998: 280e movel %fp,%d4
4c99a: 0684 ffff ff30 addil #-208,%d4
4c9a0: 2f04 movel %d4,%sp@-
4c9a2: 4eb9 0005 6b4a jsr 56b4a <rtems_rfs_buffer_setblksize>
if (rc > 0)
4c9a8: 508f addql #8,%sp
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
4c9aa: 2400 movel %d0,%d2
if (rc > 0)
4c9ac: 6f16 bles 4c9c4 <rtems_rfs_format+0x358> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
4c9ae: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c9b0: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4c9b6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c9b8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4c9ba: 4879 0006 b6f5 pea 6b6f5 <ramdisk_ops+0x2b7> <== NOT EXECUTED
4c9c0: 6000 0742 braw 4d104 <rtems_rfs_format+0xa98> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
4c9c4: 42a7 clrl %sp@-
4c9c6: 2a0e movel %fp,%d5
4c9c8: 0685 ffff ffee addil #-18,%d5
4c9ce: 42a7 clrl %sp@-
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4c9d0: 4200 clrb %d0
4c9d2: 2f05 movel %d5,%sp@-
4c9d4: 1d40 ffee moveb %d0,%fp@(-18)
4c9d8: 2f04 movel %d4,%sp@-
handle->bnum = 0;
4c9da: 42ae fff0 clrl %fp@(-16)
handle->buffer = NULL;
4c9de: 42ae fff4 clrl %fp@(-12)
4c9e2: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
4c9e8: 4fef 0010 lea %sp@(16),%sp
printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
4c9ec: 2400 movel %d0,%d2
if (rc > 0)
4c9ee: 6f1e bles 4ca0e <rtems_rfs_format+0x3a2> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4c9f0: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4c9f2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4c9f4: 4eba fbd6 jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
4c9f8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4c9fa: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4ca00: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ca02: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ca04: 4879 0006 b72b pea 6b72b <ramdisk_ops+0x2ed> <== NOT EXECUTED
4ca0a: 6000 013e braw 4cb4a <rtems_rfs_format+0x4de> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
4ca0e: 206e fff4 moveal %fp@(-12),%a0
4ca12: 2668 001e moveal %a0@(30),%a3
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
4ca16: 2f2e ff38 movel %fp@(-200),%sp@-
4ca1a: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
4ca1e: 7420 moveq #32,%d2
sb = rtems_rfs_buffer_data (&handle);
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
4ca20: 2f0b movel %a3,%sp@-
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
4ca22: 7601 moveq #1,%d3
sb = rtems_rfs_buffer_data (&handle);
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
4ca24: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
4ca2a: 4200 clrb %d0
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
4ca2c: 7209 moveq #9,%d1
4ca2e: 1742 0002 moveb %d2,%a3@(2)
4ca32: 1743 0003 moveb %d3,%a3@(3)
4ca36: 1741 0001 moveb %d1,%a3@(1)
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4ca3a: 7418 moveq #24,%d2
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
4ca3c: 16bc 0028 moveb #40,%a3@
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
4ca40: 1740 0004 moveb %d0,%a3@(4)
4ca44: 1740 0005 moveb %d0,%a3@(5)
4ca48: 1740 0006 moveb %d0,%a3@(6)
4ca4c: 1740 0007 moveb %d0,%a3@(7)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
4ca50: 4203 clrb %d3
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4ca52: 202e ff34 movel %fp@(-204),%d0
4ca56: 2200 movel %d0,%d1
4ca58: e4a9 lsrl %d2,%d1
4ca5a: 1741 000c moveb %d1,%a3@(12)
4ca5e: 2200 movel %d0,%d1
4ca60: 4241 clrw %d1
4ca62: 4841 swap %d1
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4ca64: 176e ff38 0008 moveb %fp@(-200),%a3@(8)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4ca6a: 1740 000f moveb %d0,%a3@(15)
4ca6e: 1741 000d moveb %d1,%a3@(13)
4ca72: 2200 movel %d0,%d1
4ca74: e089 lsrl #8,%d1
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4ca76: 176e ff39 0009 moveb %fp@(-199),%a3@(9)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4ca7c: 1741 000e moveb %d1,%a3@(14)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
4ca80: 7038 moveq #56,%d0
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4ca82: 176e ff3a 000a moveb %fp@(-198),%a3@(10)
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
4ca88: 7201 moveq #1,%d1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4ca8a: 176e ff3b 000b moveb %fp@(-197),%a3@(11)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
4ca90: 176e ff44 0010 moveb %fp@(-188),%a3@(16)
4ca96: 176e ff45 0011 moveb %fp@(-187),%a3@(17)
4ca9c: 176e ff46 0012 moveb %fp@(-186),%a3@(18)
4caa2: 176e ff47 0013 moveb %fp@(-185),%a3@(19)
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
4caa8: 176e ff48 0014 moveb %fp@(-184),%a3@(20)
4caae: 176e ff49 0015 moveb %fp@(-183),%a3@(21)
4cab4: 176e ff4a 0016 moveb %fp@(-182),%a3@(22)
4caba: 176e ff4b 0017 moveb %fp@(-181),%a3@(23)
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
4cac0: 176e ff50 0018 moveb %fp@(-176),%a3@(24)
4cac6: 176e ff51 0019 moveb %fp@(-175),%a3@(25)
4cacc: 176e ff52 001a moveb %fp@(-174),%a3@(26)
4cad2: 176e ff53 001b moveb %fp@(-173),%a3@(27)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
4cad8: 176e ff54 001c moveb %fp@(-172),%a3@(28)
4cade: 176e ff55 001d moveb %fp@(-171),%a3@(29)
4cae4: 176e ff56 001e moveb %fp@(-170),%a3@(30)
4caea: 176e ff57 001f moveb %fp@(-169),%a3@(31)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
4caf0: 176e ff58 0020 moveb %fp@(-168),%a3@(32)
4caf6: 176e ff59 0021 moveb %fp@(-167),%a3@(33)
4cafc: 176e ff5a 0022 moveb %fp@(-166),%a3@(34)
4cb02: 176e ff5b 0023 moveb %fp@(-165),%a3@(35)
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
4cb08: 1740 0027 moveb %d0,%a3@(39)
4cb0c: 1743 0024 moveb %d3,%a3@(36)
4cb10: 1743 0025 moveb %d3,%a3@(37)
4cb14: 1743 0026 moveb %d3,%a3@(38)
rtems_rfs_buffer_mark_dirty (&handle);
4cb18: 1d41 ffee moveb %d1,%fp@(-18)
rc = rtems_rfs_buffer_handle_release (fs, &handle);
4cb1c: 2f05 movel %d5,%sp@-
4cb1e: 2f04 movel %d4,%sp@-
4cb20: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
if (rc > 0)
4cb26: 4fef 0014 lea %sp@(20),%sp
4cb2a: 41fa faa0 lea %pc@(4c5cc <rtems_rfs_buffer_handle_close>),%a0
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
4cb2e: 2400 movel %d0,%d2
if (rc > 0)
4cb30: 6f24 bles 4cb56 <rtems_rfs_format+0x4ea> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4cb32: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cb34: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cb36: 4e90 jsr %a0@ <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
4cb38: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cb3a: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cb40: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cb42: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cb44: 4879 0006 b760 pea 6b760 <ramdisk_ops+0x322> <== NOT EXECUTED
4cb4a: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4cb50: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4cb54: 602a bras 4cb80 <rtems_rfs_format+0x514> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
4cb56: 2f05 movel %d5,%sp@-
4cb58: 2f04 movel %d4,%sp@-
4cb5a: 4e90 jsr %a0@
if (rc > 0)
4cb5c: 508f addql #8,%sp
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
4cb5e: 2400 movel %d0,%d2
if (rc > 0)
4cb60: 6f00 033a blew 4ce9c <rtems_rfs_format+0x830>
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
4cb64: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cb66: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cb6c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cb6e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cb70: 4879 0006 b79c pea 6b79c <ramdisk_ops+0x35e> <== NOT EXECUTED
4cb76: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4cb7c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
4cb80: 4879 0006 b7dd pea 6b7dd <ramdisk_ops+0x39f> <== NOT EXECUTED
4cb86: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
return -1;
4cb8c: 588f addql #4,%sp <== NOT EXECUTED
4cb8e: 6000 057e braw 4d10e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
4cb92: 206e ff2c moveal %fp@(-212),%a0
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
4cb96: 2e02 movel %d2,%d7
4cb98: 2c2e ff54 movel %fp@(-172),%d6
4cb9c: 4c06 7800 mulsl %d6,%d7
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
4cba0: 1028 0015 moveb %a0@(21),%d0
4cba4: 1228 0014 moveb %a0@(20),%d1
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
4cba8: 2647 moveal %d7,%a3
4cbaa: 528b addql #1,%a3
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
4cbac: 3440 moveaw %d0,%a2
4cbae: 1d41 ff28 moveb %d1,%fp@(-216)
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
4cbb2: 202e ff34 movel %fp@(-204),%d0
4cbb6: b08b cmpl %a3,%d0
4cbb8: 6414 bccs 4cbce <rtems_rfs_format+0x562> <== ALWAYS TAKEN
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
4cbba: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cbbc: 4879 0006 b808 pea 6b808 <ramdisk_ops+0x3ca> <== NOT EXECUTED
4cbc2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4cbc8: 508f addql #8,%sp <== NOT EXECUTED
4cbca: 6000 0542 braw 4d10e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
/*
* Be nice to strange sizes of disks. These are embedded systems after all
* and nice numbers do not always work out. Let the last block pick up the
* remainder of the blocks.
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
4cbce: 220b movel %a3,%d1
4cbd0: d286 addl %d6,%d1
4cbd2: b081 cmpl %d1,%d0
4cbd4: 6404 bccs 4cbda <rtems_rfs_format+0x56e> <== NEVER TAKEN
group_size = rtems_rfs_fs_blocks (fs) - group_base;
4cbd6: 2c00 movel %d0,%d6
4cbd8: 9c8b subl %a3,%d6
if (verbose)
4cbda: 300a movew %a2,%d0
4cbdc: 4a00 tstb %d0
4cbde: 6712 beqs 4cbf2 <rtems_rfs_format+0x586> <== ALWAYS TAKEN
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
4cbe0: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cbe2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cbe4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cbe6: 4879 0006 b841 pea 6b841 <ramdisk_ops+0x403> <== NOT EXECUTED
4cbec: 4e94 jsr %a4@ <== NOT EXECUTED
4cbee: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
4cbf2: 42ae fff0 clrl %fp@(-16)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4cbf6: 4201 clrb %d1
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
4cbf8: 300a movew %a2,%d0
handle->bnum = 0;
handle->buffer = NULL;
4cbfa: 42ae fff4 clrl %fp@(-12)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4cbfe: 1d41 ffee moveb %d1,%fp@(-18)
4cc02: 4a00 tstb %d0
4cc04: 670a beqs 4cc10 <rtems_rfs_format+0x5a4> <== ALWAYS TAKEN
printf (", blocks");
4cc06: 4879 0006 b877 pea 6b877 <ramdisk_ops+0x439> <== NOT EXECUTED
4cc0c: 4e94 jsr %a4@ <== NOT EXECUTED
4cc0e: 588f addql #4,%sp <== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4cc10: 2f0b movel %a3,%sp@-
4cc12: 2f06 movel %d6,%sp@-
4cc14: 2f05 movel %d5,%sp@-
4cc16: 2f04 movel %d4,%sp@-
4cc18: 2f03 movel %d3,%sp@-
4cc1a: 4e95 jsr %a5@
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
4cc1c: 4fef 0014 lea %sp@(20),%sp
4cc20: 4a80 tstl %d0
4cc22: 6f22 bles 4cc46 <rtems_rfs_format+0x5da> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4cc24: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cc26: 2640 moveal %d0,%a3 <== NOT EXECUTED
4cc28: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cc2a: 4eba f9a0 jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
4cc2e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cc30: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cc36: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cc38: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cc3a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cc3c: 4879 0006 b880 pea 6b880 <ramdisk_ops+0x442> <== NOT EXECUTED
4cc42: 6000 00c8 braw 4cd0c <rtems_rfs_format+0x6a0> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
4cc46: 2f2e ff38 movel %fp@(-200),%sp@-
4cc4a: 206e fff4 moveal %fp@(-12),%a0
4cc4e: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
4cc52: 2f28 001e movel %a0@(30),%sp@-
4cc56: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
4cc5c: 2f03 movel %d3,%sp@-
4cc5e: 4eb9 0005 5424 jsr 55424 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
4cc64: 4fef 0010 lea %sp@(16),%sp
4cc68: 4a80 tstl %d0
4cc6a: 6f2a bles 4cc96 <rtems_rfs_format+0x62a> <== ALWAYS TAKEN
{
rtems_rfs_bitmap_close (&bitmap);
4cc6c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4cc6e: 2640 moveal %d0,%a3 <== NOT EXECUTED
4cc70: 4eb9 0005 5626 jsr 55626 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
4cc76: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cc78: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cc7a: 4eba f950 jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
4cc7e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cc80: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cc86: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cc88: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cc8a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cc8c: 4879 0006 b8c6 pea 6b8c6 <ramdisk_ops+0x488> <== NOT EXECUTED
4cc92: 6000 0122 braw 4cdb6 <rtems_rfs_format+0x74a> <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
4cc96: 42a7 clrl %sp@-
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
4cc98: 97cb subal %a3,%a3
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
4cc9a: 2f03 movel %d3,%sp@-
4cc9c: 4eb9 0005 5288 jsr 55288 <rtems_rfs_bitmap_map_set>
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
4cca2: 4878 0001 pea 1 <ADD>
4cca6: 2f03 movel %d3,%sp@-
4cca8: 4eb9 0005 5288 jsr 55288 <rtems_rfs_bitmap_map_set>
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
4ccae: 2f2e ff5c movel %fp@(-164),%sp@-
4ccb2: 2f2e ff58 movel %fp@(-168),%sp@-
4ccb6: 4eb9 0004 c5f6 jsr 4c5f6 <rtems_rfs_rup_quotient>
4ccbc: 4fef 0018 lea %sp@(24),%sp
4ccc0: 2d40 ff24 movel %d0,%fp@(-220)
4ccc4: 6010 bras 4ccd6 <rtems_rfs_format+0x66a>
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
4ccc6: 486b 0002 pea %a3@(2)
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
4ccca: 528b addql #1,%a3
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
4cccc: 2f03 movel %d3,%sp@-
4ccce: 4eb9 0005 5288 jsr 55288 <rtems_rfs_bitmap_map_set>
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
4ccd4: 508f addql #8,%sp
4ccd6: b7ee ff24 cmpal %fp@(-220),%a3
4ccda: 6dea blts 4ccc6 <rtems_rfs_format+0x65a>
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
4ccdc: 2f03 movel %d3,%sp@-
4ccde: 4eb9 0005 5626 jsr 55626 <rtems_rfs_bitmap_close>
if (rc > 0)
4cce4: 588f addql #4,%sp
4cce6: 4a80 tstl %d0
4cce8: 6f30 bles 4cd1a <rtems_rfs_format+0x6ae> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4ccea: 486e ffee pea %fp@(-18) <== NOT EXECUTED
4ccee: 2640 moveal %d0,%a3 <== NOT EXECUTED
4ccf0: 486e ff30 pea %fp@(-208) <== NOT EXECUTED
4ccf4: 4eba f8d6 jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
4ccf8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ccfa: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cd00: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cd02: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cd04: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cd06: 4879 0006 b911 pea 6b911 <ramdisk_ops+0x4d3> <== NOT EXECUTED
4cd0c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4cd12: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4cd16: 6000 03f6 braw 4d10e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
4cd1a: 7201 moveq #1,%d1
if (verbose)
4cd1c: 300a movew %a2,%d0
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
4cd1e: 1d41 ffee moveb %d1,%fp@(-18)
if (verbose)
4cd22: 4a00 tstb %d0
4cd24: 670a beqs 4cd30 <rtems_rfs_format+0x6c4> <== ALWAYS TAKEN
printf (", inodes");
4cd26: 4879 0006 b958 pea 6b958 <ramdisk_ops+0x51a> <== NOT EXECUTED
4cd2c: 4e94 jsr %a4@ <== NOT EXECUTED
4cd2e: 588f addql #4,%sp <== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4cd30: 2047 moveal %d7,%a0
4cd32: 4868 0002 pea %a0@(2)
4cd36: 2f06 movel %d6,%sp@-
4cd38: 2f05 movel %d5,%sp@-
4cd3a: 2f04 movel %d4,%sp@-
4cd3c: 2f03 movel %d3,%sp@-
4cd3e: 4e95 jsr %a5@
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
4cd40: 4fef 0014 lea %sp@(20),%sp
4cd44: 4a80 tstl %d0
4cd46: 6f20 bles 4cd68 <rtems_rfs_format+0x6fc> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4cd48: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cd4a: 2c00 movel %d0,%d6 <== NOT EXECUTED
4cd4c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cd4e: 4eba f87c jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
4cd52: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cd54: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cd5a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cd5c: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cd5e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cd60: 4879 0006 b961 pea 6b961 <ramdisk_ops+0x523> <== NOT EXECUTED
4cd66: 60a4 bras 4cd0c <rtems_rfs_format+0x6a0> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
4cd68: 2f2e ff38 movel %fp@(-200),%sp@-
4cd6c: 45f9 0005 c0e4 lea 5c0e4 <memset>,%a2
4cd72: 206e fff4 moveal %fp@(-12),%a0
4cd76: 42a7 clrl %sp@-
4cd78: 2f28 001e movel %a0@(30),%sp@-
4cd7c: 4e92 jsr %a2@
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
4cd7e: 2f03 movel %d3,%sp@-
4cd80: 4eb9 0005 5424 jsr 55424 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
4cd86: 4fef 0010 lea %sp@(16),%sp
4cd8a: 41f9 0005 5626 lea 55626 <rtems_rfs_bitmap_close>,%a0
4cd90: 4a80 tstl %d0
4cd92: 6f30 bles 4cdc4 <rtems_rfs_format+0x758> <== ALWAYS TAKEN
{
rtems_rfs_bitmap_close (&bitmap);
4cd94: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4cd96: 2c00 movel %d0,%d6 <== NOT EXECUTED
4cd98: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
4cd9a: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cd9c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cd9e: 4eba f82c jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
4cda2: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cda4: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cdaa: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cdac: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cdae: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cdb0: 4879 0006 b9a7 pea 6b9a7 <ramdisk_ops+0x569> <== NOT EXECUTED
4cdb6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4cdbc: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
4cdc0: 6000 034c braw 4d10e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
4cdc4: 2f03 movel %d3,%sp@-
4cdc6: 4e90 jsr %a0@
if (rc > 0)
4cdc8: 588f addql #4,%sp
4cdca: 4a80 tstl %d0
4cdcc: 6f22 bles 4cdf0 <rtems_rfs_format+0x784> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4cdce: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cdd0: 2c00 movel %d0,%d6 <== NOT EXECUTED
4cdd2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cdd4: 4eba f7f6 jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
4cdd8: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cdda: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cde0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cde2: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cde4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cde6: 4879 0006 b9f2 pea 6b9f2 <ramdisk_ops+0x5b4> <== NOT EXECUTED
4cdec: 6000 ff1e braw 4cd0c <rtems_rfs_format+0x6a0> <== NOT EXECUTED
" bitmap failed: %d: %s\n", group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
4cdf0: 7001 moveq #1,%d0
4cdf2: 1d40 ffee moveb %d0,%fp@(-18)
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
4cdf6: 4a2e ff28 tstb %fp@(-216)
4cdfa: 6664 bnes 4ce60 <rtems_rfs_format+0x7f4> <== NEVER TAKEN
4cdfc: 6076 bras 4ce74 <rtems_rfs_format+0x808>
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
4cdfe: 2e2e ff28 movel %fp@(-216),%d7 <== NOT EXECUTED
4ce02: de86 addl %d6,%d7 <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
4ce04: 42a7 clrl %sp@- <== NOT EXECUTED
4ce06: 2f07 movel %d7,%sp@- <== NOT EXECUTED
4ce08: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4ce0a: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4ce0c: 4e93 jsr %a3@ <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
4ce0e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4ce12: 4a80 tstl %d0 <== NOT EXECUTED
4ce14: 6f2a bles 4ce40 <rtems_rfs_format+0x7d4> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
4ce16: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4ce18: 2640 moveal %d0,%a3 <== NOT EXECUTED
4ce1a: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4ce1c: 4eba f7ae jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
4ce20: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ce22: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4ce28: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ce2a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ce2c: 2f07 movel %d7,%sp@- <== NOT EXECUTED
4ce2e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ce30: 4879 0006 ba39 pea 6ba39 <ramdisk_ops+0x5fb> <== NOT EXECUTED
4ce36: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4ce3c: 6000 ff7e braw 4cdbc <rtems_rfs_format+0x750> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
4ce40: 2f2e ff38 movel %fp@(-200),%sp@- <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
4ce44: 5286 addql #1,%d6 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
4ce46: 4878 00ff pea ff <DBL_MANT_DIG+0xca> <== NOT EXECUTED
4ce4a: 206e fff4 moveal %fp@(-12),%a0 <== NOT EXECUTED
4ce4e: 2f28 001e movel %a0@(30),%sp@- <== NOT EXECUTED
4ce52: 4e92 jsr %a2@ <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
4ce54: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
rtems_rfs_buffer_mark_dirty (&handle);
4ce58: 7201 moveq #1,%d1 <== NOT EXECUTED
4ce5a: 1d41 ffee moveb %d1,%fp@(-18) <== NOT EXECUTED
4ce5e: 600e bras 4ce6e <rtems_rfs_format+0x802> <== NOT EXECUTED
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
4ce60: 5687 addql #3,%d7 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
4ce62: 4286 clrl %d6 <== NOT EXECUTED
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
4ce64: 47f9 0005 66f8 lea 566f8 <rtems_rfs_buffer_handle_request>,%a3<== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
4ce6a: 2d47 ff28 movel %d7,%fp@(-216) <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
4ce6e: bcae ff24 cmpl %fp@(-220),%d6 <== NOT EXECUTED
4ce72: 6d8a blts 4cdfe <rtems_rfs_format+0x792> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
4ce74: 2f05 movel %d5,%sp@-
4ce76: 2f04 movel %d4,%sp@-
4ce78: 4eba f752 jsr %pc@(4c5cc <rtems_rfs_buffer_handle_close>)
if (rc > 0)
4ce7c: 508f addql #8,%sp
4ce7e: 4a80 tstl %d0
4ce80: 6f00 02a8 blew 4d12a <rtems_rfs_format+0xabe>
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
4ce84: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ce86: 2c00 movel %d0,%d6 <== NOT EXECUTED
4ce88: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4ce8e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ce90: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4ce92: 4879 0006 ba7f pea 6ba7f <ramdisk_ops+0x641> <== NOT EXECUTED
4ce98: 6000 026a braw 4d104 <rtems_rfs_format+0xa98> <== NOT EXECUTED
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4ce9c: 260e movel %fp,%d3
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
4ce9e: 4282 clrl %d2
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
4cea0: 49f9 0005 c170 lea 5c170 <printf>,%a4
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4cea6: 0683 ffff ffd6 addil #-42,%d3
4ceac: 4bf9 0005 55ce lea 555ce <rtems_rfs_bitmap_open>,%a5
4ceb2: 2d4a ff2c movel %a2,%fp@(-212)
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
4ceb6: b4ae ff50 cmpl %fp@(-176),%d2
4ceba: 6d00 fcd6 bltw 4cb92 <rtems_rfs_format+0x526>
4cebe: 246e ff2c moveal %fp@(-212),%a2
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
4cec2: 4a2a 0015 tstb %a2@(21)
4cec6: 670c beqs 4ced4 <rtems_rfs_format+0x868> <== ALWAYS TAKEN
printf ("\n");
4cec8: 4878 000a pea a <LASTO> <== NOT EXECUTED
4cecc: 4eb9 0005 c1b0 jsr 5c1b0 <putchar> <== NOT EXECUTED
4ced2: 588f addql #4,%sp <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
4ced4: 486e ff30 pea %fp@(-208)
4ced8: 4eb9 0005 6c26 jsr 56c26 <rtems_rfs_buffer_close>
if (rc > 0)
4cede: 588f addql #4,%sp
return -1;
if (config->verbose)
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
4cee0: 2400 movel %d0,%d2
if (rc > 0)
4cee2: 6f16 bles 4cefa <rtems_rfs_format+0x88e> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
4cee4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cee6: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4ceec: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ceee: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cef0: 4879 0006 babc pea 6babc <ramdisk_ops+0x67e> <== NOT EXECUTED
4cef6: 6000 020c braw 4d104 <rtems_rfs_format+0xa98> <== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
4cefa: 486e fff8 pea %fp@(-8)
4cefe: 4878 0004 pea 4 <CONTEXT_ARG>
4cf02: 42a7 clrl %sp@-
4cf04: 2f2e 0008 movel %fp@(8),%sp@-
4cf08: 4eb9 0005 8a74 jsr 58a74 <rtems_rfs_fs_open>
if (rc < 0)
4cf0e: 4fef 0010 lea %sp@(16),%sp
4cf12: 4a80 tstl %d0
4cf14: 6c26 bges 4cf3c <rtems_rfs_format+0x8d0> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
4cf16: 45f9 0005 b6e4 lea 5b6e4 <__errno>,%a2 <== NOT EXECUTED
4cf1c: 4e92 jsr %a2@ <== NOT EXECUTED
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
4cf1e: 2040 moveal %d0,%a0 <== NOT EXECUTED
4cf20: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4cf22: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cf28: 2400 movel %d0,%d2 <== NOT EXECUTED
errno, strerror (errno));
4cf2a: 4e92 jsr %a2@ <== NOT EXECUTED
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
4cf2c: 2040 moveal %d0,%a0 <== NOT EXECUTED
4cf2e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cf30: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4cf32: 4879 0006 baec pea 6baec <ramdisk_ops+0x6ae> <== NOT EXECUTED
4cf38: 6000 01a8 braw 4d0e2 <rtems_rfs_format+0xa76> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
4cf3c: 486e fffc pea %fp@(-4)
4cf40: 4878 0001 pea 1 <ADD>
4cf44: 2f2e fff8 movel %fp@(-8),%sp@-
4cf48: 4eb9 0004 d6fc jsr 4d6fc <rtems_rfs_inode_alloc>
if (rc > 0)
4cf4e: 4fef 000c lea %sp@(12),%sp
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
4cf52: 2400 movel %d0,%d2
if (rc > 0)
4cf54: 6f2a bles 4cf80 <rtems_rfs_format+0x914> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
4cf56: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cf58: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cf5e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cf60: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cf62: 4879 0006 bb20 pea 6bb20 <ramdisk_ops+0x6e2> <== NOT EXECUTED
4cf68: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
4cf6e: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4cf72: 4eb9 0005 9222 jsr 59222 <rtems_rfs_fs_close> <== NOT EXECUTED
4cf78: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4cf7c: 6000 0174 braw 4d0f2 <rtems_rfs_format+0xa86> <== NOT EXECUTED
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
4cf80: 202e fffc movel %fp@(-4),%d0
4cf84: 7201 moveq #1,%d1
4cf86: b280 cmpl %d0,%d1
4cf88: 6720 beqs 4cfaa <rtems_rfs_format+0x93e> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
4cf8a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cf8c: 4879 0006 bb54 pea 6bb54 <ramdisk_ops+0x716> <== NOT EXECUTED
4cf92: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
4cf98: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4cf9c: 4eb9 0005 9222 jsr 59222 <rtems_rfs_fs_close> <== NOT EXECUTED
4cfa2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4cfa6: 6000 016a braw 4d112 <rtems_rfs_format+0xaa6> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4cfaa: 4878 0001 pea 1 <ADD>
4cfae: 260e movel %fp,%d3
4cfb0: 0683 ffff ffb0 addil #-80,%d3
4cfb6: 2f03 movel %d3,%sp@-
4cfb8: 4878 0001 pea 1 <ADD>
4cfbc: 2f2e fff8 movel %fp@(-8),%sp@-
4cfc0: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
4cfc6: 4fef 0010 lea %sp@(16),%sp
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4cfca: 2400 movel %d0,%d2
if (rc > 0)
4cfcc: 6f3c bles 4d00a <rtems_rfs_format+0x99e> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
4cfce: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cfd0: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4cfd6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cfd8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cfda: 4879 0006 bb8a pea 6bb8a <ramdisk_ops+0x74c> <== NOT EXECUTED
4cfe0: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
4cfe6: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4cfea: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4cfee: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4cff2: 4eb9 0004 d53a jsr 4d53a <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
4cff8: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4cffc: 4eb9 0005 9222 jsr 59222 <rtems_rfs_fs_close> <== NOT EXECUTED
4d002: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
4d006: 6000 00ea braw 4d0f2 <rtems_rfs_format+0xa86> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
4d00a: 42a7 clrl %sp@-
4d00c: 42a7 clrl %sp@-
4d00e: 4878 41c9 pea 41c9 <D_MAX_EXP+0x39ca>
4d012: 42a7 clrl %sp@-
4d014: 2f03 movel %d3,%sp@-
4d016: 4eb9 0004 db66 jsr 4db66 <rtems_rfs_inode_initialise>
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
4d01c: 4fef 0014 lea %sp@(20),%sp
rtems_rfs_group_bitmap_free (fs, true, ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
4d020: 2400 movel %d0,%d2
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
4d022: 6f1c bles 4d040 <rtems_rfs_format+0x9d4> <== ALWAYS TAKEN
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
4d024: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d026: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4d02c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d02e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d030: 4879 0006 bbb8 pea 6bbb8 <ramdisk_ops+0x77a> <== NOT EXECUTED
4d036: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d03c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
4d040: 2f2e fffc movel %fp@(-4),%sp@-
4d044: 4878 0001 pea 1 <ADD>
4d048: 4879 0006 a05a pea 6a05a <_rodata_start+0x1aa>
4d04e: 486e ffb0 pea %fp@(-80)
4d052: 2f2e fff8 movel %fp@(-8),%sp@-
4d056: 4eb9 0005 7150 jsr 57150 <rtems_rfs_dir_add_entry>
if (rc > 0)
4d05c: 4fef 0014 lea %sp@(20),%sp
0, 0);
if (rc > 0)
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
4d060: 2400 movel %d0,%d2
if (rc > 0)
4d062: 6f1c bles 4d080 <rtems_rfs_format+0xa14> <== ALWAYS TAKEN
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
4d064: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d066: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4d06c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d06e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d070: 4879 0006 bbec pea 6bbec <ramdisk_ops+0x7ae> <== NOT EXECUTED
4d076: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d07c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
4d080: 486e ffb0 pea %fp@(-80)
4d084: 2f2e fff8 movel %fp@(-8),%sp@-
4d088: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
if (rc > 0)
4d08e: 508f addql #8,%sp
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
if (rc > 0)
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
4d090: 2400 movel %d0,%d2
if (rc > 0)
4d092: 6f1c bles 4d0b0 <rtems_rfs_format+0xa44> <== ALWAYS TAKEN
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
4d094: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d096: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4d09c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d09e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d0a0: 4879 0006 bc1d pea 6bc1d <ramdisk_ops+0x7df> <== NOT EXECUTED
4d0a6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d0ac: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
4d0b0: 2f2e fff8 movel %fp@(-8),%sp@-
4d0b4: 4eb9 0005 9222 jsr 59222 <rtems_rfs_fs_close>
if (rc < 0)
4d0ba: 588f addql #4,%sp
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
4d0bc: 2400 movel %d0,%d2
if (rc < 0)
4d0be: 6c2e bges 4d0ee <rtems_rfs_format+0xa82> <== ALWAYS TAKEN
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
4d0c0: 45f9 0005 b6e4 lea 5b6e4 <__errno>,%a2 <== NOT EXECUTED
4d0c6: 4e92 jsr %a2@ <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
4d0c8: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d0ca: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4d0cc: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4d0d2: 2400 movel %d0,%d2 <== NOT EXECUTED
errno, strerror (errno));
4d0d4: 4e92 jsr %a2@ <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
4d0d6: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d0d8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d0da: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4d0dc: 4879 0006 bc4c pea 6bc4c <ramdisk_ops+0x80e> <== NOT EXECUTED
4d0e2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d0e8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d0ec: 6024 bras 4d112 <rtems_rfs_format+0xaa6> <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
4d0ee: 4a80 tstl %d0
4d0f0: 6f20 bles 4d112 <rtems_rfs_format+0xaa6> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
4d0f2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d0f4: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4d0fa: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d0fc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d0fe: 4879 0006 bc81 pea 6bc81 <ramdisk_ops+0x843> <== NOT EXECUTED
4d104: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
4d10a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d10e: 70ff moveq #-1,%d0 <== NOT EXECUTED
4d110: 6002 bras 4d114 <rtems_rfs_format+0xaa8> <== NOT EXECUTED
}
return 0;
4d112: 4280 clrl %d0
}
4d114: 4cee 3cfc fefc moveml %fp@(-260),%d2-%d7/%a2-%a5
4d11a: 4e5e unlk %fp
4d11c: 4e75 rts
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
4d11e: 4a2a 0015 tstb %a2@(21)
4d122: 6700 f870 beqw 4c994 <rtems_rfs_format+0x328>
4d126: 6000 f788 braw 4c8b0 <rtems_rfs_format+0x244> <== NOT EXECUTED
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
4d12a: 5282 addql #1,%d2
4d12c: 6000 fd88 braw 4ceb6 <rtems_rfs_format+0x84a>
00059222 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
59222: 4e56 fff0 linkw %fp,#-16
59226: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
5922a: 4878 0002 pea 2 <DOUBLE_FLOAT>
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
5922e: 246e 0008 moveal %fp@(8),%a2
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
59232: 42a7 clrl %sp@-
59234: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
5923a: 508f addql #8,%sp
5923c: 4a00 tstb %d0
5923e: 670e beqs 5924e <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
printf ("rtems-rfs: close\n");
59240: 4879 0006 d903 pea 6d903 <CSWTCH.1+0x1249> <== NOT EXECUTED
59246: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
5924c: 588f addql #4,%sp <== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
5924e: 4283 clrl %d3
59250: 4282 clrl %d2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
rtems_rfs_group_close (fs, &fs->groups[group]);
59252: 47f9 0004 d31a lea 4d31a <rtems_rfs_group_close>,%a3
59258: 6016 bras 59270 <rtems_rfs_fs_close+0x4e>
5925a: 202a 001c movel %a2@(28),%d0
5925e: d083 addl %d3,%d0
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
59260: 5282 addql #1,%d2
59262: 0683 0000 004c addil #76,%d3
rtems_rfs_group_close (fs, &fs->groups[group]);
59268: 2f00 movel %d0,%sp@-
5926a: 2f0a movel %a2,%sp@-
5926c: 4e93 jsr %a3@
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
5926e: 508f addql #8,%sp
59270: b4aa 0020 cmpl %a2@(32),%d2
59274: 6de4 blts 5925a <rtems_rfs_fs_close+0x38>
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
59276: 2f0a movel %a2,%sp@-
59278: 4eb9 0005 6c26 jsr 56c26 <rtems_rfs_buffer_close>
free (fs);
5927e: 2f0a movel %a2,%sp@-
59280: 4eb9 0004 54d0 jsr 454d0 <free>
return 0;
}
59286: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
5928c: 4280 clrl %d0
5928e: 4e5e unlk %fp
...
00058a74 <rtems_rfs_fs_open>:
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
58a74: 4e56 ff98 linkw %fp,#-104
58a78: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58a7c: 4878 0001 pea 1 <ADD>
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
58a80: 242e 0008 movel %fp@(8),%d2
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58a84: 42a7 clrl %sp@-
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
58a86: 286e 0014 moveal %fp@(20),%a4
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58a8a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
58a90: 508f addql #8,%sp
58a92: 4a00 tstb %d0
58a94: 6710 beqs 58aa6 <rtems_rfs_fs_open+0x32> <== ALWAYS TAKEN
printf ("rtems-rfs: open: %s\n", name);
58a96: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58a98: 4879 0006 d5fc pea 6d5fc <CSWTCH.1+0xf42> <== NOT EXECUTED
58a9e: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
58aa4: 508f addql #8,%sp <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
58aa6: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
58aaa: 4eb9 0004 5af0 jsr 45af0 <malloc>
if (!*fs)
58ab0: 588f addql #4,%sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
58ab2: 2880 movel %d0,%a4@
if (!*fs)
58ab4: 6630 bnes 58ae6 <rtems_rfs_fs_open+0x72> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58ab6: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58aba: 42a7 clrl %sp@- <== NOT EXECUTED
58abc: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58ac2: 508f addql #8,%sp <== NOT EXECUTED
58ac4: 4a00 tstb %d0 <== NOT EXECUTED
58ac6: 670e beqs 58ad6 <rtems_rfs_fs_open+0x62> <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
58ac8: 4879 0006 d611 pea 6d611 <CSWTCH.1+0xf57> <== NOT EXECUTED
58ace: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
58ad4: 588f addql #4,%sp <== NOT EXECUTED
errno = ENOMEM;
58ad6: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
58adc: 720c moveq #12,%d1 <== NOT EXECUTED
58ade: 2040 moveal %d0,%a0 <== NOT EXECUTED
58ae0: 2081 movel %d1,%a0@ <== NOT EXECUTED
58ae2: 6000 00dc braw 58bc0 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
58ae6: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
58aea: 42a7 clrl %sp@-
58aec: 2f00 movel %d0,%sp@-
58aee: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
(*fs)->user = user;
58af4: 2054 moveal %a4@,%a0
rtems_chain_initialize_empty (&(*fs)->buffers);
rtems_chain_initialize_empty (&(*fs)->release);
rtems_chain_initialize_empty (&(*fs)->release_modified);
rtems_chain_initialize_empty (&(*fs)->file_shares);
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
58af6: 7005 moveq #5,%d0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
58af8: 216e 000c 007c movel %fp@(12),%a0@(124)
rtems_chain_initialize_empty (&(*fs)->buffers);
58afe: 2054 moveal %a4@,%a0
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
58b00: 43e8 0044 lea %a0@(68),%a1
58b04: 2149 0040 movel %a1,%a0@(64)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58b08: 43e8 0040 lea %a0@(64),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
58b0c: 42a8 0044 clrl %a0@(68)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58b10: 2149 0048 movel %a1,%a0@(72)
rtems_chain_initialize_empty (&(*fs)->release);
58b14: 2054 moveal %a4@,%a0
Chain_Node *tail = _Chain_Tail( the_chain );
58b16: 43e8 0054 lea %a0@(84),%a1
58b1a: 2149 0050 movel %a1,%a0@(80)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58b1e: 43e8 0050 lea %a0@(80),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
58b22: 42a8 0054 clrl %a0@(84)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58b26: 2149 0058 movel %a1,%a0@(88)
rtems_chain_initialize_empty (&(*fs)->release_modified);
58b2a: 2054 moveal %a4@,%a0
Chain_Node *tail = _Chain_Tail( the_chain );
58b2c: 43e8 0064 lea %a0@(100),%a1
58b30: 2149 0060 movel %a1,%a0@(96)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58b34: 43e8 0060 lea %a0@(96),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
58b38: 42a8 0064 clrl %a0@(100)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58b3c: 2149 0068 movel %a1,%a0@(104)
rtems_chain_initialize_empty (&(*fs)->file_shares);
58b40: 2054 moveal %a4@,%a0
Chain_Node *tail = _Chain_Tail( the_chain );
58b42: 43e8 0074 lea %a0@(116),%a1
58b46: 2149 0070 movel %a1,%a0@(112)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58b4a: 43e8 0070 lea %a0@(112),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
58b4e: 42a8 0074 clrl %a0@(116)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58b52: 2149 0078 movel %a1,%a0@(120)
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
58b56: 2054 moveal %a4@,%a0
(*fs)->buffers_count = 0;
(*fs)->release_count = 0;
(*fs)->release_modified_count = 0;
(*fs)->flags = flags;
58b58: 20ae 0010 movel %fp@(16),%a0@
rtems_chain_initialize_empty (&(*fs)->buffers);
rtems_chain_initialize_empty (&(*fs)->release);
rtems_chain_initialize_empty (&(*fs)->release_modified);
rtems_chain_initialize_empty (&(*fs)->file_shares);
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
58b5c: 2140 003c movel %d0,%a0@(60)
(*fs)->buffers_count = 0;
58b60: 42a8 004c clrl %a0@(76)
(*fs)->release_count = 0;
58b64: 42a8 005c clrl %a0@(92)
(*fs)->release_modified_count = 0;
58b68: 42a8 006c clrl %a0@(108)
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
58b6c: 2f08 movel %a0,%sp@-
58b6e: 2f02 movel %d2,%sp@-
58b70: 4eb9 0005 690a jsr 5690a <rtems_rfs_buffer_open>
if (rc > 0)
58b76: 4fef 0014 lea %sp@(20),%sp
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
58b7a: 2400 movel %d0,%d2
if (rc > 0)
58b7c: 6f48 bles 58bc6 <rtems_rfs_fs_open+0x152> <== ALWAYS TAKEN
{
free (*fs);
58b7e: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
58b80: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58b86: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58b8a: 42a7 clrl %sp@- <== NOT EXECUTED
58b8c: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58b92: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
58b96: 4a00 tstb %d0 <== NOT EXECUTED
58b98: 671c beqs 58bb6 <rtems_rfs_fs_open+0x142> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
58b9a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58b9c: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
58ba2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58ba4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58ba6: 4879 0006 d641 pea 6d641 <CSWTCH.1+0xf87> <== NOT EXECUTED
58bac: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
58bb2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
58bb6: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
58bbc: 2040 moveal %d0,%a0 <== NOT EXECUTED
58bbe: 2082 movel %d2,%a0@ <== NOT EXECUTED
return -1;
58bc0: 70ff moveq #-1,%d0 <== NOT EXECUTED
58bc2: 6000 0630 braw 591f4 <rtems_rfs_fs_open+0x780> <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
58bc6: 2654 moveal %a4@,%a3
printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
58bc8: 4878 0001 pea 1 <ADD>
58bcc: 2a0e movel %fp,%d5
58bce: 0685 ffff fff6 addil #-10,%d5
58bd4: 42a7 clrl %sp@-
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
58bd6: 4200 clrb %d0
58bd8: 2f05 movel %d5,%sp@-
58bda: 1d40 fff6 moveb %d0,%fp@(-10)
58bde: 2f0b movel %a3,%sp@-
handle->bnum = 0;
58be0: 42ae fff8 clrl %fp@(-8)
handle->buffer = NULL;
58be4: 42ae fffc clrl %fp@(-4)
58be8: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
58bee: 4fef 0010 lea %sp@(16),%sp
printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
58bf2: 2400 movel %d0,%d2
if (rc > 0)
58bf4: 6f2a bles 58c20 <rtems_rfs_fs_open+0x1ac> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58bf6: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58bfa: 42a7 clrl %sp@- <== NOT EXECUTED
58bfc: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58c02: 508f addql #8,%sp <== NOT EXECUTED
58c04: 4a00 tstb %d0 <== NOT EXECUTED
58c06: 6700 0488 beqw 59090 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
58c0a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58c0c: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
58c12: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58c14: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58c16: 4879 0006 d66e pea 6d66e <CSWTCH.1+0xfb4> <== NOT EXECUTED
58c1c: 6000 0446 braw 59064 <rtems_rfs_fs_open+0x5f0> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
58c20: 206e fffc moveal %fp@(-4),%a0
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
58c24: 4280 clrl %d0
58c26: 7218 moveq #24,%d1
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
58c28: 2468 001e moveal %a0@(30),%a2
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
58c2c: 1012 moveb %a2@,%d0
58c2e: e3a8 lsll %d1,%d0
58c30: 4281 clrl %d1
58c32: 122a 0001 moveb %a2@(1),%d1
58c36: 4841 swap %d1
58c38: 4241 clrw %d1
58c3a: 8081 orl %d1,%d0
58c3c: 4281 clrl %d1
58c3e: 122a 0003 moveb %a2@(3),%d1
58c42: 8081 orl %d1,%d0
58c44: 122a 0002 moveb %a2@(2),%d1
58c48: e189 lsll #8,%d1
58c4a: 8081 orl %d1,%d0
58c4c: 0c80 2809 2001 cmpil #671686657,%d0
58c52: 671e beqs 58c72 <rtems_rfs_fs_open+0x1fe> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58c54: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58c58: 42a7 clrl %sp@- <== NOT EXECUTED
58c5a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58c60: 508f addql #8,%sp <== NOT EXECUTED
58c62: 4a00 tstb %d0 <== NOT EXECUTED
58c64: 6700 0154 beqw 58dba <rtems_rfs_fs_open+0x346> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
58c68: 4879 0006 d6a0 pea 6d6a0 <CSWTCH.1+0xfe6> <== NOT EXECUTED
58c6e: 6000 00ca braw 58d3a <rtems_rfs_fs_open+0x2c6> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
58c72: 4280 clrl %d0
58c74: 4281 clrl %d1
58c76: 102a 000c moveb %a2@(12),%d0
58c7a: 122a 000d moveb %a2@(13),%d1
58c7e: 7418 moveq #24,%d2
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
58c80: 4284 clrl %d4
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
58c82: 2c3c 0006 7f94 movel #425876,%d6
58c88: 2046 moveal %d6,%a0
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
58c8a: e5a8 lsll %d2,%d0
58c8c: 4841 swap %d1
58c8e: 4241 clrw %d1
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
58c90: 2a6b 000c moveal %a3@(12),%a5
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
58c94: 8081 orl %d1,%d0
58c96: 4281 clrl %d1
58c98: 122a 000f moveb %a2@(15),%d1
58c9c: 8081 orl %d1,%d0
58c9e: 122a 000e moveb %a2@(14),%d1
58ca2: e189 lsll #8,%d1
58ca4: 8081 orl %d1,%d0
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
58ca6: 4281 clrl %d1
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
58ca8: 2740 0004 movel %d0,%a3@(4)
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
58cac: 182a 0008 moveb %a2@(8),%d4
58cb0: 122a 0009 moveb %a2@(9),%d1
58cb4: e5ac lsll %d2,%d4
58cb6: 4841 swap %d1
58cb8: 4241 clrw %d1
58cba: 8881 orl %d1,%d4
58cbc: 4281 clrl %d1
58cbe: 122a 000b moveb %a2@(11),%d1
58cc2: 8881 orl %d1,%d4
58cc4: 122a 000a moveb %a2@(10),%d1
58cc8: e189 lsll #8,%d1
58cca: 8881 orl %d1,%d4
58ccc: 2744 0008 movel %d4,%a3@(8)
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
58cd0: 2f00 movel %d0,%sp@-
58cd2: 42a7 clrl %sp@-
58cd4: 2f04 movel %d4,%sp@-
58cd6: 42a7 clrl %sp@-
58cd8: 4e90 jsr %a0@
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
58cda: 226d 0024 moveal %a5@(36),%a1
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
58cde: 4fef 0010 lea %sp@(16),%sp
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
58ce2: 91c8 subal %a0,%a0
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
58ce4: 2a6d 001c moveal %a5@(28),%a5
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
58ce8: 2d49 ffcc movel %a1,%fp@(-52)
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
58cec: 93c9 subal %a1,%a1
58cee: 2d4d ffc4 movel %a5,%fp@(-60)
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
58cf2: 2f2e ffc4 movel %fp@(-60),%sp@-
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
58cf6: 2400 movel %d0,%d2
58cf8: 2601 movel %d1,%d3
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
58cfa: 2d49 ffc0 movel %a1,%fp@(-64)
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
58cfe: 2f2e ffc0 movel %fp@(-64),%sp@-
58d02: 2f2e ffcc movel %fp@(-52),%sp@-
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
58d06: 2d48 ffc8 movel %a0,%fp@(-56)
return media_blocks * media_block_size;
58d0a: 2f2e ffc8 movel %fp@(-56),%sp@-
58d0e: 2046 moveal %d6,%a0
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
58d10: 2c02 movel %d2,%d6
58d12: 2e03 movel %d3,%d7
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
58d14: 4e90 jsr %a0@
58d16: 4fef 0010 lea %sp@(16),%sp
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
58d1a: 9e81 subl %d1,%d7
58d1c: 9d80 subxl %d0,%d6
58d1e: 6324 blss 58d44 <rtems_rfs_fs_open+0x2d0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58d20: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58d24: 42a7 clrl %sp@- <== NOT EXECUTED
58d26: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58d2c: 508f addql #8,%sp <== NOT EXECUTED
58d2e: 4a00 tstb %d0 <== NOT EXECUTED
58d30: 6700 0088 beqw 58dba <rtems_rfs_fs_open+0x346> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
58d34: 4879 0006 d6da pea 6d6da <CSWTCH.1+0x1020> <== NOT EXECUTED
58d3a: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
58d40: 588f addql #4,%sp <== NOT EXECUTED
58d42: 6076 bras 58dba <rtems_rfs_fs_open+0x346> <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
58d44: 4280 clrl %d0
58d46: 4281 clrl %d1
58d48: 102a 0024 moveb %a2@(36),%d0
58d4c: 122a 0025 moveb %a2@(37),%d1
58d50: 7e18 moveq #24,%d7
58d52: 4841 swap %d1
58d54: 4241 clrw %d1
58d56: efa8 lsll %d7,%d0
58d58: 8081 orl %d1,%d0
58d5a: 4281 clrl %d1
58d5c: 122a 0027 moveb %a2@(39),%d1
58d60: 8081 orl %d1,%d0
58d62: 122a 0026 moveb %a2@(38),%d1
58d66: e189 lsll #8,%d1
58d68: 8081 orl %d1,%d0
58d6a: 7238 moveq #56,%d1
58d6c: b280 cmpl %d0,%d1
58d6e: 675c beqs 58dcc <rtems_rfs_fs_open+0x358> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58d70: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58d74: 42a7 clrl %sp@- <== NOT EXECUTED
58d76: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58d7c: 508f addql #8,%sp <== NOT EXECUTED
58d7e: 4a00 tstb %d0 <== NOT EXECUTED
58d80: 6738 beqs 58dba <rtems_rfs_fs_open+0x346> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
58d82: 42a7 clrl %sp@- <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
58d84: 4280 clrl %d0 <== NOT EXECUTED
58d86: 4281 clrl %d1 <== NOT EXECUTED
58d88: 102a 0004 moveb %a2@(4),%d0 <== NOT EXECUTED
58d8c: 122a 0005 moveb %a2@(5),%d1 <== NOT EXECUTED
58d90: efa8 lsll %d7,%d0 <== NOT EXECUTED
58d92: 4841 swap %d1 <== NOT EXECUTED
58d94: 4241 clrw %d1 <== NOT EXECUTED
58d96: 8081 orl %d1,%d0 <== NOT EXECUTED
58d98: 4281 clrl %d1 <== NOT EXECUTED
58d9a: 122a 0007 moveb %a2@(7),%d1 <== NOT EXECUTED
58d9e: 8081 orl %d1,%d0 <== NOT EXECUTED
58da0: 122a 0006 moveb %a2@(6),%d1 <== NOT EXECUTED
58da4: e189 lsll #8,%d1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
58da6: 8081 orl %d1,%d0 <== NOT EXECUTED
58da8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58daa: 4879 0006 d71a pea 6d71a <CSWTCH.1+0x1060> <== NOT EXECUTED
58db0: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
58db6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58dba: 486e fff6 pea %fp@(-10) <== NOT EXECUTED
58dbe: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58dc0: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
58dc6: 508f addql #8,%sp <== NOT EXECUTED
58dc8: 6000 02c0 braw 5908a <rtems_rfs_fs_open+0x616> <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
58dcc: 4280 clrl %d0
58dce: 4281 clrl %d1
58dd0: 102a 0010 moveb %a2@(16),%d0
58dd4: 122a 0011 moveb %a2@(17),%d1
58dd8: 7418 moveq #24,%d2
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
58dda: 4286 clrl %d6
58ddc: 7618 moveq #24,%d3
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
58dde: e5a8 lsll %d2,%d0
58de0: 4841 swap %d1
58de2: 4241 clrw %d1
58de4: 8081 orl %d1,%d0
58de6: 4281 clrl %d1
58de8: 122a 0013 moveb %a2@(19),%d1
58dec: 8081 orl %d1,%d0
58dee: 122a 0012 moveb %a2@(18),%d1
58df2: e189 lsll #8,%d1
58df4: 8081 orl %d1,%d0
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
58df6: 4281 clrl %d1
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
58df8: 2740 0014 movel %d0,%a3@(20)
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
58dfc: 4280 clrl %d0
58dfe: 102a 0014 moveb %a2@(20),%d0
58e02: 122a 0015 moveb %a2@(21),%d1
58e06: e5a8 lsll %d2,%d0
58e08: 4841 swap %d1
58e0a: 4241 clrw %d1
58e0c: 8081 orl %d1,%d0
58e0e: 4281 clrl %d1
58e10: 122a 0017 moveb %a2@(23),%d1
58e14: 8081 orl %d1,%d0
58e16: 122a 0016 moveb %a2@(22),%d1
58e1a: e189 lsll #8,%d1
58e1c: 8081 orl %d1,%d0
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
58e1e: 4281 clrl %d1
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
58e20: 2740 0018 movel %d0,%a3@(24)
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
58e24: 4280 clrl %d0
58e26: 122a 0018 moveb %a2@(24),%d1
58e2a: 102a 0019 moveb %a2@(25),%d0
58e2e: e5a9 lsll %d2,%d1
58e30: 4840 swap %d0
58e32: 4240 clrw %d0
58e34: 8280 orl %d0,%d1
58e36: 4280 clrl %d0
58e38: 102a 001b moveb %a2@(27),%d0
58e3c: 8280 orl %d0,%d1
58e3e: 102a 001a moveb %a2@(26),%d0
58e42: e188 lsll #8,%d0
58e44: 8280 orl %d0,%d1
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
58e46: 4280 clrl %d0
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
58e48: 2741 0020 movel %d1,%a3@(32)
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
58e4c: 102a 001c moveb %a2@(28),%d0
58e50: e5a8 lsll %d2,%d0
58e52: 4282 clrl %d2
58e54: 142a 001d moveb %a2@(29),%d2
58e58: 4842 swap %d2
58e5a: 4242 clrw %d2
58e5c: 8082 orl %d2,%d0
58e5e: 4282 clrl %d2
58e60: 142a 001f moveb %a2@(31),%d2
58e64: 8082 orl %d2,%d0
58e66: 142a 001e moveb %a2@(30),%d2
58e6a: e18a lsll #8,%d2
58e6c: 8082 orl %d2,%d0
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
58e6e: 4282 clrl %d2
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
58e70: 2740 0024 movel %d0,%a3@(36)
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
58e74: 142a 0020 moveb %a2@(32),%d2
58e78: 1c2a 0021 moveb %a2@(33),%d6
58e7c: e7aa lsll %d3,%d2
58e7e: 4846 swap %d6
58e80: 4246 clrw %d6
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
58e82: 163c 0038 moveb #56,%d3
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
58e86: 8486 orl %d6,%d2
58e88: 4286 clrl %d6
58e8a: 1c2a 0023 moveb %a2@(35),%d6
58e8e: 8486 orl %d6,%d2
58e90: 1c2a 0022 moveb %a2@(34),%d6
58e94: 45f9 0005 6580 lea 56580 <rtems_rfs_buffer_handle_release>,%a2
58e9a: e18e lsll #8,%d6
58e9c: 8486 orl %d6,%d2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
58e9e: 2c04 movel %d4,%d6
58ea0: e48e lsrl #2,%d6
fs->block_map_singly_blocks =
58ea2: 2046 moveal %d6,%a0
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
58ea4: 2742 0028 movel %d2,%a3@(40)
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
58ea8: 4c01 2800 mulsl %d1,%d2
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
58eac: 41f0 6c00 lea %a0@(00000000,%d6:l:4),%a0
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
58eb0: 2746 0030 movel %d6,%a3@(48)
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
58eb4: 4c06 6800 mulsl %d6,%d6
fs->inodes = fs->group_count * fs->group_inodes;
58eb8: 2742 0010 movel %d2,%a3@(16)
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
58ebc: 2404 movel %d4,%d2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
58ebe: 2246 moveal %d6,%a1
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
58ec0: 4c43 2002 remul %d3,%d2,%d2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
58ec4: 43f1 6c00 lea %a1@(00000000,%d6:l:4),%a1
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
58ec8: e78c lsll #3,%d4
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
58eca: 2748 0034 movel %a0,%a3@(52)
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
58ece: 2749 0038 movel %a1,%a3@(56)
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
58ed2: 2742 002c movel %d2,%a3@(44)
if (fs->group_blocks >
58ed6: b880 cmpl %d0,%d4
58ed8: 643c bccs 58f16 <rtems_rfs_fs_open+0x4a2> <== ALWAYS TAKEN
58eda: 2f05 movel %d5,%sp@- <== NOT EXECUTED
handle->dirty = false;
58edc: 4206 clrb %d6 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58ede: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58ee0: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58ee2: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
58ee6: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
58eea: 1d46 fff6 moveb %d6,%fp@(-10) <== NOT EXECUTED
58eee: 42a7 clrl %sp@- <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
58ef0: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
58ef4: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58efa: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58efe: 4a00 tstb %d0 <== NOT EXECUTED
58f00: 6700 0188 beqw 5908a <rtems_rfs_fs_open+0x616> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
58f04: 4879 0006 d75e pea 6d75e <CSWTCH.1+0x10a4> <== NOT EXECUTED
58f0a: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
58f10: 588f addql #4,%sp <== NOT EXECUTED
58f12: 6000 0176 braw 5908a <rtems_rfs_fs_open+0x616> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58f16: 2f05 movel %d5,%sp@-
handle->dirty = false;
58f18: 4207 clrb %d7
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58f1a: 2f0b movel %a3,%sp@-
58f1c: 4e92 jsr %a2@
rtems_rfs_buffer_handle_close (fs, &handle);
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
58f1e: 2f2b 0008 movel %a3@(8),%sp@-
handle->dirty = false;
handle->bnum = 0;
58f22: 42ae fff8 clrl %fp@(-8)
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
58f26: 1d47 fff6 moveb %d7,%fp@(-10)
58f2a: 2f0b movel %a3,%sp@-
handle->bnum = 0;
handle->buffer = NULL;
58f2c: 42ae fffc clrl %fp@(-4)
58f30: 4eb9 0005 6b4a jsr 56b4a <rtems_rfs_buffer_setblksize>
if (rc > 0)
58f36: 4fef 0010 lea %sp@(16),%sp
rtems_rfs_buffer_handle_close (fs, &handle);
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
58f3a: 2400 movel %d0,%d2
if (rc > 0)
58f3c: 6f3e bles 58f7c <rtems_rfs_fs_open+0x508> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58f3e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58f40: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58f42: 4e92 jsr %a2@ <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58f44: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
58f48: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
58f4c: 1d47 fff6 moveb %d7,%fp@(-10) <== NOT EXECUTED
58f50: 42a7 clrl %sp@- <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
58f52: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
58f56: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58f5c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58f60: 4a00 tstb %d0 <== NOT EXECUTED
58f62: 6700 012c beqw 59090 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
58f66: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58f68: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
58f6e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58f70: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58f72: 4879 0006 d79f pea 6d79f <CSWTCH.1+0x10e5> <== NOT EXECUTED
58f78: 6000 00ea braw 59064 <rtems_rfs_fs_open+0x5f0> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
58f7c: 4878 004c pea 4c <DBL_MANT_DIG+0x17>
58f80: 2f2b 0020 movel %a3@(32),%sp@-
58f84: 4eb9 0004 4e3c jsr 44e3c <calloc>
if (!fs->groups)
58f8a: 508f addql #8,%sp
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
58f8c: 2740 001c movel %d0,%a3@(28)
if (!fs->groups)
58f90: 6600 00e2 bnew 59074 <rtems_rfs_fs_open+0x600>
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58f94: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58f96: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58f98: 4e92 jsr %a2@ <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58f9a: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
handle->dirty = false;
58f9e: 4200 clrb %d0 <== NOT EXECUTED
58fa0: 42a7 clrl %sp@- <== NOT EXECUTED
58fa2: 1d40 fff6 moveb %d0,%fp@(-10) <== NOT EXECUTED
handle->bnum = 0;
58fa6: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
handle->buffer = NULL;
58faa: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
58fae: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
58fb4: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58fb8: 4a00 tstb %d0 <== NOT EXECUTED
58fba: 6700 00d2 beqw 5908e <rtems_rfs_fs_open+0x61a> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
58fbe: 4879 0006 d7e0 pea 6d7e0 <CSWTCH.1+0x1126> <== NOT EXECUTED
58fc4: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
58fca: 588f addql #4,%sp <== NOT EXECUTED
58fcc: 6000 00c0 braw 5908e <rtems_rfs_fs_open+0x61a> <== NOT EXECUTED
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
58fd0: 222b 001c movel %a3@(28),%d1
58fd4: d285 addl %d5,%d1
58fd6: 0685 0000 004c addil #76,%d5
rtems_rfs_fs_block (fs, group, 0),
58fdc: 202b 0024 movel %a3@(36),%d0
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
58fe0: 2f01 movel %d1,%sp@-
58fe2: 2f2b 0028 movel %a3@(40),%sp@-
58fe6: 2f00 movel %d0,%sp@-
rtems_rfs_fs_block (fs, group, 0),
58fe8: 4c04 0800 mulsl %d4,%d0
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
58fec: 2040 moveal %d0,%a0
58fee: 4868 0001 pea %a0@(1)
58ff2: 2f0b movel %a3,%sp@-
58ff4: 4e92 jsr %a2@
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
58ff6: 4fef 0014 lea %sp@(20),%sp
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
58ffa: 2400 movel %d0,%d2
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
58ffc: 6f72 bles 59070 <rtems_rfs_fs_open+0x5fc> <== ALWAYS TAKEN
58ffe: 4286 clrl %d6 <== NOT EXECUTED
59000: 4285 clrl %d5 <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
59002: 45f9 0004 d31a lea 4d31a <rtems_rfs_group_close>,%a2 <== NOT EXECUTED
59008: 6016 bras 59020 <rtems_rfs_fs_open+0x5ac> <== NOT EXECUTED
5900a: 226b 001c moveal %a3@(28),%a1 <== NOT EXECUTED
5900e: d3c6 addal %d6,%a1 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
59010: 5285 addql #1,%d5 <== NOT EXECUTED
59012: 0686 0000 004c addil #76,%d6 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
59018: 2f09 movel %a1,%sp@- <== NOT EXECUTED
5901a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5901c: 4e92 jsr %a2@ <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
5901e: 508f addql #8,%sp <== NOT EXECUTED
59020: b885 cmpl %d5,%d4 <== NOT EXECUTED
59022: 6ee6 bgts 5900a <rtems_rfs_fs_open+0x596> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
59024: 486e fff6 pea %fp@(-10) <== NOT EXECUTED
59028: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5902a: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
59030: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
handle->dirty = false;
59034: 4200 clrb %d0 <== NOT EXECUTED
59036: 42a7 clrl %sp@- <== NOT EXECUTED
59038: 1d40 fff6 moveb %d0,%fp@(-10) <== NOT EXECUTED
handle->bnum = 0;
5903c: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
handle->buffer = NULL;
59040: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
59044: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5904a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5904e: 4a00 tstb %d0 <== NOT EXECUTED
59050: 673e beqs 59090 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
59052: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59054: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
5905a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5905c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5905e: 4879 0006 d816 pea 6d816 <CSWTCH.1+0x115c> <== NOT EXECUTED
59064: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5906a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5906e: 6020 bras 59090 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
59070: 5284 addql #1,%d4
59072: 600a bras 5907e <rtems_rfs_fs_open+0x60a>
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
59074: 4285 clrl %d5
59076: 4284 clrl %d4
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
59078: 45f9 0004 d130 lea 4d130 <rtems_rfs_group_open>,%a2
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
5907e: b8ab 0020 cmpl %a3@(32),%d4
59082: 6d00 ff4c bltw 58fd0 <rtems_rfs_fs_open+0x55c>
59086: 6000 0176 braw 591fe <rtems_rfs_fs_open+0x78a>
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
return EIO;
5908a: 7405 moveq #5,%d2 <== NOT EXECUTED
5908c: 6002 bras 59090 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: no memory for group table\n");
return ENOMEM;
5908e: 740c moveq #12,%d2 <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
59090: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
59092: 4eb9 0005 6c26 jsr 56c26 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
59098: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
5909a: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
590a0: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
590a4: 42a7 clrl %sp@- <== NOT EXECUTED
590a6: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
590ac: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
590b0: 4a00 tstb %d0 <== NOT EXECUTED
590b2: 6700 fb02 beqw 58bb6 <rtems_rfs_fs_open+0x142> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
590b6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
590b8: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
590be: 2f00 movel %d0,%sp@- <== NOT EXECUTED
590c0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
590c2: 4879 0006 d853 pea 6d853 <CSWTCH.1+0x1199> <== NOT EXECUTED
590c8: 6000 fae2 braw 58bac <rtems_rfs_fs_open+0x138> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
590cc: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
590ce: 4eb9 0005 6c26 jsr 56c26 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
590d4: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
590d6: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
590dc: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
590e0: 42a7 clrl %sp@- <== NOT EXECUTED
590e2: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
590e8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
590ec: 4a00 tstb %d0 <== NOT EXECUTED
590ee: 6700 00ea beqw 591da <rtems_rfs_fs_open+0x766> <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
590f2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
590f4: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
590fa: 2f00 movel %d0,%sp@- <== NOT EXECUTED
590fc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
590fe: 4879 0006 d880 pea 6d880 <CSWTCH.1+0x11c6> <== NOT EXECUTED
59104: 6000 00ca braw 591d0 <rtems_rfs_fs_open+0x75c> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
59108: 2054 moveal %a4@,%a0
5910a: 7004 moveq #4,%d0
5910c: c090 andl %a0@,%d0
5910e: 6678 bnes 59188 <rtems_rfs_fs_open+0x714>
{
mode = rtems_rfs_inode_get_mode (&inode);
59110: 226a 000c moveal %a2@(12),%a1
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
59114: 4280 clrl %d0
59116: 1029 0002 moveb %a1@(2),%d0
5911a: 4281 clrl %d1
5911c: 1229 0003 moveb %a1@(3),%d1
59120: e188 lsll #8,%d0
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
59122: 8081 orl %d1,%d0
59124: 0c80 0000 ffff cmpil #65535,%d0
5912a: 670e beqs 5913a <rtems_rfs_fs_open+0x6c6> <== NEVER TAKEN
5912c: 0280 0000 f000 andil #61440,%d0
59132: 0c80 0000 4000 cmpil #16384,%d0
59138: 674e beqs 59188 <rtems_rfs_fs_open+0x714> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (*fs, &inode);
5913a: 486e ffd0 pea %fp@(-48) <== NOT EXECUTED
5913e: 2f08 movel %a0,%sp@- <== NOT EXECUTED
59140: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
59146: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
59148: 4eb9 0005 6c26 jsr 56c26 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
5914e: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
59150: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
59156: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5915a: 42a7 clrl %sp@- <== NOT EXECUTED
5915c: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
59162: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
59166: 4a00 tstb %d0 <== NOT EXECUTED
59168: 670e beqs 59178 <rtems_rfs_fs_open+0x704> <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
5916a: 4879 0006 d8ad pea 6d8ad <CSWTCH.1+0x11f3> <== NOT EXECUTED
59170: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
59176: 588f addql #4,%sp <== NOT EXECUTED
errno = EIO;
59178: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5917e: 2040 moveal %d0,%a0 <== NOT EXECUTED
59180: 7005 moveq #5,%d0 <== NOT EXECUTED
59182: 2080 movel %d0,%a0@ <== NOT EXECUTED
59184: 6000 fa3a braw 58bc0 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
59188: 486e ffd0 pea %fp@(-48)
5918c: 2f08 movel %a0,%sp@-
5918e: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
if (rc > 0)
59194: 508f addql #8,%sp
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
59196: 2400 movel %d0,%d2
if (rc > 0)
59198: 6f4e bles 591e8 <rtems_rfs_fs_open+0x774> <== ALWAYS TAKEN
{
rtems_rfs_buffer_close (*fs);
5919a: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
5919c: 4eb9 0005 6c26 jsr 56c26 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
591a2: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
591a4: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
591aa: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
591ae: 42a7 clrl %sp@- <== NOT EXECUTED
591b0: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
591b6: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
591ba: 4a00 tstb %d0 <== NOT EXECUTED
591bc: 671c beqs 591da <rtems_rfs_fs_open+0x766> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
591be: 2f02 movel %d2,%sp@- <== NOT EXECUTED
591c0: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
591c6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
591c8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
591ca: 4879 0006 d8d6 pea 6d8d6 <CSWTCH.1+0x121c> <== NOT EXECUTED
591d0: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
591d6: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
errno = rc;
591da: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
591e0: 2240 moveal %d0,%a1 <== NOT EXECUTED
591e2: 2282 movel %d2,%a1@ <== NOT EXECUTED
591e4: 6000 f9da braw 58bc0 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
return -1;
}
errno = 0;
591e8: 4eb9 0005 b6e4 jsr 5b6e4 <__errno>
591ee: 2040 moveal %d0,%a0
return 0;
591f0: 4280 clrl %d0
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
errno = 0;
591f2: 4290 clrl %a0@
return 0;
}
591f4: 4cee 3cfc ff98 moveml %fp@(-104),%d2-%d7/%a2-%a5
591fa: 4e5e unlk %fp
591fc: 4e75 rts
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
591fe: 4878 0001 pea 1 <ADD>
59202: 45ee ffd0 lea %fp@(-48),%a2
59206: 2f0a movel %a2,%sp@-
59208: 4878 0001 pea 1 <ADD>
5920c: 2f14 movel %a4@,%sp@-
5920e: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
59214: 4fef 0010 lea %sp@(16),%sp
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
59218: 2400 movel %d0,%d2
if (rc > 0)
5921a: 6f00 feec blew 59108 <rtems_rfs_fs_open+0x694>
5921e: 6000 feac braw 590cc <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
00058a10 <rtems_rfs_fs_size>:
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
58a10: 91c8 subal %a0,%a0 <== NOT EXECUTED
uint64_t block_size = rtems_rfs_fs_block_size (fs);
58a12: 4280 clrl %d0 <== NOT EXECUTED
#include <rtems/rfs/rtems-rfs-inode.h>
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
58a14: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
58a18: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58a1a: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
58a1e: 222a 0008 movel %a2@(8),%d1 <== NOT EXECUTED
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
58a22: 226a 0004 moveal %a2@(4),%a1 <== NOT EXECUTED
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
58a26: 2f09 movel %a1,%sp@- <== NOT EXECUTED
58a28: 2f08 movel %a0,%sp@- <== NOT EXECUTED
58a2a: 2f01 movel %d1,%sp@- <== NOT EXECUTED
58a2c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58a2e: 4eb9 0006 7f94 jsr 67f94 <__muldi3> <== NOT EXECUTED
}
58a34: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
58a38: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
58a3c: 4e5e unlk %fp <== NOT EXECUTED
0004d3b8 <rtems_rfs_group_bitmap_alloc>:
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
4d3b8: 4e56 ffc8 linkw %fp,#-56
4d3bc: 222e 000c movel %fp@(12),%d1
4d3c0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4d3c4: 162e 0013 moveb %fp@(19),%d3
4d3c8: 246e 0008 moveal %fp@(8),%a2
4d3cc: 266e 0014 moveal %fp@(20),%a3
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
4d3d0: 6708 beqs 4d3da <rtems_rfs_group_bitmap_alloc+0x22>
{
size = fs->group_inodes;
4d3d2: 202a 0028 movel %a2@(40),%d0
goal -= RTEMS_RFS_ROOT_INO;
4d3d6: 5381 subql #1,%d1
4d3d8: 6004 bras 4d3de <rtems_rfs_group_bitmap_alloc+0x26>
}
else
size = fs->group_blocks;
4d3da: 202a 0024 movel %a2@(36),%d0
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
4d3de: 4285 clrl %d5
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
if (rc > 0)
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d3e0: 4bf9 0005 6580 lea 56580 <rtems_rfs_buffer_handle_release>,%a5
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
4d3e6: 4c40 1002 remul %d0,%d2,%d1
4d3ea: 4c40 1001 remul %d0,%d1,%d1
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
bit = direction > 0 ? 0 : size - 1;
4d3ee: 5380 subql #1,%d0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
4d3f0: 2d42 fffa movel %d2,%fp@(-6)
offset = 0;
updown = true;
direction = 1;
4d3f4: 7401 moveq #1,%d2
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
4d3f6: 2d41 fff4 movel %d1,%fp@(-12)
offset = 0;
updown = true;
4d3fa: 7c01 moveq #1,%d6
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
bit = direction > 0 ? 0 : size - 1;
4d3fc: 2d40 fff0 movel %d0,%fp@(-16)
4d400: 6004 bras 4d406 <rtems_rfs_group_bitmap_alloc+0x4e>
*/
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
4d402: 74ff moveq #-1,%d2 <== NOT EXECUTED
updown = false;
4d404: 4206 clrb %d6
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
4d406: 2802 movel %d2,%d4
4d408: 4c05 4800 mulsl %d5,%d4
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
4d40c: 4200 clrb %d0
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
4d40e: d8ae fff4 addl %fp@(-12),%d4
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
4d412: 1d40 ffff moveb %d0,%fp@(-1)
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
4d416: 4a85 tstl %d5
4d418: 6712 beqs 4d42c <rtems_rfs_group_bitmap_alloc+0x74>
bit = direction > 0 ? 0 : size - 1;
4d41a: 7001 moveq #1,%d0
4d41c: b082 cmpl %d2,%d0
4d41e: 6706 beqs 4d426 <rtems_rfs_group_bitmap_alloc+0x6e>
4d420: 202e fff0 movel %fp@(-16),%d0
4d424: 6002 bras 4d428 <rtems_rfs_group_bitmap_alloc+0x70>
4d426: 4280 clrl %d0
4d428: 2d40 fffa movel %d0,%fp@(-6)
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
4d42c: 4a84 tstl %d4
4d42e: 6d06 blts 4d436 <rtems_rfs_group_bitmap_alloc+0x7e>
4d430: b8aa 0020 cmpl %a2@(32),%d4
4d434: 6d10 blts 4d446 <rtems_rfs_group_bitmap_alloc+0x8e>
{
if (!updown)
4d436: 4a06 tstb %d6
4d438: 6700 00cc beqw 4d506 <rtems_rfs_group_bitmap_alloc+0x14e>
break;
direction = direction > 0 ? -1 : 1;
4d43c: 7001 moveq #1,%d0
4d43e: b082 cmpl %d2,%d0
4d440: 67c0 beqs 4d402 <rtems_rfs_group_bitmap_alloc+0x4a><== NEVER TAKEN
4d442: 7401 moveq #1,%d2
4d444: 60be bras 4d404 <rtems_rfs_group_bitmap_alloc+0x4c>
4d446: 7e4c moveq #76,%d7
4d448: 4c04 7800 mulsl %d4,%d7
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4d44c: 286a 001c moveal %a2@(28),%a4
4d450: d9c7 addal %d7,%a4
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
4d452: 4a03 tstb %d3
4d454: 6706 beqs 4d45c <rtems_rfs_group_bitmap_alloc+0xa4>
bitmap = &fs->groups[group].inode_bitmap;
4d456: 49ec 002a lea %a4@(42),%a4
4d45a: 6002 bras 4d45e <rtems_rfs_group_bitmap_alloc+0xa6>
else
bitmap = &fs->groups[group].block_bitmap;
4d45c: 508c addql #8,%a4
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
4d45e: 486e fffa pea %fp@(-6)
4d462: 486e ffff pea %fp@(-1)
4d466: 2f2e fffa movel %fp@(-6),%sp@-
4d46a: 2f0c movel %a4,%sp@-
4d46c: 4eb9 0005 54a2 jsr 554a2 <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
4d472: 4fef 0010 lea %sp@(16),%sp
4d476: 4a80 tstl %d0
4d478: 6e00 00b6 bgtw 4d530 <rtems_rfs_group_bitmap_alloc+0x178>
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
4d47c: 7001 moveq #1,%d0
4d47e: c092 andl %a2@,%d0
4d480: 6608 bnes 4d48a <rtems_rfs_group_bitmap_alloc+0xd2><== NEVER TAKEN
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d482: 2f14 movel %a4@,%sp@-
4d484: 2f0a movel %a2,%sp@-
4d486: 4e95 jsr %a5@
4d488: 508f addql #8,%sp
if (allocated)
4d48a: 4a2e ffff tstb %fp@(-1)
4d48e: 6762 beqs 4d4f2 <rtems_rfs_group_bitmap_alloc+0x13a>
{
if (inode)
4d490: 4a03 tstb %d3
4d492: 6714 beqs 4d4a8 <rtems_rfs_group_bitmap_alloc+0xf0>
*result = rtems_rfs_group_inode (fs, group, bit);
4d494: 45ea 0028 lea %a2@(40),%a2
4d498: 4c12 4800 mulsl %a2@,%d4
4d49c: 206e fffa moveal %fp@(-6),%a0
4d4a0: 5288 addql #1,%a0
4d4a2: d1c4 addal %d4,%a0
4d4a4: 2688 movel %a0,%a3@
4d4a6: 600e bras 4d4b6 <rtems_rfs_group_bitmap_alloc+0xfe>
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
4d4a8: 206a 001c moveal %a2@(28),%a0
4d4ac: 242e fffa movel %fp@(-6),%d2
4d4b0: d4b0 7800 addl %a0@(00000000,%d7:l),%d2
4d4b4: 2682 movel %d2,%a3@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d4b6: 2f3c 0002 0000 movel #131072,%sp@-
4d4bc: 42a7 clrl %sp@-
4d4be: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d4c4: 508f addql #8,%sp
4d4c6: 4a00 tstb %d0
4d4c8: 6760 beqs 4d52a <rtems_rfs_group_bitmap_alloc+0x172><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
4d4ca: 2213 movel %a3@,%d1 <== NOT EXECUTED
4d4cc: 203c 0006 b52b movel #439595,%d0 <== NOT EXECUTED
4d4d2: 4a03 tstb %d3 <== NOT EXECUTED
4d4d4: 6706 beqs 4d4dc <rtems_rfs_group_bitmap_alloc+0x124><== NOT EXECUTED
4d4d6: 203c 0006 bdc6 movel #441798,%d0 <== NOT EXECUTED
4d4dc: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4d4de: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d4e0: 4879 0006 bdcc pea 6bdcc <ramdisk_ops+0x98e> <== NOT EXECUTED
4d4e6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d4ec: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4d4f0: 6038 bras 4d52a <rtems_rfs_group_bitmap_alloc+0x172><== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
4d4f2: 4a06 tstb %d6
4d4f4: 670a beqs 4d500 <rtems_rfs_group_bitmap_alloc+0x148><== NEVER TAKEN
direction = direction > 0 ? -1 : 1;
4d4f6: 7001 moveq #1,%d0
4d4f8: b082 cmpl %d2,%d0
4d4fa: 57c2 seq %d2
4d4fc: 49c2 extbl %d2
4d4fe: 8480 orl %d0,%d2
offset++;
4d500: 5285 addql #1,%d5
4d502: 6000 ff02 braw 4d406 <rtems_rfs_group_bitmap_alloc+0x4e>
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d506: 2f3c 0002 0000 movel #131072,%sp@-
4d50c: 42a7 clrl %sp@-
4d50e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d514: 508f addql #8,%sp
4d516: 4a00 tstb %d0
4d518: 6714 beqs 4d52e <rtems_rfs_group_bitmap_alloc+0x176><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
4d51a: 4879 0006 bdfe pea 6bdfe <ramdisk_ops+0x9c0> <== NOT EXECUTED
4d520: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
4d526: 588f addql #4,%sp <== NOT EXECUTED
4d528: 6004 bras 4d52e <rtems_rfs_group_bitmap_alloc+0x176><== NOT EXECUTED
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
4d52a: 4280 clrl %d0
4d52c: 6002 bras 4d530 <rtems_rfs_group_bitmap_alloc+0x178>
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
4d52e: 701c moveq #28,%d0
}
4d530: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4d536: 4e5e unlk %fp <== NOT EXECUTED
0004d53a <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
4d53a: 4e56 fff0 linkw %fp,#-16
4d53e: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d542: 2f3c 0002 0000 movel #131072,%sp@-
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
4d548: 246e 0008 moveal %fp@(8),%a2
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d54c: 42a7 clrl %sp@-
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
4d54e: 266e 0010 moveal %fp@(16),%a3
4d552: 142e 000f moveb %fp@(15),%d2
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d556: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d55c: 508f addql #8,%sp
4d55e: 4a00 tstb %d0
4d560: 6724 beqs 4d586 <rtems_rfs_group_bitmap_free+0x4c><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
4d562: 203c 0006 b52b movel #439595,%d0 <== NOT EXECUTED
4d568: 4a02 tstb %d2 <== NOT EXECUTED
4d56a: 6706 beqs 4d572 <rtems_rfs_group_bitmap_free+0x38><== NOT EXECUTED
4d56c: 203c 0006 bdc6 movel #441798,%d0 <== NOT EXECUTED
4d572: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d574: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d576: 4879 0006 be31 pea 6be31 <ramdisk_ops+0x9f3> <== NOT EXECUTED
4d57c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d582: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4d586: 220b movel %a3,%d1
4d588: 5381 subql #1,%d1
inode ? "inode" : "block", no);
if (inode)
4d58a: 4a02 tstb %d2
4d58c: 6706 beqs 4d594 <rtems_rfs_group_bitmap_free+0x5a><== NEVER TAKEN
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
4d58e: 202a 0028 movel %a2@(40),%d0
4d592: 6004 bras 4d598 <rtems_rfs_group_bitmap_free+0x5e>
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
4d594: 202a 0024 movel %a2@(36),%d0 <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4d598: 266a 001c moveal %a2@(28),%a3
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
4d59c: 4c40 1003 remul %d0,%d3,%d1
4d5a0: 4c40 1001 remul %d0,%d1,%d1
4d5a4: 2001 movel %d1,%d0
4d5a6: 724c moveq #76,%d1
4d5a8: 4c01 0800 mulsl %d1,%d0
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4d5ac: d7c0 addal %d0,%a3
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
4d5ae: 4a02 tstb %d2
4d5b0: 6706 beqs 4d5b8 <rtems_rfs_group_bitmap_free+0x7e><== NEVER TAKEN
bitmap = &fs->groups[group].inode_bitmap;
4d5b2: 47eb 002a lea %a3@(42),%a3
4d5b6: 6002 bras 4d5ba <rtems_rfs_group_bitmap_free+0x80>
else
bitmap = &fs->groups[group].block_bitmap;
4d5b8: 508b addql #8,%a3 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
4d5ba: 2f03 movel %d3,%sp@-
4d5bc: 2f0b movel %a3,%sp@-
4d5be: 4eb9 0005 5304 jsr 55304 <rtems_rfs_bitmap_map_clear>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d5c4: 2f13 movel %a3@,%sp@-
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
4d5c6: 2400 movel %d0,%d2
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d5c8: 2f0a movel %a2,%sp@-
4d5ca: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
return rc;
}
4d5d0: 2002 movel %d2,%d0
4d5d2: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4d5d8: 4e5e unlk %fp <== NOT EXECUTED
0004d5dc <rtems_rfs_group_bitmap_test>:
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
4d5dc: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
4d5e0: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d5e4: 2f3c 0002 0000 movel #131072,%sp@- <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
4d5ea: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d5ee: 42a7 clrl %sp@- <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
4d5f0: 242e 0010 movel %fp@(16),%d2 <== NOT EXECUTED
4d5f4: 162e 000f moveb %fp@(15),%d3 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d5f8: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
4d5fe: 508f addql #8,%sp <== NOT EXECUTED
4d600: 4a00 tstb %d0 <== NOT EXECUTED
4d602: 6724 beqs 4d628 <rtems_rfs_group_bitmap_test+0x4c><== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
4d604: 203c 0006 b52b movel #439595,%d0 <== NOT EXECUTED
4d60a: 4a03 tstb %d3 <== NOT EXECUTED
4d60c: 6706 beqs 4d614 <rtems_rfs_group_bitmap_test+0x38><== NOT EXECUTED
4d60e: 203c 0006 bdc6 movel #441798,%d0 <== NOT EXECUTED
4d614: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d616: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d618: 4879 0006 be5d pea 6be5d <ramdisk_ops+0xa1f> <== NOT EXECUTED
4d61e: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d624: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
4d628: 4a03 tstb %d3 <== NOT EXECUTED
4d62a: 6712 beqs 4d63e <rtems_rfs_group_bitmap_test+0x62><== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
4d62c: 4a82 tstl %d2 <== NOT EXECUTED
4d62e: 6f58 bles 4d688 <rtems_rfs_group_bitmap_test+0xac><== NOT EXECUTED
4d630: b4aa 0010 cmpl %a2@(16),%d2 <== NOT EXECUTED
4d634: 6252 bhis 4d688 <rtems_rfs_group_bitmap_test+0xac><== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
4d636: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
4d63a: 5382 subql #1,%d2 <== NOT EXECUTED
4d63c: 600a bras 4d648 <rtems_rfs_group_bitmap_test+0x6c><== NOT EXECUTED
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
4d63e: b4aa 0004 cmpl %a2@(4),%d2 <== NOT EXECUTED
4d642: 6444 bccs 4d688 <rtems_rfs_group_bitmap_test+0xac><== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
4d644: 202a 0024 movel %a2@(36),%d0 <== NOT EXECUTED
}
group = no / size;
4d648: 4c40 2001 remul %d0,%d1,%d2 <== NOT EXECUTED
4d64c: 4c40 2002 remul %d0,%d2,%d2 <== NOT EXECUTED
4d650: 704c moveq #76,%d0 <== NOT EXECUTED
4d652: 4c00 2800 mulsl %d0,%d2 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4d656: d4aa 001c addl %a2@(28),%d2 <== NOT EXECUTED
4d65a: 2642 moveal %d2,%a3 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
4d65c: 4a03 tstb %d3 <== NOT EXECUTED
4d65e: 6706 beqs 4d666 <rtems_rfs_group_bitmap_test+0x8a><== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
4d660: 47eb 002a lea %a3@(42),%a3 <== NOT EXECUTED
4d664: 6002 bras 4d668 <rtems_rfs_group_bitmap_test+0x8c><== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
4d666: 508b addql #8,%a3 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
4d668: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
4d66c: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4d66e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d670: 4eb9 0005 5370 jsr 55370 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d676: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
4d678: 2400 movel %d0,%d2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d67a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d67c: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
4d682: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4d686: 6002 bras 4d68a <rtems_rfs_group_bitmap_test+0xae><== NOT EXECUTED
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
4d688: 7416 moveq #22,%d2 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
rtems_rfs_bitmap_release_buffer (fs, bitmap);
return rc;
}
4d68a: 2002 movel %d2,%d0 <== NOT EXECUTED
4d68c: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3 <== NOT EXECUTED
4d692: 4e5e unlk %fp <== NOT EXECUTED
0004d31a <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
4d31a: 4e56 ffec linkw %fp,#-20
4d31e: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
4d322: 2f3c 0001 0000 movel #65536,%sp@-
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
4d328: 262e 0008 movel %fp@(8),%d3
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
4d32c: 42a7 clrl %sp@-
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
4d32e: 246e 000c moveal %fp@(12),%a2
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
4d332: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d338: 508f addql #8,%sp
4d33a: 4a00 tstb %d0
4d33c: 6710 beqs 4d34e <rtems_rfs_group_close+0x34> <== ALWAYS TAKEN
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
4d33e: 2f12 movel %a2@,%sp@- <== NOT EXECUTED
4d340: 4879 0006 bda4 pea 6bda4 <ramdisk_ops+0x966> <== NOT EXECUTED
4d346: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d34c: 508f addql #8,%sp <== NOT EXECUTED
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
4d34e: 486a 002a pea %a2@(42)
4d352: 47f9 0005 5626 lea 55626 <rtems_rfs_bitmap_close>,%a3
4d358: 4e93 jsr %a3@
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d35a: 486a 0042 pea %a2@(66)
4d35e: 2800 movel %d0,%d4
4d360: 2f03 movel %d3,%sp@-
4d362: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
4d368: 4200 clrb %d0
4d36a: 1540 0042 moveb %d0,%a2@(66)
handle->bnum = 0;
4d36e: 42aa 0044 clrl %a2@(68)
handle->buffer = NULL;
4d372: 42aa 0048 clrl %a2@(72)
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
4d376: 486a 0008 pea %a2@(8)
4d37a: 4e93 jsr %a3@
if (rc > 0)
4d37c: 4fef 0010 lea %sp@(16),%sp
4d380: 4a80 tstl %d0
4d382: 6e0c bgts 4d390 <rtems_rfs_group_close+0x76> <== NEVER TAKEN
4d384: 2404 movel %d4,%d2
4d386: 4682 notl %d2
4d388: d482 addl %d2,%d2
4d38a: 9582 subxl %d2,%d2
4d38c: c484 andl %d4,%d2
4d38e: 6002 bras 4d392 <rtems_rfs_group_close+0x78>
4d390: 2400 movel %d0,%d2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d392: 486a 0020 pea %a2@(32)
4d396: 2f03 movel %d3,%sp@-
4d398: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
4d39e: 4200 clrb %d0
4d3a0: 1540 0020 moveb %d0,%a2@(32)
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
4d3a4: 2002 movel %d2,%d0
handle->bnum = 0;
4d3a6: 42aa 0022 clrl %a2@(34)
handle->buffer = NULL;
4d3aa: 42aa 0026 clrl %a2@(38)
4d3ae: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
4d3b4: 4e5e unlk %fp <== NOT EXECUTED
0004d130 <rtems_rfs_group_open>:
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
4d130: 4e56 ffe0 linkw %fp,#-32
4d134: 222e 0014 movel %fp@(20),%d1
4d138: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@
4d13c: 266e 0008 moveal %fp@(8),%a3
4d140: 262e 000c movel %fp@(12),%d3
4d144: 242e 0010 movel %fp@(16),%d2
4d148: 246e 0018 moveal %fp@(24),%a2
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
4d14c: 202b 0004 movel %a3@(4),%d0
4d150: b083 cmpl %d3,%d0
4d152: 623a bhis 4d18e <rtems_rfs_group_open+0x5e> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
4d154: 2f3c 0000 8000 movel #32768,%sp@- <== NOT EXECUTED
4d15a: 42a7 clrl %sp@- <== NOT EXECUTED
4d15c: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
4d162: 508f addql #8,%sp <== NOT EXECUTED
4d164: 4a00 tstb %d0 <== NOT EXECUTED
4d166: 6700 01a0 beqw 4d308 <rtems_rfs_group_open+0x1d8> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
4d16a: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
4d16e: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4d174: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d176: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
4d17a: 4879 0006 bcb5 pea 6bcb5 <ramdisk_ops+0x877> <== NOT EXECUTED
4d180: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d186: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d18a: 6000 017c braw 4d308 <rtems_rfs_group_open+0x1d8> <== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
4d18e: 2042 moveal %d2,%a0
4d190: d1c3 addal %d3,%a0
4d192: b088 cmpl %a0,%d0
4d194: 6204 bhis 4d19a <rtems_rfs_group_open+0x6a> <== NEVER TAKEN
size = rtems_rfs_fs_blocks (fs) - base;
4d196: 2400 movel %d0,%d2
4d198: 9483 subl %d3,%d2
4d19a: 2a02 movel %d2,%d5
4d19c: b282 cmpl %d2,%d1
4d19e: 6402 bccs 4d1a2 <rtems_rfs_group_open+0x72> <== NEVER TAKEN
4d1a0: 2a01 movel %d1,%d5
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
4d1a2: 2f3c 0000 8000 movel #32768,%sp@-
4d1a8: 42a7 clrl %sp@-
4d1aa: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d1b0: 508f addql #8,%sp
4d1b2: 4a00 tstb %d0
4d1b4: 6716 beqs 4d1cc <rtems_rfs_group_open+0x9c> <== ALWAYS TAKEN
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
4d1b6: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4d1b8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d1ba: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4d1bc: 4879 0006 bcf4 pea 6bcf4 <ramdisk_ops+0x8b6> <== NOT EXECUTED
4d1c2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d1c8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
base, size, inodes);
group->base = base;
group->size = size;
4d1cc: 2542 0004 movel %d2,%a2@(4)
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
4d1d0: 280a movel %a2,%d4
4d1d2: 2c0a movel %a2,%d6
4d1d4: 0684 0000 0020 addil #32,%d4
4d1da: 5086 addql #8,%d6
4d1dc: 49f9 0005 55ce lea 555ce <rtems_rfs_bitmap_open>,%a4
4d1e2: 4200 clrb %d0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
4d1e4: 2483 movel %d3,%a2@
4d1e6: 1540 0020 moveb %d0,%a2@(32)
handle->bnum = 0;
4d1ea: 42aa 0022 clrl %a2@(34)
handle->buffer = NULL;
4d1ee: 42aa 0026 clrl %a2@(38)
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
4d1f2: 2f03 movel %d3,%sp@-
4d1f4: 2f02 movel %d2,%sp@-
4d1f6: 2f04 movel %d4,%sp@-
4d1f8: 2f0b movel %a3,%sp@-
4d1fa: 2f06 movel %d6,%sp@-
4d1fc: 4e94 jsr %a4@
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
4d1fe: 4fef 0014 lea %sp@(20),%sp
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
4d202: 2400 movel %d0,%d2
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
4d204: 6f46 bles 4d24c <rtems_rfs_group_open+0x11c> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d206: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4d208: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d20a: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
4d210: 4200 clrb %d0 <== NOT EXECUTED
handle->bnum = 0;
4d212: 42aa 0022 clrl %a2@(34) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
4d216: 1540 0020 moveb %d0,%a2@(32) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
4d21a: 42aa 0026 clrl %a2@(38) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
4d21e: 2f3c 0000 8000 movel #32768,%sp@- <== NOT EXECUTED
4d224: 42a7 clrl %sp@- <== NOT EXECUTED
4d226: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
4d22c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d230: 4a00 tstb %d0 <== NOT EXECUTED
4d232: 6700 00da beqw 4d30e <rtems_rfs_group_open+0x1de> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
4d236: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d238: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4d23e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d240: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d242: 4879 0006 bd2c pea 6bd2c <ramdisk_ops+0x8ee> <== NOT EXECUTED
4d248: 6000 0090 braw 4d2da <rtems_rfs_group_open+0x1aa> <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
4d24c: 42aa 0044 clrl %a2@(68)
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
4d250: 260a movel %a2,%d3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4d252: 4200 clrb %d0
handle->bnum = 0;
handle->buffer = NULL;
4d254: 42aa 0048 clrl %a2@(72)
4d258: 0683 0000 0042 addil #66,%d3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4d25e: 1540 0042 moveb %d0,%a2@(66)
4d262: 2012 movel %a2@,%d0
4d264: 5280 addql #1,%d0
4d266: 2f00 movel %d0,%sp@-
4d268: 2f05 movel %d5,%sp@-
4d26a: 2f03 movel %d3,%sp@-
4d26c: 2f0b movel %a3,%sp@-
4d26e: 486a 002a pea %a2@(42)
4d272: 4e94 jsr %a4@
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
4d274: 4fef 0014 lea %sp@(20),%sp
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
4d278: 2400 movel %d0,%d2
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
4d27a: 6f6a bles 4d2e6 <rtems_rfs_group_open+0x1b6> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d27c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4d27e: 49f9 0005 6580 lea 56580 <rtems_rfs_buffer_handle_release>,%a4<== NOT EXECUTED
4d284: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d286: 4e94 jsr %a4@ <== NOT EXECUTED
handle->dirty = false;
4d288: 4200 clrb %d0 <== NOT EXECUTED
handle->bnum = 0;
4d28a: 42aa 0044 clrl %a2@(68) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
4d28e: 1540 0042 moveb %d0,%a2@(66) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
4d292: 42aa 0048 clrl %a2@(72) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
4d296: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4d298: 4eb9 0005 5626 jsr 55626 <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d29e: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4d2a0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d2a2: 4e94 jsr %a4@ <== NOT EXECUTED
handle->dirty = false;
4d2a4: 4200 clrb %d0 <== NOT EXECUTED
handle->bnum = 0;
4d2a6: 42aa 0022 clrl %a2@(34) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
4d2aa: 1540 0020 moveb %d0,%a2@(32) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
4d2ae: 42aa 0026 clrl %a2@(38) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
4d2b2: 2f3c 0000 8000 movel #32768,%sp@- <== NOT EXECUTED
4d2b8: 42a7 clrl %sp@- <== NOT EXECUTED
4d2ba: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
4d2c0: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4d2c4: 4a00 tstb %d0 <== NOT EXECUTED
4d2c6: 6746 beqs 4d30e <rtems_rfs_group_open+0x1de> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
4d2c8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d2ca: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
4d2d0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d2d2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d2d4: 4879 0006 bd68 pea 6bd68 <ramdisk_ops+0x92a> <== NOT EXECUTED
4d2da: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d2e0: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d2e4: 6028 bras 4d30e <rtems_rfs_group_open+0x1de> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
4d2e6: 7001 moveq #1,%d0
4d2e8: c093 andl %a3@,%d0
4d2ea: 6620 bnes 4d30c <rtems_rfs_group_open+0x1dc> <== NEVER TAKEN
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
4d2ec: 2f2a 0008 movel %a2@(8),%sp@-
4d2f0: 49f9 0005 6580 lea 56580 <rtems_rfs_buffer_handle_release>,%a4
4d2f6: 2f0b movel %a3,%sp@-
4d2f8: 4e94 jsr %a4@
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
4d2fa: 2f2a 002a movel %a2@(42),%sp@-
4d2fe: 2f0b movel %a3,%sp@-
4d300: 4e94 jsr %a4@
4d302: 4fef 0010 lea %sp@(16),%sp
4d306: 6004 bras 4d30c <rtems_rfs_group_open+0x1dc>
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
4d308: 7405 moveq #5,%d2 <== NOT EXECUTED
4d30a: 6002 bras 4d30e <rtems_rfs_group_open+0x1de> <== NOT EXECUTED
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
4d30c: 4282 clrl %d2
}
4d30e: 2002 movel %d2,%d0
4d310: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
4d316: 4e5e unlk %fp <== NOT EXECUTED
0004d696 <rtems_rfs_group_usage>:
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
4d696: 4281 clrl %d1 <== NOT EXECUTED
4d698: 4280 clrl %d0 <== NOT EXECUTED
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
4d69a: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
4d69e: 226e 000c moveal %fp@(12),%a1 <== NOT EXECUTED
4d6a2: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ <== NOT EXECUTED
4d6a6: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
4d6aa: 206e 0010 moveal %fp@(16),%a0 <== NOT EXECUTED
int g;
*blocks = 0;
4d6ae: 4291 clrl %a1@ <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
4d6b0: 242a 0020 movel %a2@(32),%d2 <== NOT EXECUTED
size_t* inodes)
{
int g;
*blocks = 0;
*inodes = 0;
4d6b4: 4290 clrl %a0@ <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
4d6b6: 6022 bras 4d6da <rtems_rfs_group_usage+0x44> <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
4d6b8: 266a 001c moveal %a2@(28),%a3 <== NOT EXECUTED
4d6bc: d7c1 addal %d1,%a3 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
4d6be: 5280 addql #1,%d0 <== NOT EXECUTED
4d6c0: 0681 0000 004c addil #76,%d1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
4d6c6: 262b 0014 movel %a3@(20),%d3 <== NOT EXECUTED
4d6ca: 96ab 0018 subl %a3@(24),%d3 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
4d6ce: d791 addl %d3,%a1@ <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
4d6d0: 262b 0036 movel %a3@(54),%d3 <== NOT EXECUTED
4d6d4: 96ab 003a subl %a3@(58),%d3 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
4d6d8: d790 addl %d3,%a0@ <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
4d6da: b480 cmpl %d0,%d2 <== NOT EXECUTED
4d6dc: 6eda bgts 4d6b8 <rtems_rfs_group_usage+0x22> <== NOT EXECUTED
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
4d6de: 202a 0004 movel %a2@(4),%d0 <== NOT EXECUTED
4d6e2: b091 cmpl %a1@,%d0 <== NOT EXECUTED
4d6e4: 6402 bccs 4d6e8 <rtems_rfs_group_usage+0x52> <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
4d6e6: 2280 movel %d0,%a1@ <== NOT EXECUTED
if (*inodes > rtems_rfs_fs_inodes (fs))
4d6e8: 202a 0010 movel %a2@(16),%d0 <== NOT EXECUTED
4d6ec: b090 cmpl %a0@,%d0 <== NOT EXECUTED
4d6ee: 6402 bccs 4d6f2 <rtems_rfs_group_usage+0x5c> <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
4d6f0: 2080 movel %d0,%a0@ <== NOT EXECUTED
return 0;
}
4d6f2: 4280 clrl %d0 <== NOT EXECUTED
4d6f4: 4cd7 0c0c moveml %sp@,%d2-%d3/%a2-%a3 <== NOT EXECUTED
4d6f8: 4e5e unlk %fp <== NOT EXECUTED
0004d966 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d966: 4e56 0000 linkw %fp,#0
4d96a: 2f0a movel %a2,%sp@-
4d96c: 246e 000c moveal %fp@(12),%a2
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
4d970: 2f3c 0008 0000 movel #524288,%sp@-
4d976: 42a7 clrl %sp@-
4d978: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d97e: 508f addql #8,%sp
4d980: 4a00 tstb %d0
4d982: 6712 beqs 4d996 <rtems_rfs_inode_close+0x30> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
4d984: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4d988: 4879 0006 bf16 pea 6bf16 <ramdisk_ops+0xad8> <== NOT EXECUTED
4d98e: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d994: 508f addql #8,%sp <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
4d996: 4878 0001 pea 1 <ADD>
4d99a: 2f0a movel %a2,%sp@-
4d99c: 2f2e 0008 movel %fp@(8),%sp@-
4d9a0: 4eb9 0004 d890 jsr 4d890 <rtems_rfs_inode_unload>
if ((rc == 0) && (handle->loads > 0))
4d9a6: 4fef 000c lea %sp@(12),%sp
4d9aa: 4a80 tstl %d0
4d9ac: 662e bnes 4d9dc <rtems_rfs_inode_close+0x76> <== NEVER TAKEN
4d9ae: 4aaa 0022 tstl %a2@(34)
4d9b2: 6f28 bles 4d9dc <rtems_rfs_inode_close+0x76> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
4d9b4: 2f3c 0008 0000 movel #524288,%sp@- <== NOT EXECUTED
4d9ba: 42a7 clrl %sp@- <== NOT EXECUTED
4d9bc: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
4d9c2: 508f addql #8,%sp <== NOT EXECUTED
4d9c4: 4a00 tstb %d0 <== NOT EXECUTED
4d9c6: 6712 beqs 4d9da <rtems_rfs_inode_close+0x74> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
4d9c8: 2f2a 0022 movel %a2@(34),%sp@- <== NOT EXECUTED
4d9cc: 4879 0006 bf38 pea 6bf38 <ramdisk_ops+0xafa> <== NOT EXECUTED
4d9d2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d9d8: 508f addql #8,%sp <== NOT EXECUTED
handle->loads);
rc = EIO;
4d9da: 7005 moveq #5,%d0 <== NOT EXECUTED
}
handle->ino = 0;
4d9dc: 42aa 0008 clrl %a2@(8)
return rc;
}
4d9e0: 246e fffc moveal %fp@(-4),%a2
4d9e4: 4e5e unlk %fp <== NOT EXECUTED
0004dcc0 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
4dcc0: 4e56 ff88 linkw %fp,#-120
4dcc4: 302e 0026 movew %fp@(38),%d0
4dcc8: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
4dccc: 2f3c 0040 0000 movel #4194304,%sp@-
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
4dcd2: 242e 0008 movel %fp@(8),%d2
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
4dcd6: 42a7 clrl %sp@-
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
4dcd8: 282e 000c movel %fp@(12),%d4
4dcdc: 246e 0028 moveal %fp@(40),%a2
4dce0: 3e2e 001a movew %fp@(26),%d7
4dce4: 386e 001e moveaw %fp@(30),%a4
4dce8: 3a6e 0022 moveaw %fp@(34),%a5
4dcec: 3d40 ffb2 movew %d0,%fp@(-78)
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
4dcf0: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4dcf6: 508f addql #8,%sp
4dcf8: 4a00 tstb %d0
4dcfa: 6700 00a6 beqw 4dda2 <rtems_rfs_inode_create+0xe2>
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
4dcfe: 4285 clrl %d5 <== NOT EXECUTED
type = "dir";
4dd00: 263c 0006 a1d1 movel #434641,%d3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
4dd06: 3a07 movew %d7,%d5 <== NOT EXECUTED
4dd08: 2005 movel %d5,%d0 <== NOT EXECUTED
4dd0a: 0280 0000 f000 andil #61440,%d0 <== NOT EXECUTED
4dd10: 0c80 0000 4000 cmpil #16384,%d0 <== NOT EXECUTED
4dd16: 673e beqs 4dd56 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
4dd18: 263c 0006 bf92 movel #442258,%d3 <== NOT EXECUTED
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
4dd1e: 0c80 0000 2000 cmpil #8192,%d0 <== NOT EXECUTED
4dd24: 6730 beqs 4dd56 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
4dd26: 263c 0006 b52b movel #439595,%d3 <== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
4dd2c: 0c80 0000 6000 cmpil #24576,%d0 <== NOT EXECUTED
4dd32: 6722 beqs 4dd56 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
4dd34: 263c 0006 a145 movel #434501,%d3 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
4dd3a: 0c80 0000 8000 cmpil #32768,%d0 <== NOT EXECUTED
4dd40: 6714 beqs 4dd56 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
4dd42: 263c 0006 df38 movel #450360,%d3 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
4dd48: 0c80 0000 a000 cmpil #40960,%d0 <== NOT EXECUTED
4dd4e: 6706 beqs 4dd56 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
4dd50: 263c 0006 bf97 movel #442263,%d3 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
4dd56: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4dd58: 4879 0006 bf9f pea 6bf9f <ramdisk_ops+0xb61> <== NOT EXECUTED
for (c = 0; c < length; c++)
4dd5e: 4286 clrl %d6 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
4dd60: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4dd66: 266e 0010 moveal %fp@(16),%a3 <== NOT EXECUTED
for (c = 0; c < length; c++)
4dd6a: 508f addql #8,%sp <== NOT EXECUTED
4dd6c: 6010 bras 4dd7e <rtems_rfs_inode_create+0xbe> <== NOT EXECUTED
4dd6e: 5286 addql #1,%d6 <== NOT EXECUTED
printf ("%c", name[c]);
4dd70: 101b moveb %a3@+,%d0 <== NOT EXECUTED
4dd72: 49c0 extbl %d0 <== NOT EXECUTED
4dd74: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4dd76: 4eb9 0005 c1b0 jsr 5c1b0 <putchar> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
4dd7c: 588f addql #4,%sp <== NOT EXECUTED
4dd7e: bcae 0014 cmpl %fp@(20),%d6 <== NOT EXECUTED
4dd82: 66ea bnes 4dd6e <rtems_rfs_inode_create+0xae> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
4dd84: 2005 movel %d5,%d0 <== NOT EXECUTED
4dd86: 0280 0000 03ff andil #1023,%d0 <== NOT EXECUTED
4dd8c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4dd8e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4dd90: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4dd92: 4879 0006 bfc9 pea 6bfc9 <ramdisk_ops+0xb8b> <== NOT EXECUTED
4dd98: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4dd9e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
4dda2: 0287 0000 ffff andil #65535,%d7
4dda8: 2a07 movel %d7,%d5
4ddaa: 0285 0000 f000 andil #61440,%d5
4ddb0: 0c85 0000 6000 cmpil #24576,%d5
4ddb6: 6728 beqs 4dde0 <rtems_rfs_inode_create+0x120> <== NEVER TAKEN
4ddb8: 6e14 bgts 4ddce <rtems_rfs_inode_create+0x10e>
4ddba: 0c85 0000 2000 cmpil #8192,%d5
4ddc0: 671e beqs 4dde0 <rtems_rfs_inode_create+0x120> <== NEVER TAKEN
4ddc2: 0c85 0000 4000 cmpil #16384,%d5
4ddc8: 6600 01d8 bnew 4dfa2 <rtems_rfs_inode_create+0x2e2>
4ddcc: 6012 bras 4dde0 <rtems_rfs_inode_create+0x120>
4ddce: 0c85 0000 8000 cmpil #32768,%d5
4ddd4: 670a beqs 4dde0 <rtems_rfs_inode_create+0x120>
4ddd6: 0c85 0000 a000 cmpil #40960,%d5
4dddc: 6600 01c4 bnew 4dfa2 <rtems_rfs_inode_create+0x2e2>
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
4dde0: 2f0a movel %a2,%sp@-
4dde2: 2f04 movel %d4,%sp@-
4dde4: 2f02 movel %d2,%sp@-
4dde6: 4eb9 0004 d6fc jsr 4d6fc <rtems_rfs_inode_alloc>
if (rc > 0)
4ddec: 4fef 000c lea %sp@(12),%sp
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
4ddf0: 2600 movel %d0,%d3
if (rc > 0)
4ddf2: 6e00 01b4 bgtw 4dfa8 <rtems_rfs_inode_create+0x2e8>
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
4ddf6: 4878 0001 pea 1 <ADD>
4ddfa: 2c0e movel %fp,%d6
4ddfc: 0686 ffff ffda addil #-38,%d6
4de02: 2f06 movel %d6,%sp@-
4de04: 2f12 movel %a2@,%sp@-
4de06: 2f02 movel %d2,%sp@-
4de08: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
4de0e: 4fef 0010 lea %sp@(16),%sp
rc = rtems_rfs_inode_alloc (fs, parent, ino);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
4de12: 2600 movel %d0,%d3
if (rc > 0)
4de14: 6e00 017e bgtw 4df94 <rtems_rfs_inode_create+0x2d4>
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
4de18: 3f2e ffb2 movew %fp@(-78),%sp@-
4de1c: 4267 clrw %sp@-
4de1e: 3f0d movew %a5,%sp@-
4de20: 4267 clrw %sp@-
4de22: 2f07 movel %d7,%sp@-
4de24: 3f0c movew %a4,%sp@-
4de26: 4267 clrw %sp@-
4de28: 2f06 movel %d6,%sp@-
4de2a: 4eb9 0004 db66 jsr 4db66 <rtems_rfs_inode_initialise>
if (rc > 0)
4de30: 4fef 0014 lea %sp@(20),%sp
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
4de34: 2600 movel %d0,%d3
if (rc > 0)
4de36: 6f18 bles 4de50 <rtems_rfs_inode_create+0x190> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
4de38: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4de3a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4de3c: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
4de42: 2f12 movel %a2@,%sp@- <== NOT EXECUTED
4de44: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4de46: 4eb9 0004 d722 jsr 4d722 <rtems_rfs_inode_free> <== NOT EXECUTED
4de4c: 6000 0134 braw 4df82 <rtems_rfs_inode_create+0x2c2> <== NOT EXECUTED
/*
* Only handle the specifics of a directory. Let caller handle the others.
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
4de50: 0c85 0000 4000 cmpil #16384,%d5
4de56: 663c bnes 4de94 <rtems_rfs_inode_create+0x1d4>
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
4de58: 2f12 movel %a2@,%sp@-
4de5a: 47f9 0005 7150 lea 57150 <rtems_rfs_dir_add_entry>,%a3
4de60: 4878 0001 pea 1 <ADD>
4de64: 4879 0006 a05a pea 6a05a <_rodata_start+0x1aa>
4de6a: 2f06 movel %d6,%sp@-
4de6c: 2f02 movel %d2,%sp@-
4de6e: 4e93 jsr %a3@
if (rc == 0)
4de70: 4fef 0014 lea %sp@(20),%sp
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
4de74: 2600 movel %d0,%d3
if (rc == 0)
4de76: 6618 bnes 4de90 <rtems_rfs_inode_create+0x1d0>
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
4de78: 2f04 movel %d4,%sp@-
4de7a: 4878 0002 pea 2 <DOUBLE_FLOAT>
4de7e: 4879 0006 a059 pea 6a059 <_rodata_start+0x1a9>
4de84: 2f06 movel %d6,%sp@-
4de86: 2f02 movel %d2,%sp@-
4de88: 4e93 jsr %a3@
4de8a: 4fef 0014 lea %sp@(20),%sp
4de8e: 2600 movel %d0,%d3
if (rc > 0)
4de90: 4a83 tstl %d3
4de92: 6e1c bgts 4deb0 <rtems_rfs_inode_create+0x1f0>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4de94: 4878 0001 pea 1 <ADD>
4de98: 47ee ffb4 lea %fp@(-76),%a3
4de9c: 2f0b movel %a3,%sp@-
4de9e: 2f04 movel %d4,%sp@-
4dea0: 2f02 movel %d2,%sp@-
4dea2: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
4dea8: 4fef 0010 lea %sp@(16),%sp
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4deac: 2600 movel %d0,%d3
if (rc > 0)
4deae: 6f20 bles 4ded0 <rtems_rfs_inode_create+0x210> <== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
4deb0: 280e movel %fp,%d4
4deb2: 0684 ffff ffda addil #-38,%d4
4deb8: 2f04 movel %d4,%sp@-
4deba: 2f02 movel %d2,%sp@-
4debc: 4eb9 0004 d9e8 jsr 4d9e8 <rtems_rfs_inode_delete>
rtems_rfs_inode_close (fs, &inode);
4dec2: 2f04 movel %d4,%sp@-
4dec4: 2f02 movel %d2,%sp@-
4dec6: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
4decc: 6000 00b4 braw 4df82 <rtems_rfs_inode_create+0x2c2>
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
4ded0: 2f12 movel %a2@,%sp@-
4ded2: 2f2e 0014 movel %fp@(20),%sp@-
4ded6: 2f2e 0010 movel %fp@(16),%sp@-
4deda: 2f0b movel %a3,%sp@-
4dedc: 2f02 movel %d2,%sp@-
4dede: 4eb9 0005 7150 jsr 57150 <rtems_rfs_dir_add_entry>
if (rc > 0)
4dee4: 4fef 0014 lea %sp@(20),%sp
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
4dee8: 2600 movel %d0,%d3
if (rc > 0)
4deea: 6f2c bles 4df18 <rtems_rfs_inode_create+0x258> <== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
4deec: 280e movel %fp,%d4 <== NOT EXECUTED
4deee: 0684 ffff ffda addil #-38,%d4 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4def4: 45f9 0004 d966 lea 4d966 <rtems_rfs_inode_close>,%a2 <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
4defa: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4defc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4defe: 4eb9 0004 d9e8 jsr 4d9e8 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4df04: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4df06: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4df08: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4df0a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4df0c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4df0e: 4e92 jsr %a2@ <== NOT EXECUTED
return rc;
4df10: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4df14: 6000 0092 braw 4dfa8 <rtems_rfs_inode_create+0x2e8> <== NOT EXECUTED
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
4df18: 0c85 0000 4000 cmpil #16384,%d5
4df1e: 6636 bnes 4df56 <rtems_rfs_inode_create+0x296>
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
4df20: 206b 000c moveal %a3@(12),%a0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
4df24: 4280 clrl %d0
4df26: 1010 moveb %a0@,%d0
4df28: 4281 clrl %d1
4df2a: 1228 0001 moveb %a0@(1),%d1
4df2e: e188 lsll #8,%d0
4df30: 8081 orl %d1,%d0
if (links == 0xffff)
4df32: 3200 movew %d0,%d1
links = 0;
4df34: 0c81 0000 ffff cmpil #65535,%d1
4df3a: 56c1 sne %d1
4df3c: 4881 extw %d1
4df3e: c081 andl %d1,%d0
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
4df40: 5280 addql #1,%d0
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
4df42: 2200 movel %d0,%d1
4df44: e089 lsrl #8,%d1
4df46: 1081 moveb %d1,%a0@
4df48: 206e ffc0 moveal %fp@(-64),%a0
4df4c: 1140 0001 moveb %d0,%a0@(1)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4df50: 7001 moveq #1,%d0
4df52: 1d40 ffc4 moveb %d0,%fp@(-60)
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
4df56: 486e ffb4 pea %fp@(-76)
4df5a: 47f9 0004 d966 lea 4d966 <rtems_rfs_inode_close>,%a3
4df60: 280e movel %fp,%d4
4df62: 0684 ffff ffda addil #-38,%d4
4df68: 2f02 movel %d2,%sp@-
4df6a: 4e93 jsr %a3@
if (rc > 0)
4df6c: 508f addql #8,%sp
*/
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
4df6e: 2600 movel %d0,%d3
if (rc > 0)
4df70: 6f16 bles 4df88 <rtems_rfs_inode_create+0x2c8> <== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
4df72: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4df74: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4df76: 4eb9 0004 d9e8 jsr 4d9e8 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4df7c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4df7e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4df80: 4e93 jsr %a3@ <== NOT EXECUTED
return rc;
4df82: 4fef 0010 lea %sp@(16),%sp
4df86: 6020 bras 4dfa8 <rtems_rfs_inode_create+0x2e8>
}
rc = rtems_rfs_inode_close (fs, &inode);
4df88: 2f04 movel %d4,%sp@-
4df8a: 2f02 movel %d2,%sp@-
4df8c: 4e93 jsr %a3@
if (rc > 0)
4df8e: 508f addql #8,%sp
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
4df90: 2600 movel %d0,%d3
if (rc > 0)
4df92: 6f12 bles 4dfa6 <rtems_rfs_inode_create+0x2e6> <== ALWAYS TAKEN
{
rtems_rfs_inode_free (fs, *ino);
4df94: 2f12 movel %a2@,%sp@- <== NOT EXECUTED
4df96: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4df98: 4eb9 0004 d722 jsr 4d722 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
4df9e: 508f addql #8,%sp <== NOT EXECUTED
4dfa0: 6006 bras 4dfa8 <rtems_rfs_inode_create+0x2e8> <== NOT EXECUTED
case RTEMS_RFS_S_IFBLK:
case RTEMS_RFS_S_IFREG:
case RTEMS_RFS_S_IFLNK:
break;
default:
return EINVAL;
4dfa2: 7616 moveq #22,%d3 <== NOT EXECUTED
4dfa4: 6002 bras 4dfa8 <rtems_rfs_inode_create+0x2e8> <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
4dfa6: 4283 clrl %d3
}
4dfa8: 2003 movel %d3,%d0
4dfaa: 4cee 3cfc ff88 moveml %fp@(-120),%d2-%d7/%a2-%a5
4dfb0: 4e5e unlk %fp <== NOT EXECUTED
0004d9e8 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d9e8: 4e56 ffa8 linkw %fp,#-88
4d9ec: 48d7 040c moveml %d2-%d3/%a2,%sp@
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
4d9f0: 2f3c 0080 0000 movel #8388608,%sp@-
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d9f6: 242e 0008 movel %fp@(8),%d2
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
4d9fa: 42a7 clrl %sp@-
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d9fc: 246e 000c moveal %fp@(12),%a2
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
4da00: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4da06: 508f addql #8,%sp
4da08: 4a00 tstb %d0
4da0a: 6728 beqs 4da34 <rtems_rfs_inode_delete+0x4c> <== ALWAYS TAKEN
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
4da0c: 203c 0006 c27c movel #443004,%d0 <== NOT EXECUTED
4da12: 4aaa 000c tstl %a2@(12) <== NOT EXECUTED
4da16: 6706 beqs 4da1e <rtems_rfs_inode_delete+0x36> <== NOT EXECUTED
4da18: 203c 0006 be89 movel #441993,%d0 <== NOT EXECUTED
4da1e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4da20: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4da24: 4879 0006 bf66 pea 6bf66 <ramdisk_ops+0xb28> <== NOT EXECUTED
4da2a: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4da30: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
4da34: 4aaa 000c tstl %a2@(12)
4da38: 6774 beqs 4daae <rtems_rfs_inode_delete+0xc6> <== NEVER TAKEN
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
4da3a: 2f2a 0008 movel %a2@(8),%sp@-
4da3e: 2f02 movel %d2,%sp@-
4da40: 4eb9 0004 d722 jsr 4d722 <rtems_rfs_inode_free>
if (rc > 0)
4da46: 508f addql #8,%sp
4da48: 4a80 tstl %d0
4da4a: 6e64 bgts 4dab0 <rtems_rfs_inode_delete+0xc8> <== NEVER TAKEN
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
4da4c: 260e movel %fp,%d3
4da4e: 0683 ffff ffb6 addil #-74,%d3
4da54: 2f03 movel %d3,%sp@-
4da56: 2f0a movel %a2,%sp@-
4da58: 2f02 movel %d2,%sp@-
4da5a: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open>
if (rc == 0)
4da60: 4fef 000c lea %sp@(12),%sp
4da64: 4a80 tstl %d0
4da66: 6648 bnes 4dab0 <rtems_rfs_inode_delete+0xc8> <== NEVER TAKEN
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
4da68: 2f03 movel %d3,%sp@-
4da6a: 2f02 movel %d2,%sp@-
4da6c: 4eb9 0005 6404 jsr 56404 <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
4da72: 2f03 movel %d3,%sp@-
4da74: 2f02 movel %d2,%sp@-
4da76: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close>
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
4da7c: 4878 0038 pea 38 <DBL_MANT_DIG+0x3>
4da80: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
4da84: 2f2a 000c movel %a2@(12),%sp@-
4da88: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4da8e: 7001 moveq #1,%d0
4da90: 1540 0010 moveb %d0,%a2@(16)
/*
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
4da94: 486a 0010 pea %a2@(16)
4da98: 2f02 movel %d2,%sp@-
4da9a: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
handle->loads = 0;
handle->node = NULL;
4daa0: 4fef 0024 lea %sp@(36),%sp
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
handle->loads = 0;
4daa4: 42aa 0022 clrl %a2@(34)
handle->node = NULL;
4daa8: 42aa 000c clrl %a2@(12)
4daac: 6002 bras 4dab0 <rtems_rfs_inode_delete+0xc8>
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
int rc = 0;
4daae: 4280 clrl %d0 <== NOT EXECUTED
handle->loads = 0;
handle->node = NULL;
}
}
return rc;
}
4dab0: 4cee 040c ffa8 moveml %fp@(-88),%d2-%d3/%a2
4dab6: 4e5e unlk %fp <== NOT EXECUTED
00059e8c <rtems_rfs_inode_get_block.isra.0>:
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
59e8c: 4280 clrl %d0 <== NOT EXECUTED
* @param handle The inode handle.
* @param block The block number to return.
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
59e8e: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
59e92: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
59e96: 2f03 movel %d3,%sp@- <== NOT EXECUTED
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
59e98: 7618 moveq #24,%d3 <== NOT EXECUTED
* @param handle The inode handle.
* @param block The block number to return.
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
59e9a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59e9c: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
59ea0: 2202 movel %d2,%d1 <== NOT EXECUTED
59ea2: 1431 2c1c moveb %a1@(0000001c,%d2:l:4),%d2 <== NOT EXECUTED
59ea6: e589 lsll #2,%d1 <== NOT EXECUTED
59ea8: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
59eae: 1031 181f moveb %a1@(0000001f,%d1:l),%d0 <== NOT EXECUTED
59eb2: e7aa lsll %d3,%d2 <== NOT EXECUTED
59eb4: 8082 orl %d2,%d0 <== NOT EXECUTED
59eb6: 4282 clrl %d2 <== NOT EXECUTED
59eb8: 1431 181d moveb %a1@(0000001d,%d1:l),%d2 <== NOT EXECUTED
59ebc: 1231 181e moveb %a1@(0000001e,%d1:l),%d1 <== NOT EXECUTED
59ec0: 4842 swap %d2 <== NOT EXECUTED
59ec2: 4242 clrw %d2 <== NOT EXECUTED
59ec4: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
59eca: 8082 orl %d2,%d0 <== NOT EXECUTED
}
59ecc: 241f movel %sp@+,%d2 <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
59ece: e189 lsll #8,%d1 <== NOT EXECUTED
}
59ed0: 261f movel %sp@+,%d3 <== NOT EXECUTED
59ed2: 4e5e unlk %fp <== NOT EXECUTED
59ed4: 8081 orl %d1,%d0 <== NOT EXECUTED
0004e1a0 <rtems_rfs_inode_get_block.isra.9>:
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4e1a0: 4280 clrl %d0 <== NOT EXECUTED
* @param handle The inode handle.
* @param block The block number to return.
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
4e1a2: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
4e1a6: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
4e1aa: 2f03 movel %d3,%sp@- <== NOT EXECUTED
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4e1ac: 7618 moveq #24,%d3 <== NOT EXECUTED
* @param handle The inode handle.
* @param block The block number to return.
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
4e1ae: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e1b0: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4e1b4: 2202 movel %d2,%d1 <== NOT EXECUTED
4e1b6: 1431 2c1c moveb %a1@(0000001c,%d2:l:4),%d2 <== NOT EXECUTED
4e1ba: e589 lsll #2,%d1 <== NOT EXECUTED
4e1bc: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
4e1c2: 1031 181f moveb %a1@(0000001f,%d1:l),%d0 <== NOT EXECUTED
4e1c6: e7aa lsll %d3,%d2 <== NOT EXECUTED
4e1c8: 8082 orl %d2,%d0 <== NOT EXECUTED
4e1ca: 4282 clrl %d2 <== NOT EXECUTED
4e1cc: 1431 181d moveb %a1@(0000001d,%d1:l),%d2 <== NOT EXECUTED
4e1d0: 1231 181e moveb %a1@(0000001e,%d1:l),%d1 <== NOT EXECUTED
4e1d4: 4842 swap %d2 <== NOT EXECUTED
4e1d6: 4242 clrw %d2 <== NOT EXECUTED
4e1d8: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
4e1de: 8082 orl %d2,%d0 <== NOT EXECUTED
}
4e1e0: 241f movel %sp@+,%d2 <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4e1e2: e189 lsll #8,%d1 <== NOT EXECUTED
}
4e1e4: 261f movel %sp@+,%d3 <== NOT EXECUTED
4e1e6: 4e5e unlk %fp <== NOT EXECUTED
4e1e8: 8081 orl %d1,%d0 <== NOT EXECUTED
0004d73c <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d73c: 4e56 0000 linkw %fp,#0
4d740: 2f0a movel %a2,%sp@-
4d742: 246e 000c moveal %fp@(12),%a2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
4d746: 2f3c 0010 0000 movel #1048576,%sp@-
4d74c: 42a7 clrl %sp@-
4d74e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d754: 508f addql #8,%sp
4d756: 4a00 tstb %d0
4d758: 672c beqs 4d786 <rtems_rfs_inode_load+0x4a> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
4d75a: 203c 0006 c27c movel #443004,%d0 <== NOT EXECUTED
4d760: 4aaa 000c tstl %a2@(12) <== NOT EXECUTED
4d764: 6706 beqs 4d76c <rtems_rfs_inode_load+0x30> <== NOT EXECUTED
4d766: 203c 0006 be89 movel #441993,%d0 <== NOT EXECUTED
4d76c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d76e: 2f2a 0022 movel %a2@(34),%sp@- <== NOT EXECUTED
4d772: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4d776: 4879 0006 be8d pea 6be8d <ramdisk_ops+0xa4f> <== NOT EXECUTED
4d77c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d782: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
4d786: 4aaa 000c tstl %a2@(12)
4d78a: 6636 bnes 4d7c2 <rtems_rfs_inode_load+0x86>
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
4d78c: 4878 0001 pea 1 <ADD>
4d790: 2f2a 001a movel %a2@(26),%sp@-
4d794: 486a 0010 pea %a2@(16)
4d798: 2f2e 0008 movel %fp@(8),%sp@-
4d79c: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request>
handle->block, true);
if (rc > 0)
4d7a2: 4fef 0010 lea %sp@(16),%sp
4d7a6: 4a80 tstl %d0
4d7a8: 6e1e bgts 4d7c8 <rtems_rfs_inode_load+0x8c> <== NEVER TAKEN
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
4d7aa: 202a 001e movel %a2@(30),%d0
4d7ae: 2200 movel %d0,%d1
4d7b0: ed88 lsll #6,%d0
4d7b2: e789 lsll #3,%d1
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
handle->block, true);
if (rc > 0)
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
4d7b4: 206a 0016 moveal %a2@(22),%a0
handle->node += handle->offset;
4d7b8: 9081 subl %d1,%d0
4d7ba: d0a8 001e addl %a0@(30),%d0
4d7be: 2540 000c movel %d0,%a2@(12)
}
handle->loads++;
4d7c2: 52aa 0022 addql #1,%a2@(34)
return 0;
4d7c6: 4280 clrl %d0
}
4d7c8: 246e fffc moveal %fp@(-4),%a2
4d7cc: 4e5e unlk %fp <== NOT EXECUTED
0004d7d0 <rtems_rfs_inode_open>:
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
4d7d0: 4e56 fff0 linkw %fp,#-16
4d7d4: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
4d7d8: 2f3c 0004 0000 movel #262144,%sp@-
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
4d7de: 266e 0008 moveal %fp@(8),%a3
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
4d7e2: 42a7 clrl %sp@-
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
4d7e4: 242e 000c movel %fp@(12),%d2
4d7e8: 246e 0010 moveal %fp@(16),%a2
4d7ec: 162e 0017 moveb %fp@(23),%d3
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
4d7f0: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d7f6: 508f addql #8,%sp
4d7f8: 4a00 tstb %d0
4d7fa: 6710 beqs 4d80c <rtems_rfs_inode_open+0x3c> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
4d7fc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d7fe: 4879 0006 bec0 pea 6bec0 <ramdisk_ops+0xa82> <== NOT EXECUTED
4d804: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d80a: 508f addql #8,%sp <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
4d80c: 4a82 tstl %d2
4d80e: 6774 beqs 4d884 <rtems_rfs_inode_open+0xb4> <== NEVER TAKEN
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
4d810: 2002 movel %d2,%d0
4d812: 5380 subql #1,%d0
4d814: b0ab 0010 cmpl %a3@(16),%d0
4d818: 626a bhis 4d884 <rtems_rfs_inode_open+0xb4> <== NEVER TAKEN
return EINVAL;
handle->ino = ino;
4d81a: 2542 0008 movel %d2,%a2@(8)
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4d81e: 206b 001c moveal %a3@(28),%a0
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
4d822: 42aa 000c clrl %a2@(12)
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
4d826: 4c6b 0001 0028 remul %a3@(40),%d1,%d0
4d82c: 4c6b 0000 0028 remul %a3@(40),%d0,%d0
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
4d832: 42aa 0022 clrl %a2@(34)
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
4d836: 4c6b 1002 002c remul %a3@(44),%d2,%d1
4d83c: 4c6b 1001 002c remul %a3@(44),%d1,%d1
4d842: 2542 001e movel %d2,%a2@(30)
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4d846: 744c moveq #76,%d2
4d848: 4c02 0800 mulsl %d2,%d0
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
4d84c: 2070 0800 moveal %a0@(00000000,%d0:l),%a0
4d850: 5488 addql #2,%a0
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4d852: d1c1 addal %d1,%a0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4d854: 4200 clrb %d0
4d856: 2548 001a movel %a0,%a2@(26)
4d85a: 1540 0010 moveb %d0,%a2@(16)
handle->bnum = 0;
4d85e: 42aa 0012 clrl %a2@(18)
handle->buffer = NULL;
4d862: 42aa 0016 clrl %a2@(22)
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
4d866: 4a03 tstb %d3
4d868: 6716 beqs 4d880 <rtems_rfs_inode_open+0xb0> <== NEVER TAKEN
rc = rtems_rfs_inode_load (fs, handle);
4d86a: 2d4a 000c movel %a2,%fp@(12)
4d86e: 2d4b 0008 movel %a3,%fp@(8)
return rc;
}
4d872: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4d878: 4e5e unlk %fp
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
4d87a: 4ef9 0004 d73c jmp 4d73c <rtems_rfs_inode_load>
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
4d880: 4280 clrl %d0 <== NOT EXECUTED
4d882: 6002 bras 4d886 <rtems_rfs_inode_open+0xb6> <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
4d884: 7016 moveq #22,%d0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
return rc;
}
4d886: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3 <== NOT EXECUTED
4d88c: 4e5e unlk %fp <== NOT EXECUTED
0004c61a <rtems_rfs_inode_overhead>:
/**
* Return the inode overhead given a number of inodes.
*/
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
4c61a: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
4c61e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4c620: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
4c624: 2f02 movel %d2,%sp@- <== NOT EXECUTED
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
4c626: 242a 0008 movel %a2@(8),%d2 <== NOT EXECUTED
4c62a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4c62c: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED
4c630: 2200 movel %d0,%d1 <== NOT EXECUTED
4c632: ed88 lsll #6,%d0 <== NOT EXECUTED
4c634: e789 lsll #3,%d1 <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c636: e78a lsll #3,%d2 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
4c638: 9081 subl %d1,%d0 <== NOT EXECUTED
4c63a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c63c: 4eb9 0004 c5f6 jsr 4c5f6 <rtems_rfs_rup_quotient> <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
4c642: 222a 0004 movel %a2@(4),%d1 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
4c646: 508f addql #8,%sp <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
4c648: 5381 subql #1,%d1 <== NOT EXECUTED
4c64a: b282 cmpl %d2,%d1 <== NOT EXECUTED
4c64c: 6402 bccs 4c650 <rtems_rfs_inode_overhead+0x36> <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
4c64e: 2401 movel %d1,%d2 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
4c650: 223c 0000 03e8 movel #1000,%d1 <== NOT EXECUTED
4c656: 5280 addql #1,%d0 <== NOT EXECUTED
4c658: 4c01 0800 mulsl %d1,%d0 <== NOT EXECUTED
}
4c65c: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
4c660: 4c42 0800 remsl %d2,%d0,%d0 <== NOT EXECUTED
4c664: 242e fff8 movel %fp@(-8),%d2 <== NOT EXECUTED
4c668: 4e5e unlk %fp <== NOT EXECUTED
0004e010 <rtems_rfs_inode_set_block>:
* @param block The block index.
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
4e010: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
4e014: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
4e018: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4e01a: 202e 0010 movel %fp@(16),%d0 <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
4e01e: 7618 moveq #24,%d3 <== NOT EXECUTED
* @param block The block index.
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
4e020: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
4e022: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
4e026: 2400 movel %d0,%d2 <== NOT EXECUTED
4e028: e6aa lsrl %d3,%d2 <== NOT EXECUTED
* @param block The block index.
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
4e02a: 222e 000c movel %fp@(12),%d1 <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
4e02e: 1382 1c1c moveb %d2,%a1@(0000001c,%d1:l:4) <== NOT EXECUTED
4e032: 2400 movel %d0,%d2 <== NOT EXECUTED
4e034: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
4e038: e589 lsll #2,%d1 <== NOT EXECUTED
4e03a: 4242 clrw %d2 <== NOT EXECUTED
4e03c: 4842 swap %d2 <== NOT EXECUTED
4e03e: 1382 181d moveb %d2,%a1@(0000001d,%d1:l) <== NOT EXECUTED
4e042: 2400 movel %d0,%d2 <== NOT EXECUTED
4e044: e08a lsrl #8,%d2 <== NOT EXECUTED
4e046: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
4e04a: 1382 181e moveb %d2,%a1@(0000001e,%d1:l) <== NOT EXECUTED
4e04e: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
4e052: 1380 181f moveb %d0,%a1@(0000001f,%d1:l) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4e056: 7001 moveq #1,%d0 <== NOT EXECUTED
}
4e058: 241f movel %sp@+,%d2 <== NOT EXECUTED
4e05a: 261f movel %sp@+,%d3 <== NOT EXECUTED
4e05c: 4e5e unlk %fp <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4e05e: 1140 0010 moveb %d0,%a0@(16) <== NOT EXECUTED
}
0004daba <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
4daba: 4e56 fff4 linkw %fp,#-12
4dabe: 48d7 040c moveml %d2-%d3/%a2,%sp@
4dac2: 246e 0008 moveal %fp@(8),%a2
4dac6: 162e 000f moveb %fp@(15),%d3
4daca: 142e 0013 moveb %fp@(19),%d2
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
4dace: 4aaa 000c tstl %a2@(12)
4dad2: 6700 0082 beqw 4db56 <rtems_rfs_inode_time_stamp_now+0x9c>
return ENXIO;
now = time (NULL);
4dad6: 42a7 clrl %sp@-
4dad8: 4eb9 0005 f394 jsr 5f394 <time>
if (atime)
4dade: 588f addql #4,%sp
4dae0: 4a03 tstb %d3
4dae2: 6736 beqs 4db1a <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4dae4: 206a 000c moveal %a2@(12),%a0
4dae8: 2200 movel %d0,%d1
4daea: 7618 moveq #24,%d3
4daec: e6a9 lsrl %d3,%d1
4daee: 1141 0010 moveb %d1,%a0@(16)
4daf2: 2200 movel %d0,%d1
4daf4: 206a 000c moveal %a2@(12),%a0
4daf8: 4241 clrw %d1
4dafa: 4841 swap %d1
4dafc: 1141 0011 moveb %d1,%a0@(17)
4db00: 2200 movel %d0,%d1
4db02: e089 lsrl #8,%d1
4db04: 206a 000c moveal %a2@(12),%a0
4db08: 1141 0012 moveb %d1,%a0@(18)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4db0c: 7201 moveq #1,%d1
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4db0e: 206a 000c moveal %a2@(12),%a0
4db12: 1140 0013 moveb %d0,%a0@(19)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4db16: 1541 0010 moveb %d1,%a2@(16)
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
4db1a: 4a02 tstb %d2
4db1c: 673c beqs 4db5a <rtems_rfs_inode_time_stamp_now+0xa0><== NEVER TAKEN
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4db1e: 206a 000c moveal %a2@(12),%a0
4db22: 2200 movel %d0,%d1
4db24: 7418 moveq #24,%d2
4db26: e4a9 lsrl %d2,%d1
4db28: 1141 0014 moveb %d1,%a0@(20)
4db2c: 2200 movel %d0,%d1
4db2e: 206a 000c moveal %a2@(12),%a0
4db32: 4241 clrw %d1
4db34: 4841 swap %d1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4db36: 7601 moveq #1,%d3
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4db38: 1141 0015 moveb %d1,%a0@(21)
4db3c: 2200 movel %d0,%d1
4db3e: e089 lsrl #8,%d1
4db40: 206a 000c moveal %a2@(12),%a0
4db44: 1141 0016 moveb %d1,%a0@(22)
4db48: 206a 000c moveal %a2@(12),%a0
4db4c: 1140 0017 moveb %d0,%a0@(23)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4db50: 1543 0010 moveb %d3,%a2@(16)
4db54: 6004 bras 4db5a <rtems_rfs_inode_time_stamp_now+0xa0>
bool atime,
bool mtime)
{
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
return ENXIO;
4db56: 7006 moveq #6,%d0 <== NOT EXECUTED
4db58: 6002 bras 4db5c <rtems_rfs_inode_time_stamp_now+0xa2><== NOT EXECUTED
now = time (NULL);
if (atime)
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
rtems_rfs_inode_set_mtime (handle, now);
return 0;
4db5a: 4280 clrl %d0
}
4db5c: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
4db62: 4e5e unlk %fp <== NOT EXECUTED
0004d890 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
4d890: 4e56 0000 linkw %fp,#0
4d894: 2f0a movel %a2,%sp@-
4d896: 246e 000c moveal %fp@(12),%a2
4d89a: 2f02 movel %d2,%sp@-
4d89c: 142e 0013 moveb %fp@(19),%d2
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
4d8a0: 2f3c 0020 0000 movel #2097152,%sp@-
4d8a6: 42a7 clrl %sp@-
4d8a8: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
4d8ae: 508f addql #8,%sp
4d8b0: 4a00 tstb %d0
4d8b2: 672c beqs 4d8e0 <rtems_rfs_inode_unload+0x50> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
4d8b4: 203c 0006 c27c movel #443004,%d0 <== NOT EXECUTED
4d8ba: 4aaa 000c tstl %a2@(12) <== NOT EXECUTED
4d8be: 6706 beqs 4d8c6 <rtems_rfs_inode_unload+0x36> <== NOT EXECUTED
4d8c0: 203c 0006 be89 movel #441993,%d0 <== NOT EXECUTED
4d8c6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d8c8: 2f2a 0022 movel %a2@(34),%sp@- <== NOT EXECUTED
4d8cc: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4d8d0: 4879 0006 bee1 pea 6bee1 <ramdisk_ops+0xaa3> <== NOT EXECUTED
4d8d6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4d8dc: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
4d8e0: 4aaa 000c tstl %a2@(12)
4d8e4: 6772 beqs 4d958 <rtems_rfs_inode_unload+0xc8>
{
if (handle->loads == 0)
4d8e6: 202a 0022 movel %a2@(34),%d0
4d8ea: 6768 beqs 4d954 <rtems_rfs_inode_unload+0xc4> <== NEVER TAKEN
return EIO;
handle->loads--;
4d8ec: 5380 subql #1,%d0
4d8ee: 2540 0022 movel %d0,%a2@(34)
if (handle->loads == 0)
4d8f2: 6664 bnes 4d958 <rtems_rfs_inode_unload+0xc8>
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
4d8f4: 4a2a 0010 tstb %a2@(16)
4d8f8: 6744 beqs 4d93e <rtems_rfs_inode_unload+0xae>
4d8fa: 4a02 tstb %d2
4d8fc: 6740 beqs 4d93e <rtems_rfs_inode_unload+0xae> <== NEVER TAKEN
rtems_rfs_inode_set_ctime (handle, time (NULL));
4d8fe: 42a7 clrl %sp@-
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
4d900: 7418 moveq #24,%d2
4d902: 4eb9 0005 f394 jsr 5f394 <time>
4d908: 206a 000c moveal %a2@(12),%a0
4d90c: 2200 movel %d0,%d1
4d90e: e4a9 lsrl %d2,%d1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4d910: 588f addql #4,%sp
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
4d912: 1141 0018 moveb %d1,%a0@(24)
4d916: 2200 movel %d0,%d1
4d918: 206a 000c moveal %a2@(12),%a0
4d91c: 4241 clrw %d1
4d91e: 4841 swap %d1
4d920: 1141 0019 moveb %d1,%a0@(25)
4d924: 2200 movel %d0,%d1
4d926: e089 lsrl #8,%d1
4d928: 206a 000c moveal %a2@(12),%a0
4d92c: 1141 001a moveb %d1,%a0@(26)
4d930: 206a 000c moveal %a2@(12),%a0
4d934: 1140 001b moveb %d0,%a0@(27)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4d938: 7001 moveq #1,%d0
4d93a: 1540 0010 moveb %d0,%a2@(16)
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
4d93e: 486a 0010 pea %a2@(16)
4d942: 2f2e 0008 movel %fp@(8),%sp@-
4d946: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release>
handle->node = NULL;
4d94c: 508f addql #8,%sp
4d94e: 42aa 000c clrl %a2@(12)
4d952: 6006 bras 4d95a <rtems_rfs_inode_unload+0xca>
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
4d954: 7005 moveq #5,%d0 <== NOT EXECUTED
4d956: 6002 bras 4d95a <rtems_rfs_inode_unload+0xca> <== NOT EXECUTED
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
4d958: 4280 clrl %d0
handle->node = NULL;
}
}
return rc;
}
4d95a: 242e fff8 movel %fp@(-8),%d2
4d95e: 246e fffc moveal %fp@(-4),%a2
4d962: 4e5e unlk %fp <== NOT EXECUTED
00059294 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
59294: 4e56 ff90 linkw %fp,#-112
59298: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
5929c: 2f3c 0100 0000 movel #16777216,%sp@-
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
592a2: 262e 0008 movel %fp@(8),%d3
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
592a6: 42a7 clrl %sp@-
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
592a8: 2a2e 000c movel %fp@(12),%d5
592ac: 2c2e 0010 movel %fp@(16),%d6
592b0: 2e2e 0014 movel %fp@(20),%d7
592b4: 246e 0018 moveal %fp@(24),%a2
592b8: 182e 001f moveb %fp@(31),%d4
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
592bc: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
592c2: 508f addql #8,%sp
592c4: 4a00 tstb %d0
592c6: 673c beqs 59304 <rtems_rfs_link+0x70> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
592c8: 2f07 movel %d7,%sp@- <== NOT EXECUTED
592ca: 4879 0006 d914 pea 6d914 <CSWTCH.1+0x125a> <== NOT EXECUTED
592d0: 2645 moveal %d5,%a3 <== NOT EXECUTED
for (c = 0; c < length; c++)
592d2: 4282 clrl %d2 <== NOT EXECUTED
printf ("%c", name[c]);
592d4: 49f9 0005 c1b0 lea 5c1b0 <putchar>,%a4 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
592da: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
592e0: 508f addql #8,%sp <== NOT EXECUTED
592e2: 600c bras 592f0 <rtems_rfs_link+0x5c> <== NOT EXECUTED
592e4: 5282 addql #1,%d2 <== NOT EXECUTED
printf ("%c", name[c]);
592e6: 101b moveb %a3@+,%d0 <== NOT EXECUTED
592e8: 49c0 extbl %d0 <== NOT EXECUTED
592ea: 2f00 movel %d0,%sp@- <== NOT EXECUTED
592ec: 4e94 jsr %a4@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
for (c = 0; c < length; c++)
592ee: 588f addql #4,%sp <== NOT EXECUTED
592f0: bc82 cmpl %d2,%d6 <== NOT EXECUTED
592f2: 6ef0 bgts 592e4 <rtems_rfs_link+0x50> <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
592f4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
592f6: 4879 0006 d959 pea 6d959 <CSWTCH.1+0x129f> <== NOT EXECUTED
592fc: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
59302: 508f addql #8,%sp <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
59304: 4878 0001 pea 1 <ADD>
59308: 47ee ffda lea %fp@(-38),%a3
5930c: 2f0b movel %a3,%sp@-
5930e: 2f0a movel %a2,%sp@-
59310: 2f03 movel %d3,%sp@-
59312: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc)
59318: 4fef 0010 lea %sp@(16),%sp
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
5931c: 2400 movel %d0,%d2
if (rc)
5931e: 6600 0116 bnew 59436 <rtems_rfs_link+0x1a2>
/*
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
59322: 4a04 tstb %d4
59324: 662e bnes 59354 <rtems_rfs_link+0xc0> <== NEVER TAKEN
59326: 206e ffe6 moveal %fp@(-26),%a0
5932a: 4280 clrl %d0
5932c: 1028 0002 moveb %a0@(2),%d0
59330: e188 lsll #8,%d0
59332: 0280 0000 f000 andil #61440,%d0
59338: 0c80 0000 4000 cmpil #16384,%d0
5933e: 6614 bnes 59354 <rtems_rfs_link+0xc0> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
59340: 2f0b movel %a3,%sp@- <== NOT EXECUTED
return ENOTSUP;
59342: 143c ff86 moveb #-122,%d2 <== NOT EXECUTED
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
{
rtems_rfs_inode_close (fs, &target_inode);
59346: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59348: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
return ENOTSUP;
5934e: 508f addql #8,%sp <== NOT EXECUTED
59350: 6000 00e4 braw 59436 <rtems_rfs_link+0x1a2> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
59354: 4878 0001 pea 1 <ADD>
59358: 280e movel %fp,%d4
5935a: 0684 ffff ffb4 addil #-76,%d4
59360: 2f04 movel %d4,%sp@-
59362: 2f07 movel %d7,%sp@-
59364: 2f03 movel %d3,%sp@-
59366: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc)
5936c: 4fef 0010 lea %sp@(16),%sp
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
59370: 2400 movel %d0,%d2
if (rc)
59372: 6710 beqs 59384 <rtems_rfs_link+0xf0> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
59374: 486e ffda pea %fp@(-38) <== NOT EXECUTED
59378: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5937a: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
59380: 6000 00b2 braw 59434 <rtems_rfs_link+0x1a0> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
59384: 2f0a movel %a2,%sp@-
59386: 2f06 movel %d6,%sp@-
59388: 2f05 movel %d5,%sp@-
5938a: 2f04 movel %d4,%sp@-
5938c: 2f03 movel %d3,%sp@-
5938e: 4eb9 0005 7150 jsr 57150 <rtems_rfs_dir_add_entry>
if (rc > 0)
59394: 4fef 0014 lea %sp@(20),%sp
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
59398: 2400 movel %d0,%d2
if (rc > 0)
5939a: 6f12 bles 593ae <rtems_rfs_link+0x11a> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &parent_inode);
5939c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5939e: 45f9 0004 d966 lea 4d966 <rtems_rfs_inode_close>,%a2 <== NOT EXECUTED
593a4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
593a6: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
593a8: 486e ffda pea %fp@(-38) <== NOT EXECUTED
593ac: 6060 bras 5940e <rtems_rfs_link+0x17a> <== NOT EXECUTED
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
593ae: 47ee ffda lea %fp@(-38),%a3
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
593b2: 4280 clrl %d0
593b4: 4281 clrl %d1
593b6: 45f9 0004 d966 lea 4d966 <rtems_rfs_inode_close>,%a2
593bc: 206b 000c moveal %a3@(12),%a0
593c0: 1010 moveb %a0@,%d0
593c2: 1228 0001 moveb %a0@(1),%d1
593c6: e188 lsll #8,%d0
593c8: 8081 orl %d1,%d0
if (links == 0xffff)
593ca: 3200 movew %d0,%d1
links = 0;
593cc: 0c81 0000 ffff cmpil #65535,%d1
593d2: 56c1 sne %d1
593d4: 4881 extw %d1
593d6: c081 andl %d1,%d0
593d8: 5280 addql #1,%d0
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
593da: 2200 movel %d0,%d1
593dc: e089 lsrl #8,%d1
593de: 1081 moveb %d1,%a0@
593e0: 206e ffe6 moveal %fp@(-26),%a0
593e4: 1140 0001 moveb %d0,%a0@(1)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
593e8: 7001 moveq #1,%d0
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
593ea: 4878 0001 pea 1 <ADD>
593ee: 4878 0001 pea 1 <ADD>
593f2: 1d40 ffea moveb %d0,%fp@(-22)
593f6: 2f04 movel %d4,%sp@-
593f8: 4eb9 0004 daba jsr 4daba <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
593fe: 4fef 000c lea %sp@(12),%sp
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
59402: 2400 movel %d0,%d2
if (rc > 0)
59404: 6f12 bles 59418 <rtems_rfs_link+0x184> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &parent_inode);
59406: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59408: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5940a: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
5940c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5940e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59410: 4e92 jsr %a2@ <== NOT EXECUTED
return rc;
59412: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
59416: 601e bras 59436 <rtems_rfs_link+0x1a2> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
59418: 2f04 movel %d4,%sp@-
5941a: 2f03 movel %d3,%sp@-
5941c: 4e92 jsr %a2@
if (rc > 0)
5941e: 508f addql #8,%sp
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
59420: 2400 movel %d0,%d2
if (rc > 0)
59422: 6f08 bles 5942c <rtems_rfs_link+0x198> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
59424: 2f0b movel %a3,%sp@- <== NOT EXECUTED
59426: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59428: 4e92 jsr %a2@ <== NOT EXECUTED
5942a: 6008 bras 59434 <rtems_rfs_link+0x1a0> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
5942c: 2f0b movel %a3,%sp@-
5942e: 2f03 movel %d3,%sp@-
59430: 4e92 jsr %a2@
59432: 2400 movel %d0,%d2
return rc;
59434: 508f addql #8,%sp
}
59436: 2002 movel %d2,%d0
59438: 4cee 1cfc ff90 moveml %fp@(-112),%d2-%d7/%a2-%a4
5943e: 4e5e unlk %fp <== NOT EXECUTED
00059c08 <rtems_rfs_mutex_create>:
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
59c08: 4e56 0000 linkw %fp,#0
59c0c: 2f02 movel %d2,%sp@-
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
59c0e: 2f2e 0008 movel %fp@(8),%sp@-
59c12: 42a7 clrl %sp@-
59c14: 4878 0024 pea 24 <OPER2+0x10>
59c18: 4878 0001 pea 1 <ADD>
59c1c: 2f3c 5246 536d movel #1380340589,%sp@-
59c22: 4eb9 0004 8cd4 jsr 48cd4 <rtems_semaphore_create>
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
59c28: 4fef 0014 lea %sp@(20),%sp
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
59c2c: 2400 movel %d0,%d2
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
59c2e: 672e beqs 59c5e <rtems_rfs_mutex_create+0x56> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
59c30: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
59c34: 42a7 clrl %sp@- <== NOT EXECUTED
59c36: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
59c3c: 508f addql #8,%sp <== NOT EXECUTED
59c3e: 4a00 tstb %d0 <== NOT EXECUTED
59c40: 6720 beqs 59c62 <rtems_rfs_mutex_create+0x5a> <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
59c42: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59c44: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
59c4a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59c4c: 4879 0006 db32 pea 6db32 <CSWTCH.1+0x1478> <== NOT EXECUTED
59c52: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
59c58: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
59c5c: 6004 bras 59c62 <rtems_rfs_mutex_create+0x5a> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
59c5e: 4280 clrl %d0
59c60: 6002 bras 59c64 <rtems_rfs_mutex_create+0x5c>
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
59c62: 7005 moveq #5,%d0 <== NOT EXECUTED
}
#endif
return 0;
}
59c64: 242e fffc movel %fp@(-4),%d2
59c68: 4e5e unlk %fp <== NOT EXECUTED
00059c6c <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
59c6c: 4e56 0000 linkw %fp,#0
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
59c70: 206e 0008 moveal %fp@(8),%a0
return 0;
}
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
59c74: 2f02 movel %d2,%sp@-
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
59c76: 2f10 movel %a0@,%sp@-
59c78: 4eb9 0004 8e74 jsr 48e74 <rtems_semaphore_delete>
if (sc != RTEMS_SUCCESSFUL)
59c7e: 588f addql #4,%sp
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
59c80: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
59c82: 672e beqs 59cb2 <rtems_rfs_mutex_destroy+0x46> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
59c84: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
59c88: 42a7 clrl %sp@- <== NOT EXECUTED
59c8a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
59c90: 508f addql #8,%sp <== NOT EXECUTED
59c92: 4a00 tstb %d0 <== NOT EXECUTED
59c94: 6720 beqs 59cb6 <rtems_rfs_mutex_destroy+0x4a> <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
59c96: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59c98: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
59c9e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59ca0: 4879 0006 db55 pea 6db55 <CSWTCH.1+0x149b> <== NOT EXECUTED
59ca6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
59cac: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
59cb0: 6004 bras 59cb6 <rtems_rfs_mutex_destroy+0x4a> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
59cb2: 4280 clrl %d0
59cb4: 6002 bras 59cb8 <rtems_rfs_mutex_destroy+0x4c>
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
59cb6: 7005 moveq #5,%d0 <== NOT EXECUTED
}
#endif
return 0;
}
59cb8: 242e fffc movel %fp@(-4),%d2
59cbc: 4e5e unlk %fp <== NOT EXECUTED
0004e1ec <rtems_rfs_mutex_lock.isra.15>:
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
4e1ec: 4e56 0000 linkw %fp,#0
4e1f0: 2f02 movel %d2,%sp@-
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4e1f2: 42a7 clrl %sp@-
4e1f4: 42a7 clrl %sp@-
4e1f6: 2f2e 0008 movel %fp@(8),%sp@-
4e1fa: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
4e200: 4fef 000c lea %sp@(12),%sp
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4e204: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
4e206: 672e beqs 4e236 <rtems_rfs_mutex_lock.isra.15+0x4a><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4e208: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4e20c: 42a7 clrl %sp@- <== NOT EXECUTED
4e20e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
4e214: 508f addql #8,%sp <== NOT EXECUTED
4e216: 4a00 tstb %d0 <== NOT EXECUTED
4e218: 6720 beqs 4e23a <rtems_rfs_mutex_lock.isra.15+0x4e><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4e21a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e21c: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
4e222: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4e224: 4879 0006 c00a pea 6c00a <ramdisk_ops+0xbcc> <== NOT EXECUTED
4e22a: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4e230: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4e234: 6004 bras 4e23a <rtems_rfs_mutex_lock.isra.15+0x4e><== NOT EXECUTED
rtems_status_text (sc));
#endif
return EIO;
}
#endif
return 0;
4e236: 4280 clrl %d0
4e238: 6002 bras 4e23c <rtems_rfs_mutex_lock.isra.15+0x50>
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: obtain failed: %s\n",
rtems_status_text (sc));
#endif
return EIO;
4e23a: 7005 moveq #5,%d0 <== NOT EXECUTED
}
#endif
return 0;
}
4e23c: 242e fffc movel %fp@(-4),%d2
4e240: 4e5e unlk %fp <== NOT EXECUTED
00056420 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
56420: 4e56 ffe4 linkw %fp,#-28
56424: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
56428: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
5642c: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
56430: 42a7 clrl %sp@-
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
56432: 266e 000c moveal %fp@(12),%a3
56436: 162e 0013 moveb %fp@(19),%d3
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
5643a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56440: 508f addql #8,%sp
56442: 4a00 tstb %d0
56444: 6710 beqs 56456 <rtems_rfs_release_chain+0x36> <== ALWAYS TAKEN
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
56446: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
56448: 4879 0006 c7ae pea 6c7ae <CSWTCH.1+0xf4> <== NOT EXECUTED
5644e: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56454: 508f addql #8,%sp <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
56456: 280a movel %a2,%d4
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
56458: 4282 clrl %d2
5645a: 5884 addql #4,%d4
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
5645c: 4bf9 0004 9a64 lea 49a64 <_Chain_Get>,%a5
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
56462: 49f9 0005 b38a lea 5b38a <rtems_rfs_buffer_bdbuf_release>,%a4
56468: 0283 0000 00ff andil #255,%d3
5646e: 6020 bras 56490 <rtems_rfs_release_chain+0x70>
56470: 2f0a movel %a2,%sp@-
56472: 4e95 jsr %a5@
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
56474: 5393 subql #1,%a3@
buffer->user = (void*) 0;
56476: 2040 moveal %d0,%a0
56478: 42a8 0036 clrl %a0@(54)
rc = rtems_rfs_buffer_io_release (buffer, modified);
5647c: 2f03 movel %d3,%sp@-
5647e: 2f00 movel %d0,%sp@-
56480: 4e94 jsr %a4@
if ((rc > 0) && (rrc == 0))
56482: 4fef 000c lea %sp@(12),%sp
56486: 4a80 tstl %d0
56488: 6f06 bles 56490 <rtems_rfs_release_chain+0x70> <== ALWAYS TAKEN
5648a: 4a82 tstl %d2 <== NOT EXECUTED
5648c: 6602 bnes 56490 <rtems_rfs_release_chain+0x70> <== NOT EXECUTED
5648e: 2400 movel %d0,%d2 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
56490: b892 cmpl %a2@,%d4
56492: 66dc bnes 56470 <rtems_rfs_release_chain+0x50>
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
56494: 2002 movel %d2,%d0
56496: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
5649c: 4e5e unlk %fp <== NOT EXECUTED
0004e6ee <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
4e6ee: 4e56 ffc0 linkw %fp,#-64
4e6f2: 206e 0008 moveal %fp@(8),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e6f6: 2268 0010 moveal %a0@(16),%a1
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
4e6fa: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e6fe: 2610 movel %a0@,%d3
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e700: 47ee ffda lea %fp@(-38),%a3
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e704: 2469 0034 moveal %a1@(52),%a2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
4e708: 2f2a 007c movel %a2@(124),%sp@-
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
4e70c: 342e 000e movew %fp@(14),%d2
4e710: 382e 0012 movew %fp@(18),%d4
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
4e714: 4eba fbfc jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e718: 4878 0001 pea 1 <ADD>
4e71c: 2f0b movel %a3,%sp@-
4e71e: 2f03 movel %d3,%sp@-
4e720: 2f0a movel %a2,%sp@-
4e722: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
4e728: 4fef 0014 lea %sp@(20),%sp
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e72c: 2600 movel %d0,%d3
if (rc > 0)
4e72e: 6f14 bles 4e744 <rtems_rfs_rtems_chown+0x56> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e730: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e732: 4eba f9c0 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: opening inode", rc);
4e736: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e73c: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e73e: 2083 movel %d3,%a0@ <== NOT EXECUTED
4e740: 6000 00ac braw 4e7ee <rtems_rfs_rtems_chown+0x100> <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
4e744: 4eb9 0005 2bb8 jsr 52bb8 <geteuid>
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
4e74a: 206b 000c moveal %a3@(12),%a0
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4e74e: 4281 clrl %d1
4e750: 1228 0006 moveb %a0@(6),%d1
4e754: 4285 clrl %d5
4e756: 1a28 0007 moveb %a0@(7),%d5
4e75a: 4283 clrl %d3
4e75c: e189 lsll #8,%d1
4e75e: 3600 movew %d0,%d3
4e760: 8285 orl %d5,%d1
4e762: b283 cmpl %d3,%d1
4e764: 6728 beqs 4e78e <rtems_rfs_rtems_chown+0xa0> <== ALWAYS TAKEN
4e766: 4a40 tstw %d0 <== NOT EXECUTED
4e768: 6724 beqs 4e78e <rtems_rfs_rtems_chown+0xa0> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4e76a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("chown: not able", EPERM);
4e76c: 7401 moveq #1,%d2 <== NOT EXECUTED
#if defined (RTEMS_POSIX_API)
uid = geteuid();
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
{
rtems_rfs_inode_close (fs, &inode);
4e76e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e770: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4e776: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e778: 4eba f97a jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
4e77c: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e782: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4e786: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e788: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e78a: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e78c: 606c bras 4e7fa <rtems_rfs_rtems_chown+0x10c> <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
4e78e: 4280 clrl %d0
4e790: 7218 moveq #24,%d1
4e792: 3002 movew %d2,%d0
4e794: 4844 swap %d4
4e796: 4244 clrw %d4
4e798: 8880 orl %d0,%d4
4e79a: 2004 movel %d4,%d0
4e79c: e2a8 lsrl %d1,%d0
4e79e: 1140 0004 moveb %d0,%a0@(4)
4e7a2: 2004 movel %d4,%d0
4e7a4: e08c lsrl #8,%d4
4e7a6: 206e ffe6 moveal %fp@(-26),%a0
4e7aa: 4240 clrw %d0
4e7ac: 4840 swap %d0
4e7ae: 1140 0005 moveb %d0,%a0@(5)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4e7b2: 7001 moveq #1,%d0
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
4e7b4: 206e ffe6 moveal %fp@(-26),%a0
4e7b8: 1144 0006 moveb %d4,%a0@(6)
4e7bc: 206e ffe6 moveal %fp@(-26),%a0
4e7c0: 1142 0007 moveb %d2,%a0@(7)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4e7c4: 1d40 ffea moveb %d0,%fp@(-22)
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
4e7c8: 486e ffda pea %fp@(-38)
4e7cc: 2f0a movel %a2,%sp@-
4e7ce: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
if (rc)
4e7d4: 508f addql #8,%sp
4e7d6: 41fa f91c lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
4e7da: 2640 moveal %d0,%a3
if (rc)
4e7dc: 4a80 tstl %d0
4e7de: 6712 beqs 4e7f2 <rtems_rfs_rtems_chown+0x104> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e7e0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e7e2: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: closing inode", rc);
4e7e4: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e7ea: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e7ec: 208b movel %a3,%a0@ <== NOT EXECUTED
4e7ee: 588f addql #4,%sp <== NOT EXECUTED
4e7f0: 6098 bras 4e78a <rtems_rfs_rtems_chown+0x9c> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e7f2: 2f0a movel %a2,%sp@-
4e7f4: 4e90 jsr %a0@
return 0;
4e7f6: 588f addql #4,%sp
4e7f8: 4280 clrl %d0
}
4e7fa: 4cee 0c3c ffc0 moveml %fp@(-64),%d2-%d5/%a2-%a3
4e800: 4e5e unlk %fp <== NOT EXECUTED
00059df8 <rtems_rfs_rtems_device_close>:
* @return int
*/
static int
rtems_rfs_rtems_device_close (rtems_libio_t* iop)
{
59df8: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
59dfc: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
59e00: 2028 0030 movel %a0@(48),%d0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
59e04: 2228 0034 movel %a0@(52),%d1 <== NOT EXECUTED
args.iop = iop;
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
59e08: 486e fff4 pea %fp@(-12) <== NOT EXECUTED
59e0c: 2f01 movel %d1,%sp@- <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
59e0e: 2d48 fff4 movel %a0,%fp@(-12) <== NOT EXECUTED
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
59e12: 2f00 movel %d0,%sp@- <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
59e14: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
args.mode = 0;
59e18: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
status = rtems_io_close (major, minor, (void *) &args);
59e1c: 4eb9 0005 b0b4 jsr 5b0b4 <rtems_io_close> <== NOT EXECUTED
return rtems_deviceio_errno (status);
59e22: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59e24: 4eb9 0005 a7dc jsr 5a7dc <rtems_deviceio_errno> <== NOT EXECUTED
}
59e2a: 4e5e unlk %fp <== NOT EXECUTED
00059cd0 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
{
return 0;
}
59cd0: 4280 clrl %d0 <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
{
59cd2: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return 0;
}
59cd6: 4e5e unlk %fp <== NOT EXECUTED
00059cda <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
uint32_t command,
void* buffer)
{
59cda: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
59cde: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
rtems_libio_ioctl_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
59ce2: 2028 0030 movel %a0@(48),%d0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
59ce6: 2228 0034 movel %a0@(52),%d1 <== NOT EXECUTED
args.iop = iop;
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
59cea: 486e fff0 pea %fp@(-16) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.command = command;
59cee: 2d6e 000c fff4 movel %fp@(12),%fp@(-12) <== NOT EXECUTED
args.buffer = buffer;
59cf4: 2d6e 0010 fff8 movel %fp@(16),%fp@(-8) <== NOT EXECUTED
status = rtems_io_control (major, minor, (void *) &args);
59cfa: 2f01 movel %d1,%sp@- <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
59cfc: 2d48 fff0 movel %a0,%fp@(-16) <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
59d00: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59d02: 4eb9 0005 b0f8 jsr 5b0f8 <rtems_io_control> <== NOT EXECUTED
if (status)
59d08: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
59d0c: 4a80 tstl %d0 <== NOT EXECUTED
59d0e: 670c beqs 59d1c <rtems_rfs_rtems_device_ioctl+0x42><== NOT EXECUTED
return rtems_deviceio_errno (status);
59d10: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59d12: 4eb9 0005 a7dc jsr 5a7dc <rtems_deviceio_errno> <== NOT EXECUTED
59d18: 588f addql #4,%sp <== NOT EXECUTED
59d1a: 6004 bras 59d20 <rtems_rfs_rtems_device_ioctl+0x46><== NOT EXECUTED
return args.ioctl_return;
59d1c: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
}
59d20: 4e5e unlk %fp <== NOT EXECUTED
00059cc0 <rtems_rfs_rtems_device_lseek>:
static rtems_off64_t
rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
59cc0: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return offset;
}
59cc4: 202e 000c movel %fp@(12),%d0 <== NOT EXECUTED
59cc8: 222e 0010 movel %fp@(16),%d1 <== NOT EXECUTED
59ccc: 4e5e unlk %fp <== NOT EXECUTED
00059ed8 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
59ed8: 4e56 ffb4 linkw %fp,#-76 <== NOT EXECUTED
59edc: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@ <== NOT EXECUTED
59ee0: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
59ee4: 206a 0028 moveal %a2@(40),%a0 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
59ee8: 262a 0018 movel %a2@(24),%d3 <== NOT EXECUTED
const char *pathname,
uint32_t flag,
uint32_t mode)
{
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
59eec: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
59ef0: 42a7 clrl %sp@- <== NOT EXECUTED
59ef2: 42a7 clrl %sp@- <== NOT EXECUTED
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_filesystem_default_fsync,
.fdatasync_h = rtems_filesystem_default_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
59ef4: 206b 007c moveal %a3@(124),%a0 <== NOT EXECUTED
59ef8: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
59efa: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
59f00: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
59f04: 2400 movel %d0,%d2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
59f06: 672c beqs 59f34 <rtems_rfs_rtems_device_open+0x5c><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
59f08: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
59f0c: 42a7 clrl %sp@- <== NOT EXECUTED
59f0e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
59f14: 508f addql #8,%sp <== NOT EXECUTED
59f16: 4a00 tstb %d0 <== NOT EXECUTED
59f18: 671a beqs 59f34 <rtems_rfs_rtems_device_open+0x5c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
59f1a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59f1c: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
59f22: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59f24: 4879 0006 c00a pea 6c00a <ramdisk_ops+0xbcc> <== NOT EXECUTED
59f2a: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
59f30: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
59f34: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
59f38: 49ee ffce lea %fp@(-50),%a4 <== NOT EXECUTED
59f3c: 2f0c movel %a4,%sp@- <== NOT EXECUTED
59f3e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59f40: 2f0b movel %a3,%sp@- <== NOT EXECUTED
59f42: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
59f48: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
59f4c: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
59f4e: 6f12 bles 59f62 <rtems_rfs_rtems_device_open+0x8a><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
59f50: 2f0b movel %a3,%sp@- <== NOT EXECUTED
59f52: 4eba feda jsr %pc@(59e2e <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
59f56: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
59f5c: 2040 moveal %d0,%a0 <== NOT EXECUTED
59f5e: 2082 movel %d2,%a0@ <== NOT EXECUTED
59f60: 6042 bras 59fa4 <rtems_rfs_rtems_device_open+0xcc><== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
59f62: 262c 000c movel %a4@(12),%d3 <== NOT EXECUTED
59f66: 4bfa ff24 lea %pc@(59e8c <rtems_rfs_inode_get_block.isra.0>),%a5<== NOT EXECUTED
59f6a: 42a7 clrl %sp@- <== NOT EXECUTED
59f6c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59f6e: 4e95 jsr %a5@ <== NOT EXECUTED
59f70: 508f addql #8,%sp <== NOT EXECUTED
59f72: 2400 movel %d0,%d2 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
59f74: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
59f78: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59f7a: 4e95 jsr %a5@ <== NOT EXECUTED
59f7c: 508f addql #8,%sp <== NOT EXECUTED
59f7e: 2600 movel %d0,%d3 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
59f80: 2f0c movel %a4,%sp@- <== NOT EXECUTED
59f82: 2f0b movel %a3,%sp@- <== NOT EXECUTED
59f84: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
59f8a: 508f addql #8,%sp <== NOT EXECUTED
59f8c: 41fa fea0 lea %pc@(59e2e <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
rc = rtems_rfs_inode_close (fs, &inode);
59f90: 2840 moveal %d0,%a4 <== NOT EXECUTED
if (rc > 0)
59f92: 4a80 tstl %d0 <== NOT EXECUTED
59f94: 6f14 bles 59faa <rtems_rfs_rtems_device_open+0xd2><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
59f96: 2f0b movel %a3,%sp@- <== NOT EXECUTED
59f98: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
59f9a: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
59fa0: 2040 moveal %d0,%a0 <== NOT EXECUTED
59fa2: 208c movel %a4,%a0@ <== NOT EXECUTED
59fa4: 588f addql #4,%sp <== NOT EXECUTED
59fa6: 70ff moveq #-1,%d0 <== NOT EXECUTED
59fa8: 6036 bras 59fe0 <rtems_rfs_rtems_device_open+0x108><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
59faa: 2f0b movel %a3,%sp@- <== NOT EXECUTED
59fac: 4e90 jsr %a0@ <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
59fae: 2d6a 0014 fff8 movel %a2@(20),%fp@(-8) <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
59fb4: 2542 0030 movel %d2,%a2@(48) <== NOT EXECUTED
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
59fb8: 2d6e 0014 fffc movel %fp@(20),%fp@(-4) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
59fbe: 2543 0034 movel %d3,%a2@(52) <== NOT EXECUTED
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
59fc2: 486e fff4 pea %fp@(-12) <== NOT EXECUTED
59fc6: 2f03 movel %d3,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
59fc8: 2d4a fff4 movel %a2,%fp@(-12) <== NOT EXECUTED
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
59fcc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59fce: 4eb9 0005 b13c jsr 5b13c <rtems_io_open> <== NOT EXECUTED
return rtems_deviceio_errno (status);
59fd4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59fd6: 4eb9 0005 a7dc jsr 5a7dc <rtems_deviceio_errno> <== NOT EXECUTED
59fdc: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
}
59fe0: 4cee 3c0c ffb4 moveml %fp@(-76),%d2-%d3/%a2-%a5 <== NOT EXECUTED
59fe6: 4e5e unlk %fp <== NOT EXECUTED
...
00059d8e <rtems_rfs_rtems_device_read>:
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
59d8e: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
59d92: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
59d96: 2d68 0014 fff8 movel %a0@(20),%fp@(-8) <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
59d9c: 2028 0030 movel %a0@(48),%d0 <== NOT EXECUTED
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
59da0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
59da2: 2228 0034 movel %a0@(52),%d1 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
59da6: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
59daa: 2468 0010 moveal %a0@(16),%a2 <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
59dae: 486e ffe4 pea %fp@(-28) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
59db2: 2d6e 000c fff0 movel %fp@(12),%fp@(-16) <== NOT EXECUTED
args.count = count;
59db8: 2d6e 0010 fff4 movel %fp@(16),%fp@(-12) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
59dbe: 2d49 ffe8 movel %a1,%fp@(-24) <== NOT EXECUTED
59dc2: 2d4a ffec movel %a2,%fp@(-20) <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
59dc6: 2f01 movel %d1,%sp@- <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
59dc8: 2d48 ffe4 movel %a0,%fp@(-28) <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
59dcc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
59dce: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
status = rtems_io_read (major, minor, (void *) &args);
59dd2: 4eb9 0005 b180 jsr 5b180 <rtems_io_read> <== NOT EXECUTED
if (status)
59dd8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
59ddc: 4a80 tstl %d0 <== NOT EXECUTED
59dde: 670c beqs 59dec <rtems_rfs_rtems_device_read+0x5e><== NOT EXECUTED
return rtems_deviceio_errno (status);
59de0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59de2: 4eb9 0005 a7dc jsr 5a7dc <rtems_deviceio_errno> <== NOT EXECUTED
59de8: 588f addql #4,%sp <== NOT EXECUTED
59dea: 6004 bras 59df0 <rtems_rfs_rtems_device_read+0x62><== NOT EXECUTED
return (ssize_t) args.bytes_moved;
59dec: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
}
59df0: 246e ffe0 moveal %fp@(-32),%a2 <== NOT EXECUTED
59df4: 4e5e unlk %fp <== NOT EXECUTED
00059d24 <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
59d24: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
59d28: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
59d2c: 2d68 0014 fff8 movel %a0@(20),%fp@(-8) <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
59d32: 2028 0030 movel %a0@(48),%d0 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
59d36: 2f0a movel %a2,%sp@- <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
59d38: 2228 0034 movel %a0@(52),%d1 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
59d3c: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
59d40: 2468 0010 moveal %a0@(16),%a2 <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
59d44: 486e ffe4 pea %fp@(-28) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
59d48: 2d6e 000c fff0 movel %fp@(12),%fp@(-16) <== NOT EXECUTED
args.count = count;
59d4e: 2d6e 0010 fff4 movel %fp@(16),%fp@(-12) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
59d54: 2d49 ffe8 movel %a1,%fp@(-24) <== NOT EXECUTED
59d58: 2d4a ffec movel %a2,%fp@(-20) <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
59d5c: 2f01 movel %d1,%sp@- <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
59d5e: 2d48 ffe4 movel %a0,%fp@(-28) <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
59d62: 2f00 movel %d0,%sp@- <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
59d64: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
status = rtems_io_write (major, minor, (void *) &args);
59d68: 4eb9 0005 b1c4 jsr 5b1c4 <rtems_io_write> <== NOT EXECUTED
if (status)
59d6e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
59d72: 4a80 tstl %d0 <== NOT EXECUTED
59d74: 670c beqs 59d82 <rtems_rfs_rtems_device_write+0x5e><== NOT EXECUTED
return rtems_deviceio_errno (status);
59d76: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59d78: 4eb9 0005 a7dc jsr 5a7dc <rtems_deviceio_errno> <== NOT EXECUTED
59d7e: 588f addql #4,%sp <== NOT EXECUTED
59d80: 6004 bras 59d86 <rtems_rfs_rtems_device_write+0x62><== NOT EXECUTED
return (ssize_t) args.bytes_moved;
59d82: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
}
59d86: 246e ffe0 moveal %fp@(-32),%a2 <== NOT EXECUTED
59d8a: 4e5e unlk %fp <== NOT EXECUTED
0005a054 <rtems_rfs_rtems_dir_lseek>:
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
switch (whence)
5a054: 7001 moveq #1,%d0 <== NOT EXECUTED
*/
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
5a056: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
switch (whence)
5a05a: b0ae 0014 cmpl %fp@(20),%d0 <== NOT EXECUTED
5a05e: 6412 bccs 5a072 <rtems_rfs_rtems_dir_lseek+0x1e> <== NOT EXECUTED
break;
case SEEK_END: /* Movement past the end of the directory via lseek */
/* is not a permitted operation */
default:
return rtems_rfs_rtems_error ("dir_lseek: bad whence", EINVAL);
5a060: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a066: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a068: 7016 moveq #22,%d0 <== NOT EXECUTED
5a06a: 2080 movel %d0,%a0@ <== NOT EXECUTED
5a06c: 70ff moveq #-1,%d0 <== NOT EXECUTED
5a06e: 72ff moveq #-1,%d1 <== NOT EXECUTED
5a070: 6004 bras 5a076 <rtems_rfs_rtems_dir_lseek+0x22> <== NOT EXECUTED
break;
}
return 0;
5a072: 4280 clrl %d0 <== NOT EXECUTED
5a074: 4281 clrl %d1 <== NOT EXECUTED
}
5a076: 4e5e unlk %fp <== NOT EXECUTED
0005a1c8 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
5a1c8: 4e56 ffc8 linkw %fp,#-56
5a1cc: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
5a1d0: 286e 0008 moveal %fp@(8),%a4
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
5a1d4: 47ee ffda lea %fp@(-38),%a3
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
5a1d8: 206c 0028 moveal %a4@(40),%a0
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
5a1dc: 242c 0018 movel %a4@(24),%d2
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
5a1e0: 2468 0034 moveal %a0@(52),%a2
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
5a1e4: 2f2a 007c movel %a2@(124),%sp@-
5a1e8: 4eba fe90 jsr %pc@(5a07a <rtems_rfs_rtems_lock.isra.3>)
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
5a1ec: 4878 0001 pea 1 <ADD>
5a1f0: 2f0b movel %a3,%sp@-
5a1f2: 2f02 movel %d2,%sp@-
5a1f4: 2f0a movel %a2,%sp@-
5a1f6: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc)
5a1fc: 4fef 0014 lea %sp@(20),%sp
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
5a200: 2400 movel %d0,%d2
if (rc)
5a202: 6714 beqs 5a218 <rtems_rfs_rtems_dir_open+0x50> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
5a204: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a206: 4eba fdee jsr %pc@(59ff6 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
5a20a: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a210: 588f addql #4,%sp <== NOT EXECUTED
5a212: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a214: 2082 movel %d2,%a0@ <== NOT EXECUTED
5a216: 603a bras 5a252 <rtems_rfs_rtems_dir_open+0x8a> <== NOT EXECUTED
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
5a218: 206b 000c moveal %a3@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
5a21c: 4280 clrl %d0
5a21e: 1028 0002 moveb %a0@(2),%d0
5a222: e188 lsll #8,%d0
5a224: 0280 0000 f000 andil #61440,%d0
5a22a: 0c80 0000 4000 cmpil #16384,%d0
5a230: 6724 beqs 5a256 <rtems_rfs_rtems_dir_open+0x8e> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
5a232: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5a234: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a236: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
5a23c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a23e: 4eba fdb6 jsr %pc@(59ff6 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
5a242: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a248: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5a24c: 7214 moveq #20,%d1 <== NOT EXECUTED
5a24e: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a250: 2081 movel %d1,%a0@ <== NOT EXECUTED
5a252: 70ff moveq #-1,%d0 <== NOT EXECUTED
5a254: 6022 bras 5a278 <rtems_rfs_rtems_dir_open+0xb0> <== NOT EXECUTED
}
iop->offset = 0;
5a256: 4280 clrl %d0
5a258: 4281 clrl %d1
5a25a: 2940 000c movel %d0,%a4@(12)
5a25e: 2941 0010 movel %d1,%a4@(16)
rtems_rfs_inode_close (fs, &inode);
5a262: 2f0b movel %a3,%sp@-
5a264: 2f0a movel %a2,%sp@-
5a266: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
5a26c: 2f0a movel %a2,%sp@-
5a26e: 4eba fd86 jsr %pc@(59ff6 <rtems_rfs_rtems_unlock>)
return 0;
5a272: 4fef 000c lea %sp@(12),%sp
5a276: 4280 clrl %d0
}
5a278: 4cee 1c04 ffc8 moveml %fp@(-56),%d2/%a2-%a4
5a27e: 4e5e unlk %fp <== NOT EXECUTED
0005a0cc <rtems_rfs_rtems_dir_read>:
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
5a0cc: 223c 0000 0110 movel #272,%d1 <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
5a0d2: 4e56 ffa4 linkw %fp,#-92 <== NOT EXECUTED
5a0d6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
5a0da: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
5a0de: 2a0e movel %fp,%d5 <== NOT EXECUTED
5a0e0: 0685 ffff ffd6 addil #-42,%d5 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
5a0e6: 206b 0028 moveal %a3@(40),%a0 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
5a0ea: 242b 0018 movel %a3@(24),%d2 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
5a0ee: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
int rc;
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
5a0f2: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
5a0f6: 2e2e 0010 movel %fp@(16),%d7 <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
5a0fa: 2a6e 000c moveal %fp@(12),%a5 <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
5a0fe: 4c41 7007 remul %d1,%d7,%d7 <== NOT EXECUTED
dirent = buffer;
rtems_rfs_rtems_lock (fs);
5a102: 4eba ff76 jsr %pc@(5a07a <rtems_rfs_rtems_lock.isra.3>)<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
5a106: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5a10a: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5a10c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5a10e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a110: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
5a116: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
5a11a: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
5a11c: 660e bnes 5a12c <rtems_rfs_rtems_dir_read+0x60> <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
5a11e: 2c0e movel %fp,%d6 <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
5a120: 4284 clrl %d4 <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
5a122: 5986 subql #4,%d6 <== NOT EXECUTED
5a124: 49f9 0005 781c lea 5781c <rtems_rfs_dir_read>,%a4 <== NOT EXECUTED
5a12a: 6072 bras 5a19e <rtems_rfs_rtems_dir_read+0xd2> <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
5a12c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a12e: 4eba fec6 jsr %pc@(59ff6 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
5a132: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a138: 588f addql #4,%sp <== NOT EXECUTED
5a13a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a13c: 2082 movel %d2,%a0@ <== NOT EXECUTED
5a13e: 74ff moveq #-1,%d2 <== NOT EXECUTED
5a140: 607a bras 5a1bc <rtems_rfs_rtems_dir_read+0xf0> <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
5a142: 2f06 movel %d6,%sp@- <== NOT EXECUTED
5a144: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5a146: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
5a14a: 2f2b 000c movel %a3@(12),%sp@- <== NOT EXECUTED
5a14e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5a150: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a152: 4e94 jsr %a4@ <== NOT EXECUTED
if (rc == ENOENT)
5a154: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
5a158: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc == ENOENT)
5a15a: 7002 moveq #2,%d0 <== NOT EXECUTED
5a15c: b083 cmpl %d3,%d0 <== NOT EXECUTED
5a15e: 6746 beqs 5a1a6 <rtems_rfs_rtems_dir_read+0xda> <== NOT EXECUTED
{
rc = 0;
break;
}
if (rc > 0)
5a160: 4a83 tstl %d3 <== NOT EXECUTED
5a162: 6f0e bles 5a172 <rtems_rfs_rtems_dir_read+0xa6> <== NOT EXECUTED
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
5a164: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a16a: 74ff moveq #-1,%d2 <== NOT EXECUTED
5a16c: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a16e: 2083 movel %d3,%a0@ <== NOT EXECUTED
5a170: 6034 bras 5a1a6 <rtems_rfs_rtems_dir_read+0xda> <== NOT EXECUTED
break;
}
iop->offset += size;
5a172: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
5a176: 91c8 subal %a0,%a0 <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
5a178: 0682 0000 0110 addil #272,%d2 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
5a17e: 5284 addql #1,%d4 <== NOT EXECUTED
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
5a180: 2d40 ffd0 movel %d0,%fp@(-48) <== NOT EXECUTED
5a184: 2d48 ffcc movel %a0,%fp@(-52) <== NOT EXECUTED
5a188: 202e ffcc movel %fp@(-52),%d0 <== NOT EXECUTED
5a18c: 222e ffd0 movel %fp@(-48),%d1 <== NOT EXECUTED
5a190: d3ab 0010 addl %d1,%a3@(16) <== NOT EXECUTED
5a194: 262b 000c movel %a3@(12),%d3 <== NOT EXECUTED
5a198: d780 addxl %d0,%d3 <== NOT EXECUTED
5a19a: 2743 000c movel %d3,%a3@(12) <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
5a19e: 200d movel %a5,%d0 <== NOT EXECUTED
5a1a0: d082 addl %d2,%d0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
5a1a2: be84 cmpl %d4,%d7 <== NOT EXECUTED
5a1a4: 669c bnes 5a142 <rtems_rfs_rtems_dir_read+0x76> <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
5a1a6: 486e ffd6 pea %fp@(-42) <== NOT EXECUTED
5a1aa: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a1ac: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
5a1b2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a1b4: 4eba fe40 jsr %pc@(59ff6 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return bytes_transferred;
5a1b8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
5a1bc: 2002 movel %d2,%d0 <== NOT EXECUTED
5a1be: 4cee 3cfc ffa4 moveml %fp@(-92),%d2-%d7/%a2-%a5 <== NOT EXECUTED
5a1c4: 4e5e unlk %fp <== NOT EXECUTED
0005a282 <rtems_rfs_rtems_dir_rmnod>:
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
5a282: 7001 moveq #1,%d0 <== NOT EXECUTED
}
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
5a284: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
5a288: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
5a28c: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
}
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
5a290: 48d7 041c moveml %d2-%d4/%a2,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
5a294: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
5a298: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
5a29c: 2410 movel %a0@,%d2 <== NOT EXECUTED
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
5a29e: 2611 movel %a1@,%d3 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
5a2a0: 2828 0004 movel %a0@(4),%d4 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
5a2a4: b082 cmpl %d2,%d0 <== NOT EXECUTED
5a2a6: 660e bnes 5a2b6 <rtems_rfs_rtems_dir_rmnod+0x34> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
5a2a8: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a2ae: 7410 moveq #16,%d2 <== NOT EXECUTED
5a2b0: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a2b2: 2082 movel %d2,%a0@ <== NOT EXECUTED
5a2b4: 6036 bras 5a2ec <rtems_rfs_rtems_dir_rmnod+0x6a> <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
5a2b6: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
5a2ba: 4eba fdbe jsr %pc@(5a07a <rtems_rfs_rtems_lock.isra.3>)<== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
5a2be: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5a2c2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5a2c4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5a2c6: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5a2c8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a2ca: 4eb9 0005 9442 jsr 59442 <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
5a2d0: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
5a2d4: 41fa fd20 lea %pc@(59ff6 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
if (ino == RTEMS_RFS_ROOT_INO)
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
5a2d8: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
5a2da: 6714 beqs 5a2f0 <rtems_rfs_rtems_dir_rmnod+0x6e> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
5a2dc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a2de: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
5a2e0: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a2e6: 588f addql #4,%sp <== NOT EXECUTED
5a2e8: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a2ea: 2082 movel %d2,%a0@ <== NOT EXECUTED
5a2ec: 70ff moveq #-1,%d0 <== NOT EXECUTED
5a2ee: 6008 bras 5a2f8 <rtems_rfs_rtems_dir_rmnod+0x76> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
5a2f0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a2f2: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
5a2f4: 588f addql #4,%sp <== NOT EXECUTED
5a2f6: 4280 clrl %d0 <== NOT EXECUTED
}
5a2f8: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 <== NOT EXECUTED
5a2fe: 4e5e unlk %fp <== NOT EXECUTED
...
0004ea34 <rtems_rfs_rtems_eval_for_make>:
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
4ea34: 4e56 ffa4 linkw %fp,#-92
4ea38: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4ea3c: 286e 000c moveal %fp@(12),%a4
*name = path + strlen (path);
while (*name != path)
{
(*name)--;
if (rtems_filesystem_is_separator (**name))
4ea40: 47f9 0004 6a68 lea 46a68 <rtems_filesystem_is_separator>,%a3
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4ea46: 206c 0010 moveal %a4@(16),%a0
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4ea4a: 2d54 fff4 movel %a4@,%fp@(-12)
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4ea4e: 2468 0034 moveal %a0@(52),%a2
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
4ea52: 242e 0008 movel %fp@(8),%d2
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_ino node_ino;
uint32_t doff = 0;
4ea56: 42ae fffc clrl %fp@(-4)
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
4ea5a: 2a6e 0010 moveal %fp@(16),%a5
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
4ea5e: 2f02 movel %d2,%sp@-
4ea60: 4eb9 0005 cdac jsr 5cdac <strlen>
4ea66: 588f addql #4,%sp
4ea68: d082 addl %d2,%d0
4ea6a: 2a80 movel %d0,%a5@
while (*name != path)
4ea6c: 601a bras 4ea88 <rtems_rfs_rtems_eval_for_make+0x54>
{
(*name)--;
4ea6e: 2008 movel %a0,%d0
4ea70: 5380 subql #1,%d0
4ea72: 2a80 movel %d0,%a5@
if (rtems_filesystem_is_separator (**name))
4ea74: 1228 ffff moveb %a0@(-1),%d1
4ea78: 49c1 extbl %d1
4ea7a: 2f01 movel %d1,%sp@-
4ea7c: 4e93 jsr %a3@
4ea7e: 588f addql #4,%sp
4ea80: 4a80 tstl %d0
4ea82: 6704 beqs 4ea88 <rtems_rfs_rtems_eval_for_make+0x54>
{
(*name)++;
4ea84: 5295 addql #1,%a5@
break;
4ea86: 6006 bras 4ea8e <rtems_rfs_rtems_eval_for_make+0x5a>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
while (*name != path)
4ea88: 2055 moveal %a5@,%a0
4ea8a: b488 cmpl %a0,%d2
4ea8c: 66e0 bnes 4ea6e <rtems_rfs_rtems_eval_for_make+0x3a>
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
4ea8e: 2f02 movel %d2,%sp@-
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4ea90: 2e0e movel %fp,%d7
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ea92: 47ee ffce lea %fp@(-50),%a3
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4ea96: 0687 ffff fff4 addil #-12,%d7
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
4ea9c: 4eb9 0005 cdac jsr 5cdac <strlen>
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
4eaa2: 2c3c 0004 6a68 movel #289384,%d6
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
4eaa8: 2e80 movel %d0,%sp@
4eaaa: 2f02 movel %d2,%sp@-
4eaac: 4eb9 0004 537e jsr 4537e <rtems_filesystem_prefix_separators>
path += stripped;
rtems_rfs_rtems_lock (fs);
4eab2: 2f2a 007c movel %a2@(124),%sp@-
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
path += stripped;
4eab6: d480 addl %d0,%d2
rtems_rfs_rtems_lock (fs);
4eab8: 4eba f858 jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
4eabc: 4fef 000c lea %sp@(12),%sp
4eac0: 6002 bras 4eac4 <rtems_rfs_rtems_eval_for_make+0x90>
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
path += stripped;
4eac2: 2404 movel %d4,%d2
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4eac4: 4878 0001 pea 1 <ADD>
4eac8: 2f0b movel %a3,%sp@-
4eaca: 2f2e fff4 movel %fp@(-12),%sp@-
4eace: 2f0a movel %a2,%sp@-
4ead0: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
4ead6: 4fef 0010 lea %sp@(16),%sp
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4eada: 2600 movel %d0,%d3
if (rc > 0)
4eadc: 6f14 bles 4eaf2 <rtems_rfs_rtems_eval_for_make+0xbe><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4eade: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eae0: 4eba f612 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);
4eae4: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4eaea: 2040 moveal %d0,%a0 <== NOT EXECUTED
4eaec: 2083 movel %d3,%a0@ <== NOT EXECUTED
4eaee: 6000 020c braw 4ecfc <rtems_rfs_rtems_eval_for_make+0x2c8><== NOT EXECUTED
}
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
4eaf2: 206b 000c moveal %a3@(12),%a0
4eaf6: 4280 clrl %d0
4eaf8: 1028 0002 moveb %a0@(2),%d0
4eafc: e188 lsll #8,%d0
4eafe: 0280 0000 f000 andil #61440,%d0
4eb04: 0c80 0000 4000 cmpil #16384,%d0
4eb0a: 6638 bnes 4eb44 <rtems_rfs_rtems_eval_for_make+0x110>
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
4eb0c: 4878 0001 pea 1 <ADD>
4eb10: 2f0b movel %a3,%sp@-
4eb12: 4eb9 0004 f498 jsr 4f498 <rtems_rfs_rtems_eval_perms>
}
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
4eb18: 508f addql #8,%sp
4eb1a: 4a00 tstb %d0
4eb1c: 6626 bnes 4eb44 <rtems_rfs_rtems_eval_for_make+0x110><== ALWAYS TAKEN
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
4eb1e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
4eb20: 7c0d moveq #13,%d6 <== NOT EXECUTED
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
4eb22: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eb24: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4eb2a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eb2c: 4eba f5c6 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
4eb30: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4eb36: 2240 moveal %d0,%a1 <== NOT EXECUTED
4eb38: 2286 movel %d6,%a1@ <== NOT EXECUTED
4eb3a: 4fef 000c lea %sp@(12),%sp
4eb3e: 74ff moveq #-1,%d2
4eb40: 6000 02b6 braw 4edf8 <rtems_rfs_rtems_eval_for_make+0x3c4>
}
/*
* Is this the end of the pathname we where given ?
*/
if (path == *name)
4eb44: b495 cmpl %a5@,%d2
4eb46: 6700 01ba beqw 4ed02 <rtems_rfs_rtems_eval_for_make+0x2ce>
4eb4a: 2a02 movel %d2,%d5
4eb4c: 4283 clrl %d3
4eb4e: 6002 bras 4eb52 <rtems_rfs_rtems_eval_for_make+0x11e>
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
{
node_len++;
4eb50: 5283 addql #1,%d3
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
4eb52: 2045 moveal %d5,%a0
4eb54: 2246 moveal %d6,%a1
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
{
node_len++;
4eb56: 2805 movel %d5,%d4
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
4eb58: 1010 moveb %a0@,%d0
4eb5a: 49c0 extbl %d0
4eb5c: 2f00 movel %d0,%sp@-
4eb5e: 4e91 jsr %a1@
4eb60: 588f addql #4,%sp
4eb62: 4a80 tstl %d0
4eb64: 6612 bnes 4eb78 <rtems_rfs_rtems_eval_for_make+0x144>
4eb66: 5285 addql #1,%d5
4eb68: 2044 moveal %d4,%a0
4eb6a: 4a10 tstb %a0@
4eb6c: 670a beqs 4eb78 <rtems_rfs_rtems_eval_for_make+0x144><== NEVER TAKEN
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
4eb6e: 202a 0018 movel %a2@(24),%d0
4eb72: 5380 subql #1,%d0
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
(*path != '\0') &&
4eb74: b083 cmpl %d3,%d0
4eb76: 62d8 bhis 4eb50 <rtems_rfs_rtems_eval_for_make+0x11c><== ALWAYS TAKEN
}
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
4eb78: 2f04 movel %d4,%sp@-
4eb7a: 4eb9 0005 cdac jsr 5cdac <strlen>
4eb80: 2e80 movel %d0,%sp@
4eb82: 2f04 movel %d4,%sp@-
4eb84: 4eb9 0004 537e jsr 4537e <rtems_filesystem_prefix_separators>
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
4eb8a: 508f addql #8,%sp
4eb8c: 2242 moveal %d2,%a1
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
path += stripped;
4eb8e: d880 addl %d0,%d4
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
4eb90: 722e moveq #46,%d1
4eb92: 1011 moveb %a1@,%d0
4eb94: 49c0 extbl %d0
4eb96: b280 cmpl %d0,%d1
4eb98: 662c bnes 4ebc6 <rtems_rfs_rtems_eval_for_make+0x192><== ALWAYS TAKEN
4eb9a: 1029 0001 moveb %a1@(1),%d0 <== NOT EXECUTED
4eb9e: 670e beqs 4ebae <rtems_rfs_rtems_eval_for_make+0x17a><== NOT EXECUTED
4eba0: 49c0 extbl %d0 <== NOT EXECUTED
4eba2: 2046 moveal %d6,%a0 <== NOT EXECUTED
4eba4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4eba6: 4e90 jsr %a0@ <== NOT EXECUTED
4eba8: 588f addql #4,%sp <== NOT EXECUTED
4ebaa: 4a80 tstl %d0 <== NOT EXECUTED
4ebac: 6718 beqs 4ebc6 <rtems_rfs_rtems_eval_for_make+0x192><== NOT EXECUTED
{
if (*path)
4ebae: 2244 moveal %d4,%a1 <== NOT EXECUTED
4ebb0: 4a11 tstb %a1@ <== NOT EXECUTED
4ebb2: 6700 014e beqw 4ed02 <rtems_rfs_rtems_eval_for_make+0x2ce><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4ebb6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ebb8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ebba: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
continue;
4ebc0: 508f addql #8,%sp <== NOT EXECUTED
4ebc2: 6000 fefe braw 4eac2 <rtems_rfs_rtems_eval_for_make+0x8e><== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (path))
4ebc6: 2044 moveal %d4,%a0
4ebc8: 722e moveq #46,%d1
4ebca: 1010 moveb %a0@,%d0
4ebcc: 49c0 extbl %d0
4ebce: b280 cmpl %d0,%d1
4ebd0: 6600 00ea bnew 4ecbc <rtems_rfs_rtems_eval_for_make+0x288>
4ebd4: 1028 0001 moveb %a0@(1),%d0 <== NOT EXECUTED
4ebd8: 49c0 extbl %d0 <== NOT EXECUTED
4ebda: b280 cmpl %d0,%d1 <== NOT EXECUTED
4ebdc: 6600 00de bnew 4ecbc <rtems_rfs_rtems_eval_for_make+0x288><== NOT EXECUTED
4ebe0: 1028 0002 moveb %a0@(2),%d0 <== NOT EXECUTED
4ebe4: 6710 beqs 4ebf6 <rtems_rfs_rtems_eval_for_make+0x1c2><== NOT EXECUTED
4ebe6: 49c0 extbl %d0 <== NOT EXECUTED
4ebe8: 2046 moveal %d6,%a0 <== NOT EXECUTED
4ebea: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ebec: 4e90 jsr %a0@ <== NOT EXECUTED
4ebee: 588f addql #4,%sp <== NOT EXECUTED
4ebf0: 4a80 tstl %d0 <== NOT EXECUTED
4ebf2: 6700 00c8 beqw 4ecbc <rtems_rfs_rtems_eval_for_make+0x288><== NOT EXECUTED
{
/*
* If we are at the root inode of the file system we have a crossmount
* path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
4ebf6: 7001 moveq #1,%d0 <== NOT EXECUTED
4ebf8: b0ae fff4 cmpl %fp@(-12),%d0 <== NOT EXECUTED
4ebfc: 6642 bnes 4ec40 <rtems_rfs_rtems_eval_for_make+0x20c><== NOT EXECUTED
{
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
path - node_len);
rtems_rfs_inode_close (fs, &inode);
4ebfe: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ec00: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ec02: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4ec08: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ec0a: 4eba f4e8 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
*pathloc = pathloc->mt_entry->mt_point_node;
4ec0e: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
4ec12: 222c 0010 movel %a4@(16),%d1 <== NOT EXECUTED
4ec16: 5081 addql #8,%d1 <== NOT EXECUTED
4ec18: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4ec1a: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4ec1c: 4eb9 0005 bf8c jsr 5bf8c <memcpy> <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
4ec22: 206c 000c moveal %a4@(12),%a0 <== NOT EXECUTED
4ec26: 2244 moveal %d4,%a1 <== NOT EXECUTED
4ec28: 2f0d movel %a5,%sp@- <== NOT EXECUTED
4ec2a: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4ec2c: 4869 0002 pea %a1@(2) <== NOT EXECUTED
4ec30: 2068 0004 moveal %a0@(4),%a0 <== NOT EXECUTED
4ec34: 4e90 jsr %a0@ <== NOT EXECUTED
4ec36: 4fef 0024 lea %sp@(36),%sp <== NOT EXECUTED
4ec3a: 2400 movel %d0,%d2 <== NOT EXECUTED
4ec3c: 6000 01ba braw 4edf8 <rtems_rfs_rtems_eval_for_make+0x3c4><== NOT EXECUTED
/*
* If not a directory give and up return. We cannot change dir from a
* regular file or device node.
*/
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
4ec40: 206b 000c moveal %a3@(12),%a0 <== NOT EXECUTED
4ec44: 4280 clrl %d0 <== NOT EXECUTED
4ec46: 1028 0002 moveb %a0@(2),%d0 <== NOT EXECUTED
4ec4a: e188 lsll #8,%d0 <== NOT EXECUTED
4ec4c: 0280 0000 f000 andil #61440,%d0 <== NOT EXECUTED
4ec52: 0c80 0000 4000 cmpil #16384,%d0 <== NOT EXECUTED
4ec58: 6722 beqs 4ec7c <rtems_rfs_rtems_eval_for_make+0x248><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4ec5a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ec5c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ec5e: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4ec64: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ec66: 4eba f48c jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
4ec6a: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4ec70: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ec72: 20bc 0000 0086 movel #134,%a0@ <== NOT EXECUTED
4ec78: 6000 fec0 braw 4eb3a <rtems_rfs_rtems_eval_for_make+0x106><== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
4ec7c: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4ec80: 2f07 movel %d7,%sp@- <== NOT EXECUTED
4ec82: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
4ec86: 4879 0006 a059 pea 6a059 <_rodata_start+0x1a9> <== NOT EXECUTED
4ec8c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ec8e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ec90: 4eb9 0005 6cda jsr 56cda <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
if (rc > 0)
4ec96: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
4ec9a: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
4ec9c: 6f3c bles 4ecda <rtems_rfs_rtems_eval_for_make+0x2a6><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4ec9e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4eca0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eca2: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4eca8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ecaa: 4eba f448 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: read parent inode", rc);
4ecae: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4ecb4: 2240 moveal %d0,%a1 <== NOT EXECUTED
4ecb6: 2282 movel %d2,%a1@ <== NOT EXECUTED
4ecb8: 6000 fe80 braw 4eb3a <rtems_rfs_rtems_eval_for_make+0x106><== NOT EXECUTED
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4ecbc: 486e fffc pea %fp@(-4)
4ecc0: 2f07 movel %d7,%sp@-
4ecc2: 2f03 movel %d3,%sp@-
4ecc4: 2f02 movel %d2,%sp@-
4ecc6: 2f0b movel %a3,%sp@-
4ecc8: 2f0a movel %a2,%sp@-
4ecca: 4eb9 0005 6cda jsr 56cda <rtems_rfs_dir_lookup_ino>
node, node_len - stripped, &ino, &doff);
if (rc > 0)
4ecd0: 4fef 0018 lea %sp@(24),%sp
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4ecd4: 2400 movel %d0,%d2
node, node_len - stripped, &ino, &doff);
if (rc > 0)
4ecd6: 6e00 00cc bgtw 4eda4 <rtems_rfs_rtems_eval_for_make+0x370>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: down: path:%s ino:%" PRId32 "\n",
node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
4ecda: 2f0b movel %a3,%sp@-
4ecdc: 2f0a movel %a2,%sp@-
4ecde: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
if (rc > 0)
4ece4: 508f addql #8,%sp
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: down: path:%s ino:%" PRId32 "\n",
node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
4ece6: 2400 movel %d0,%d2
if (rc > 0)
4ece8: 6f00 fdd8 blew 4eac2 <rtems_rfs_rtems_eval_for_make+0x8e>
{
rtems_rfs_rtems_unlock (fs);
4ecec: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ecee: 4eba f404 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
4ecf2: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4ecf8: 2240 moveal %d0,%a1 <== NOT EXECUTED
4ecfa: 2282 movel %d2,%a1@ <== NOT EXECUTED
4ecfc: 588f addql #4,%sp <== NOT EXECUTED
4ecfe: 6000 fe3e braw 4eb3e <rtems_rfs_rtems_eval_for_make+0x10a><== NOT EXECUTED
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
4ed02: 47ee ffce lea %fp@(-50),%a3
4ed06: 4280 clrl %d0
4ed08: 206b 000c moveal %a3@(12),%a0
4ed0c: 1028 0002 moveb %a0@(2),%d0
4ed10: e188 lsll #8,%d0
4ed12: 0280 0000 f000 andil #61440,%d0
4ed18: 0c80 0000 4000 cmpil #16384,%d0
4ed1e: 6720 beqs 4ed40 <rtems_rfs_rtems_eval_for_make+0x30c>
{
rtems_rfs_inode_close (fs, &inode);
4ed20: 2f0b movel %a3,%sp@-
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
4ed22: 7a14 moveq #20,%d5
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
4ed24: 2f0a movel %a2,%sp@-
4ed26: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4ed2c: 2f0a movel %a2,%sp@-
4ed2e: 4eba f3c4 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
4ed32: 4eb9 0005 b6e4 jsr 5b6e4 <__errno>
4ed38: 2040 moveal %d0,%a0
4ed3a: 2085 movel %d5,%a0@
4ed3c: 6000 fdfc braw 4eb3a <rtems_rfs_rtems_eval_for_make+0x106>
}
if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))
4ed40: 4878 0003 pea 3 <DIVIDE>
4ed44: 2f0b movel %a3,%sp@-
4ed46: 4eb9 0004 f498 jsr 4f498 <rtems_rfs_rtems_eval_perms>
4ed4c: 508f addql #8,%sp
4ed4e: 4a00 tstb %d0
4ed50: 6700 fdcc beqw 4eb1e <rtems_rfs_rtems_eval_for_make+0xea>
}
/*
* Make sure the name does not already exists in the directory.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
4ed54: 2415 movel %a5@,%d2
4ed56: 2f02 movel %d2,%sp@-
4ed58: 4eb9 0005 cdac jsr 5cdac <strlen>
4ed5e: 588f addql #4,%sp
4ed60: 486e fffc pea %fp@(-4)
4ed64: 486e fff8 pea %fp@(-8)
4ed68: 2f00 movel %d0,%sp@-
4ed6a: 2f02 movel %d2,%sp@-
4ed6c: 2f0b movel %a3,%sp@-
4ed6e: 2f0a movel %a2,%sp@-
4ed70: 4eb9 0005 6cda jsr 56cda <rtems_rfs_dir_lookup_ino>
&node_ino, &doff);
if (rc == 0)
4ed76: 4fef 0018 lea %sp@(24),%sp
}
/*
* Make sure the name does not already exists in the directory.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
4ed7a: 2400 movel %d0,%d2
&node_ino, &doff);
if (rc == 0)
4ed7c: 6620 bnes 4ed9e <rtems_rfs_rtems_eval_for_make+0x36a>
{
rtems_rfs_inode_close (fs, &inode);
4ed7e: 2f0b movel %a3,%sp@-
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
4ed80: 7811 moveq #17,%d4
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
&node_ino, &doff);
if (rc == 0)
{
rtems_rfs_inode_close (fs, &inode);
4ed82: 2f0a movel %a2,%sp@-
4ed84: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4ed8a: 2f0a movel %a2,%sp@-
4ed8c: 4eba f366 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
4ed90: 4eb9 0005 b6e4 jsr 5b6e4 <__errno>
4ed96: 2040 moveal %d0,%a0
4ed98: 2084 movel %d4,%a0@
4ed9a: 6000 fd9e braw 4eb3a <rtems_rfs_rtems_eval_for_make+0x106>
}
if (rc != ENOENT)
4ed9e: 7002 moveq #2,%d0
4eda0: b082 cmpl %d2,%d0
4eda2: 671e beqs 4edc2 <rtems_rfs_rtems_eval_for_make+0x38e><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
4eda4: 2f0b movel %a3,%sp@-
4eda6: 2f0a movel %a2,%sp@-
4eda8: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4edae: 2f0a movel %a2,%sp@-
4edb0: 4eba f342 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
return rtems_rfs_rtems_error ("eval_for_make: look up", rc);
4edb4: 4eb9 0005 b6e4 jsr 5b6e4 <__errno>
4edba: 2040 moveal %d0,%a0
4edbc: 2082 movel %d2,%a0@
4edbe: 6000 fd7a braw 4eb3a <rtems_rfs_rtems_eval_for_make+0x106>
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
4edc2: 28ae fff4 movel %fp@(-12),%a4@
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
4edc6: 296e fffc 0004 movel %fp@(-4),%a4@(4)
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
4edcc: 2f0b movel %a3,%sp@-
4edce: 2f0c movel %a4,%sp@-
4edd0: 4eb9 0004 f544 jsr 4f544 <rtems_rfs_rtems_set_handlers>
4edd6: 508f addql #8,%sp
4edd8: 4a00 tstb %d0
4edda: 6704 beqs 4ede0 <rtems_rfs_rtems_eval_for_make+0x3ac><== NEVER TAKEN
4eddc: 4282 clrl %d2
4edde: 6002 bras 4ede2 <rtems_rfs_rtems_eval_for_make+0x3ae>
4ede0: 7405 moveq #5,%d2 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
ino, *name);
rtems_rfs_inode_close (fs, &inode);
4ede2: 486e ffce pea %fp@(-50)
4ede6: 2f0a movel %a2,%sp@-
4ede8: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4edee: 2f0a movel %a2,%sp@-
4edf0: 4eba f302 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
return rc;
4edf4: 4fef 000c lea %sp@(12),%sp
}
4edf8: 2002 movel %d2,%d0
4edfa: 4cee 3cfc ffa4 moveml %fp@(-92),%d2-%d7/%a2-%a5
4ee00: 4e5e unlk %fp <== NOT EXECUTED
0004ee04 <rtems_rfs_rtems_eval_path>:
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
4ee04: 4e56 ffa4 linkw %fp,#-92
4ee08: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4ee0c: 286e 0014 moveal %fp@(20),%a4
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4ee10: 2e0e movel %fp,%d7
4ee12: 2c0e movel %fp,%d6
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ee14: 47ee ffd2 lea %fp@(-46),%a3
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
4ee18: 2a3c 0004 6a68 movel #289384,%d5
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4ee1e: 5987 subql #4,%d7
4ee20: 5186 subql #8,%d6
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4ee22: 206c 0010 moveal %a4@(16),%a0
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4ee26: 2d54 fff8 movel %a4@,%fp@(-8)
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4ee2a: 2468 0034 moveal %a0@(52),%a2
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
4ee2e: 242e 000c movel %fp@(12),%d2
4ee32: 2a6e 0008 moveal %fp@(8),%a5
path, pathlen, ino);
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
4ee36: 2f02 movel %d2,%sp@-
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = 0;
4ee38: 42ae fffc clrl %fp@(-4)
path, pathlen, ino);
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
4ee3c: 2f0d movel %a5,%sp@-
4ee3e: 4eb9 0004 537e jsr 4537e <rtems_filesystem_prefix_separators>
path += stripped;
pathlen -= stripped;
rtems_rfs_rtems_lock (fs);
4ee44: 2f2a 007c movel %a2@(124),%sp@-
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
4ee48: dbc0 addal %d0,%a5
pathlen -= stripped;
4ee4a: 9480 subl %d0,%d2
rtems_rfs_rtems_lock (fs);
4ee4c: 4eba f4c4 jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
4ee50: 4fef 000c lea %sp@(12),%sp
4ee54: 6002 bras 4ee58 <rtems_rfs_rtems_eval_path+0x54>
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
4ee56: 2a44 moveal %d4,%a5
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ee58: 4878 0001 pea 1 <ADD>
4ee5c: 2f0b movel %a3,%sp@-
4ee5e: 2f2e fff8 movel %fp@(-8),%sp@-
4ee62: 2f0a movel %a2,%sp@-
4ee64: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
4ee6a: 4fef 0010 lea %sp@(16),%sp
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ee6e: 2600 movel %d0,%d3
if (rc > 0)
4ee70: 6f14 bles 4ee86 <rtems_rfs_rtems_eval_path+0x82> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4ee72: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ee74: 4eba f27e jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: opening inode", rc);
4ee78: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4ee7e: 588f addql #4,%sp <== NOT EXECUTED
4ee80: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ee82: 2083 movel %d3,%a0@ <== NOT EXECUTED
4ee84: 605e bras 4eee4 <rtems_rfs_rtems_eval_path+0xe0> <== NOT EXECUTED
}
/*
* Is this the end of the pathname we where given ?
*/
if ((*path == '\0') || (pathlen == 0))
4ee86: 4a15 tstb %a5@
4ee88: 6700 01f6 beqw 4f080 <rtems_rfs_rtems_eval_path+0x27c>
4ee8c: 4a82 tstl %d2
4ee8e: 6700 01f0 beqw 4f080 <rtems_rfs_rtems_eval_path+0x27c>
break;
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
4ee92: 206b 000c moveal %a3@(12),%a0
4ee96: 4280 clrl %d0
4ee98: 1028 0002 moveb %a0@(2),%d0
4ee9c: e188 lsll #8,%d0
4ee9e: 0280 0000 f000 andil #61440,%d0
4eea4: 0c80 0000 4000 cmpil #16384,%d0
4eeaa: 6612 bnes 4eebe <rtems_rfs_rtems_eval_path+0xba>
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
4eeac: 4878 0001 pea 1 <ADD>
4eeb0: 2f0b movel %a3,%sp@-
4eeb2: 4eb9 0004 f498 jsr 4f498 <rtems_rfs_rtems_eval_perms>
break;
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
4eeb8: 508f addql #8,%sp
4eeba: 4a00 tstb %d0
4eebc: 6706 beqs 4eec4 <rtems_rfs_rtems_eval_path+0xc0> <== NEVER TAKEN
4eebe: 280d movel %a5,%d4
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
4eec0: 4283 clrl %d3
4eec2: 602a bras 4eeee <rtems_rfs_rtems_eval_path+0xea>
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
4eec4: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
4eec6: 7e0d moveq #13,%d7 <== NOT EXECUTED
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
4eec8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eeca: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4eed0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eed2: 4eba f220 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
4eed6: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4eedc: 2240 moveal %d0,%a1 <== NOT EXECUTED
4eede: 2287 movel %d7,%a1@ <== NOT EXECUTED
4eee0: 4fef 000c lea %sp@(12),%sp
4eee4: 74ff moveq #-1,%d2
4eee6: 6000 01d4 braw 4f0bc <rtems_rfs_rtems_eval_path+0x2b8>
while (!rtems_filesystem_is_separator (*path) &&
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
{
path++;
pathlen--;
4eeea: 5382 subql #1,%d2
4eeec: 2600 movel %d0,%d3
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
4eeee: 2044 moveal %d4,%a0
4eef0: 2245 moveal %d5,%a1
4eef2: 1010 moveb %a0@,%d0
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
{
path++;
pathlen--;
4eef4: 2d44 ffcc movel %d4,%fp@(-52)
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
4eef8: 49c0 extbl %d0
4eefa: 2f00 movel %d0,%sp@-
4eefc: 4e91 jsr %a1@
4eefe: 588f addql #4,%sp
4ef00: 4a80 tstl %d0
4ef02: 6618 bnes 4ef1c <rtems_rfs_rtems_eval_path+0x118>
4ef04: 206e ffcc moveal %fp@(-52),%a0
4ef08: 5284 addql #1,%d4
4ef0a: 4a10 tstb %a0@
4ef0c: 670e beqs 4ef1c <rtems_rfs_rtems_eval_path+0x118><== NEVER TAKEN
(*path != '\0') && pathlen &&
4ef0e: 4a82 tstl %d2
4ef10: 670a beqs 4ef1c <rtems_rfs_rtems_eval_path+0x118><== NEVER TAKEN
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
4ef12: 2003 movel %d3,%d0
4ef14: 5280 addql #1,%d0
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
(*path != '\0') && pathlen &&
4ef16: b0aa 0018 cmpl %a2@(24),%d0
4ef1a: 65ce bcss 4eeea <rtems_rfs_rtems_eval_path+0xe6> <== ALWAYS TAKEN
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
4ef1c: 2f02 movel %d2,%sp@-
4ef1e: 2f2e ffcc movel %fp@(-52),%sp@-
4ef22: 4eb9 0004 537e jsr 4537e <rtems_filesystem_prefix_separators>
path += stripped;
4ef28: 282e ffcc movel %fp@(-52),%d4
pathlen -= stripped;
node_len += stripped;
4ef2c: 2240 moveal %d0,%a1
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
4ef2e: d880 addl %d0,%d4
pathlen -= stripped;
4ef30: 9480 subl %d0,%d2
node_len += stripped;
4ef32: d3c3 addal %d3,%a1
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
4ef34: 508f addql #8,%sp
4ef36: 722e moveq #46,%d1
4ef38: 1015 moveb %a5@,%d0
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
pathlen -= stripped;
node_len += stripped;
4ef3a: 2d49 ffcc movel %a1,%fp@(-52)
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
4ef3e: 49c0 extbl %d0
4ef40: b280 cmpl %d0,%d1
4ef42: 662c bnes 4ef70 <rtems_rfs_rtems_eval_path+0x16c>
4ef44: 102d 0001 moveb %a5@(1),%d0
4ef48: 670e beqs 4ef58 <rtems_rfs_rtems_eval_path+0x154>
4ef4a: 49c0 extbl %d0
4ef4c: 2045 moveal %d5,%a0
4ef4e: 2f00 movel %d0,%sp@-
4ef50: 4e90 jsr %a0@
4ef52: 588f addql #4,%sp
4ef54: 4a80 tstl %d0
4ef56: 6718 beqs 4ef70 <rtems_rfs_rtems_eval_path+0x16c><== ALWAYS TAKEN
{
if (*path)
4ef58: 2244 moveal %d4,%a1
4ef5a: 4a11 tstb %a1@
4ef5c: 6700 0122 beqw 4f080 <rtems_rfs_rtems_eval_path+0x27c>
{
rtems_rfs_inode_close (fs, &inode);
4ef60: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ef62: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ef64: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
continue;
4ef6a: 508f addql #8,%sp <== NOT EXECUTED
4ef6c: 6000 fee8 braw 4ee56 <rtems_rfs_rtems_eval_path+0x52> <== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (node))
4ef70: 722e moveq #46,%d1
4ef72: 1015 moveb %a5@,%d0
4ef74: 49c0 extbl %d0
4ef76: b280 cmpl %d0,%d1
4ef78: 6600 00a0 bnew 4f01a <rtems_rfs_rtems_eval_path+0x216>
4ef7c: 102d 0001 moveb %a5@(1),%d0
4ef80: 49c0 extbl %d0
4ef82: b280 cmpl %d0,%d1
4ef84: 6600 0094 bnew 4f01a <rtems_rfs_rtems_eval_path+0x216>
4ef88: 102d 0002 moveb %a5@(2),%d0
4ef8c: 670e beqs 4ef9c <rtems_rfs_rtems_eval_path+0x198><== ALWAYS TAKEN
4ef8e: 49c0 extbl %d0 <== NOT EXECUTED
4ef90: 2045 moveal %d5,%a0 <== NOT EXECUTED
4ef92: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ef94: 4e90 jsr %a0@ <== NOT EXECUTED
4ef96: 588f addql #4,%sp <== NOT EXECUTED
4ef98: 4a80 tstl %d0 <== NOT EXECUTED
4ef9a: 677e beqs 4f01a <rtems_rfs_rtems_eval_path+0x216><== NOT EXECUTED
{
/*
* If we are at root inode of the file system we have a crossmount path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
4ef9c: 7001 moveq #1,%d0
4ef9e: b0ae fff8 cmpl %fp@(-8),%d0
4efa2: 664a bnes 4efee <rtems_rfs_rtems_eval_path+0x1ea>
{
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
4efa4: 486e ffd2 pea %fp@(-46)
4efa8: 2f0a movel %a2,%sp@-
4efaa: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4efb0: 2f0a movel %a2,%sp@-
4efb2: 4eba f140 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
*pathloc = pathloc->mt_entry->mt_point_node;
4efb6: 4878 0014 pea 14 <OPER2>
4efba: 222c 0010 movel %a4@(16),%d1
4efbe: 5081 addql #8,%d1
4efc0: 2f01 movel %d1,%sp@-
4efc2: 2f0c movel %a4,%sp@-
4efc4: 4eb9 0005 bf8c jsr 5bf8c <memcpy>
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
4efca: 206c 000c moveal %a4@(12),%a0
4efce: 2f0c movel %a4,%sp@-
4efd0: 2f2e 0010 movel %fp@(16),%sp@-
4efd4: 226e ffcc moveal %fp@(-52),%a1
4efd8: 4871 2800 pea %a1@(00000000,%d2:l)
4efdc: 9889 subl %a1,%d4
4efde: 2f04 movel %d4,%sp@-
4efe0: 2050 moveal %a0@,%a0
4efe2: 4e90 jsr %a0@
4efe4: 4fef 0028 lea %sp@(40),%sp
4efe8: 2400 movel %d0,%d2
4efea: 6000 00d0 braw 4f0bc <rtems_rfs_rtems_eval_path+0x2b8>
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
4efee: 2f07 movel %d7,%sp@-
4eff0: 2f06 movel %d6,%sp@-
4eff2: 4878 0002 pea 2 <DOUBLE_FLOAT>
4eff6: 4879 0006 a059 pea 6a059 <_rodata_start+0x1a9>
4effc: 2f0b movel %a3,%sp@-
4effe: 2f0a movel %a2,%sp@-
4f000: 4eb9 0005 6cda jsr 56cda <rtems_rfs_dir_lookup_ino>
if (rc > 0)
4f006: 4fef 0018 lea %sp@(24),%sp
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
4f00a: 2600 movel %d0,%d3
if (rc > 0)
4f00c: 6f44 bles 4f052 <rtems_rfs_rtems_eval_path+0x24e><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
4f00e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f010: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f012: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
4f018: 6052 bras 4f06c <rtems_rfs_rtems_eval_path+0x268><== NOT EXECUTED
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4f01a: 2f07 movel %d7,%sp@-
4f01c: 2f06 movel %d6,%sp@-
4f01e: 2f03 movel %d3,%sp@-
4f020: 2f0d movel %a5,%sp@-
4f022: 2f0b movel %a3,%sp@-
4f024: 2f0a movel %a2,%sp@-
4f026: 4eb9 0005 6cda jsr 56cda <rtems_rfs_dir_lookup_ino>
node, node_len - stripped, &ino, &doff);
if (rc > 0)
4f02c: 4fef 0018 lea %sp@(24),%sp
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4f030: 2600 movel %d0,%d3
node, node_len - stripped, &ino, &doff);
if (rc > 0)
4f032: 6f1e bles 4f052 <rtems_rfs_rtems_eval_path+0x24e>
{
rtems_rfs_inode_close (fs, &inode);
4f034: 2f0b movel %a3,%sp@-
4f036: 2f0a movel %a2,%sp@-
4f038: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4f03e: 2f0a movel %a2,%sp@-
4f040: 4eba f0b2 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
return ((errno = rc) == 0) ? 0 : -1;
4f044: 4eb9 0005 b6e4 jsr 5b6e4 <__errno>
4f04a: 2240 moveal %d0,%a1
4f04c: 2283 movel %d3,%a1@
4f04e: 6000 fe90 braw 4eee0 <rtems_rfs_rtems_eval_path+0xdc>
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
4f052: 2f0b movel %a3,%sp@-
4f054: 4bf9 0004 d966 lea 4d966 <rtems_rfs_inode_close>,%a5
4f05a: 2f0a movel %a2,%sp@-
4f05c: 4e95 jsr %a5@
if (rc > 0)
4f05e: 508f addql #8,%sp
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
4f060: 2600 movel %d0,%d3
if (rc > 0)
4f062: 6f00 fdf2 blew 4ee56 <rtems_rfs_rtems_eval_path+0x52>
{
rtems_rfs_inode_close (fs, &inode);
4f066: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f068: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f06a: 4e95 jsr %a5@ <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4f06c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f06e: 4eba f084 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
4f072: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4f078: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f07a: 2083 movel %d3,%a0@ <== NOT EXECUTED
4f07c: 6000 fe62 braw 4eee0 <rtems_rfs_rtems_eval_path+0xdc> <== NOT EXECUTED
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
4f080: 28ae fff8 movel %fp@(-8),%a4@
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
4f084: 260e movel %fp,%d3
4f086: 0683 ffff ffd2 addil #-46,%d3
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
4f08c: 296e fffc 0004 movel %fp@(-4),%a4@(4)
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
4f092: 2f03 movel %d3,%sp@-
4f094: 2f0c movel %a4,%sp@-
4f096: 4eb9 0004 f544 jsr 4f544 <rtems_rfs_rtems_set_handlers>
4f09c: 508f addql #8,%sp
4f09e: 4a00 tstb %d0
4f0a0: 6704 beqs 4f0a6 <rtems_rfs_rtems_eval_path+0x2a2><== NEVER TAKEN
4f0a2: 4282 clrl %d2
4f0a4: 6002 bras 4f0a8 <rtems_rfs_rtems_eval_path+0x2a4>
4f0a6: 7405 moveq #5,%d2 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4f0a8: 2f03 movel %d3,%sp@-
4f0aa: 2f0a movel %a2,%sp@-
4f0ac: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4f0b2: 2f0a movel %a2,%sp@-
4f0b4: 4eba f03e jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);
return rc;
4f0b8: 4fef 000c lea %sp@(12),%sp
}
4f0bc: 2002 movel %d2,%d0
4f0be: 4cee 3cfc ffa4 moveml %fp@(-92),%d2-%d7/%a2-%a5
4f0c4: 4e5e unlk %fp <== NOT EXECUTED
0004f498 <rtems_rfs_rtems_eval_perms>:
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
{
4f498: 4e56 ffe0 linkw %fp,#-32
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
4f49c: 206e 0008 moveal %fp@(8),%a0
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
{
4f4a0: 48d7 0cfc moveml %d2-%d7/%a2-%a3,%sp@
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
4f4a4: 2068 000c moveal %a0@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4f4a8: 4284 clrl %d4
4f4aa: 1828 0003 moveb %a0@(3),%d4
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4f4ae: 1028 0006 moveb %a0@(6),%d0
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
{
4f4b2: 242e 000c movel %fp@(12),%d2
4f4b6: 3440 moveaw %d0,%a2
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4f4b8: 4280 clrl %d0
4f4ba: 1028 0002 moveb %a0@(2),%d0
4f4be: e188 lsll #8,%d0
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
4f4c0: 1628 0005 moveb %a0@(5),%d3
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4f4c4: 1e28 0007 moveb %a0@(7),%d7
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
4f4c8: 1c28 0004 moveb %a0@(4),%d6
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4f4cc: 8880 orl %d0,%d4
uid = rtems_rfs_inode_get_uid (inode);
gid = rtems_rfs_inode_get_gid (inode);
mode = rtems_rfs_inode_get_mode (inode);
#if defined (RTEMS_POSIX_API)
st_uid = geteuid ();
4f4ce: 4eb9 0005 2bb8 jsr 52bb8 <geteuid>
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
4f4d4: 3643 moveaw %d3,%a3
4f4d6: 3600 movew %d0,%d3
st_gid = getegid ();
4f4d8: 4eb9 0005 2ba4 jsr 52ba4 <getegid>
/*
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
4f4de: 4a43 tstw %d3
4f4e0: 671c beqs 4f4fe <rtems_rfs_rtems_eval_perms+0x66><== ALWAYS TAKEN
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4f4e2: 4281 clrl %d1 <== NOT EXECUTED
4f4e4: 3a0a movew %a2,%d5 <== NOT EXECUTED
4f4e6: 0287 0000 00ff andil #255,%d7 <== NOT EXECUTED
4f4ec: 1205 moveb %d5,%d1 <== NOT EXECUTED
4f4ee: 2047 moveal %d7,%a0 <== NOT EXECUTED
4f4f0: 4287 clrl %d7 <== NOT EXECUTED
4f4f2: 2a08 movel %a0,%d5 <== NOT EXECUTED
4f4f4: e189 lsll #8,%d1 <== NOT EXECUTED
4f4f6: 3e03 movew %d3,%d7 <== NOT EXECUTED
4f4f8: 8285 orl %d5,%d1 <== NOT EXECUTED
4f4fa: b287 cmpl %d7,%d1 <== NOT EXECUTED
4f4fc: 660c bnes 4f50a <rtems_rfs_rtems_eval_perms+0x72><== NOT EXECUTED
flags_to_test |= flags << 6;
4f4fe: 2202 movel %d2,%d1
4f500: ed89 lsll #6,%d1
4f502: 8282 orl %d2,%d1
if ((st_uid == 0) || (st_gid == gid))
4f504: 4a43 tstw %d3
4f506: 6722 beqs 4f52a <rtems_rfs_rtems_eval_perms+0x92><== ALWAYS TAKEN
4f508: 6002 bras 4f50c <rtems_rfs_rtems_eval_perms+0x74><== NOT EXECUTED
#endif
/*
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
4f50a: 2202 movel %d2,%d1 <== NOT EXECUTED
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
4f50c: 7618 moveq #24,%d3 <== NOT EXECUTED
4f50e: 4285 clrl %d5 <== NOT EXECUTED
4f510: e7ae lsll %d3,%d6 <== NOT EXECUTED
4f512: 360b movew %a3,%d3 <== NOT EXECUTED
if ((st_uid == 0) || (st_uid == uid))
flags_to_test |= flags << 6;
if ((st_uid == 0) || (st_gid == gid))
4f514: 0280 0000 ffff andil #65535,%d0 <== NOT EXECUTED
4f51a: 1a03 moveb %d3,%d5 <== NOT EXECUTED
4f51c: 4845 swap %d5 <== NOT EXECUTED
4f51e: 4245 clrw %d5 <== NOT EXECUTED
4f520: 8c85 orl %d5,%d6 <== NOT EXECUTED
4f522: 4246 clrw %d6 <== NOT EXECUTED
4f524: 4846 swap %d6 <== NOT EXECUTED
4f526: bc80 cmpl %d0,%d6 <== NOT EXECUTED
4f528: 6604 bnes 4f52e <rtems_rfs_rtems_eval_perms+0x96><== NOT EXECUTED
flags_to_test |= flags << 3;
4f52a: e78a lsll #3,%d2
4f52c: 8282 orl %d2,%d1
/*
* If all of the flags are set we have permission
* to do this.
*/
if ((flags_to_test & (mode & 0777)) != 0)
4f52e: 0284 0000 01ff andil #511,%d4
4f534: c881 andl %d1,%d4
#include <stdlib.h>
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
4f536: 56c0 sne %d0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
4f538: 4cee 0cfc ffe0 moveml %fp@(-32),%d2-%d7/%a2-%a3
4f53e: 4e5e unlk %fp
4f540: 4480 negl %d0 <== NOT EXECUTED
0004f35a <rtems_rfs_rtems_fchmod>:
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
4f35a: 4e56 ffc4 linkw %fp,#-60 <== NOT EXECUTED
4f35e: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4f362: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
4f366: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4f36a: 2410 movel %a0@,%d2 <== NOT EXECUTED
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f36c: 47ee ffda lea %fp@(-38),%a3 <== NOT EXECUTED
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4f370: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
4f374: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
4f378: 4eba ef98 jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f37c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4f380: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f382: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4f384: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f386: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
4f38c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f390: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
4f392: 6714 beqs 4f3a8 <rtems_rfs_rtems_fchmod+0x4e> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4f394: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f396: 4eba ed5c jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
4f39a: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4f3a0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f3a2: 2082 movel %d2,%a0@ <== NOT EXECUTED
4f3a4: 6000 00a4 braw 4f44a <rtems_rfs_rtems_fchmod+0xf0> <== NOT EXECUTED
}
imode = rtems_rfs_inode_get_mode (&inode);
4f3a8: 206b 000c moveal %a3@(12),%a0 <== NOT EXECUTED
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4f3ac: 4284 clrl %d4 <== NOT EXECUTED
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
4f3ae: 4283 clrl %d3 <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4f3b0: 1428 0002 moveb %a0@(2),%d2 <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
4f3b4: 4eb9 0005 2bb8 jsr 52bb8 <geteuid> <== NOT EXECUTED
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
4f3ba: 206b 000c moveal %a3@(12),%a0 <== NOT EXECUTED
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4f3be: 4281 clrl %d1 <== NOT EXECUTED
4f3c0: 1228 0006 moveb %a0@(6),%d1 <== NOT EXECUTED
4f3c4: 1828 0007 moveb %a0@(7),%d4 <== NOT EXECUTED
4f3c8: e189 lsll #8,%d1 <== NOT EXECUTED
4f3ca: 3600 movew %d0,%d3 <== NOT EXECUTED
4f3cc: 8284 orl %d4,%d1 <== NOT EXECUTED
4f3ce: b283 cmpl %d3,%d1 <== NOT EXECUTED
4f3d0: 6728 beqs 4f3fa <rtems_rfs_rtems_fchmod+0xa0> <== NOT EXECUTED
4f3d2: 4a40 tstw %d0 <== NOT EXECUTED
4f3d4: 6724 beqs 4f3fa <rtems_rfs_rtems_fchmod+0xa0> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4f3d6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f3d8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f3da: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4f3e0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f3e2: 4eba ed10 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
4f3e6: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4f3ec: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4f3f0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f3f2: 7001 moveq #1,%d0 <== NOT EXECUTED
4f3f4: 2080 movel %d0,%a0@ <== NOT EXECUTED
4f3f6: 70ff moveq #-1,%d0 <== NOT EXECUTED
4f3f8: 605c bras 4f456 <rtems_rfs_rtems_fchmod+0xfc> <== NOT EXECUTED
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4f3fa: 202e 000c movel %fp@(12),%d0 <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4f3fe: e18a lsll #8,%d2 <== NOT EXECUTED
4f400: 0280 0000 0fff andil #4095,%d0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4f406: 0282 0000 f000 andil #61440,%d2 <== NOT EXECUTED
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4f40c: 8480 orl %d0,%d2 <== NOT EXECUTED
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
4f40e: 2002 movel %d2,%d0 <== NOT EXECUTED
4f410: e088 lsrl #8,%d0 <== NOT EXECUTED
4f412: 1140 0002 moveb %d0,%a0@(2) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4f416: 7001 moveq #1,%d0 <== NOT EXECUTED
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
4f418: 206e ffe6 moveal %fp@(-26),%a0 <== NOT EXECUTED
4f41c: 1142 0003 moveb %d2,%a0@(3) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4f420: 1d40 ffea moveb %d0,%fp@(-22) <== NOT EXECUTED
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
4f424: 486e ffda pea %fp@(-38) <== NOT EXECUTED
4f428: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f42a: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
4f430: 508f addql #8,%sp <== NOT EXECUTED
4f432: 41fa ecc0 lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
4f436: 2640 moveal %d0,%a3 <== NOT EXECUTED
if (rc > 0)
4f438: 4a80 tstl %d0 <== NOT EXECUTED
4f43a: 6f12 bles 4f44e <rtems_rfs_rtems_fchmod+0xf4> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4f43c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f43e: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
4f440: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4f446: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f448: 208b movel %a3,%a0@ <== NOT EXECUTED
4f44a: 588f addql #4,%sp <== NOT EXECUTED
4f44c: 60a8 bras 4f3f6 <rtems_rfs_rtems_fchmod+0x9c> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4f44e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f450: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
4f452: 588f addql #4,%sp <== NOT EXECUTED
4f454: 4280 clrl %d0 <== NOT EXECUTED
}
4f456: 4cee 0c1c ffc4 moveml %fp@(-60),%d2-%d4/%a2-%a3 <== NOT EXECUTED
4f45c: 4e5e unlk %fp <== NOT EXECUTED
0004f460 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
4f460: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4f464: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
4f468: 2068 0028 moveal %a0@(40),%a0 <== NOT EXECUTED
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
4f46c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4f46e: 2f28 0034 movel %a0@(52),%sp@- <== NOT EXECUTED
4f472: 4eb9 0005 6a3c jsr 56a3c <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
4f478: 588f addql #4,%sp <== NOT EXECUTED
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4f47a: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
4f47c: 670e beqs 4f48c <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
4f47e: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4f484: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f486: 70ff moveq #-1,%d0 <== NOT EXECUTED
4f488: 2082 movel %d2,%a0@ <== NOT EXECUTED
4f48a: 6002 bras 4f48e <rtems_rfs_rtems_fdatasync+0x2e> <== NOT EXECUTED
return 0;
4f48c: 4280 clrl %d0 <== NOT EXECUTED
}
4f48e: 242e fffc movel %fp@(-4),%d2 <== NOT EXECUTED
4f492: 4e5e unlk %fp <== NOT EXECUTED
...
0005a6ee <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
5a6ee: 4e56 fff4 linkw %fp,#-12
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
5a6f2: 206e 0008 moveal %fp@(8),%a0
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
5a6f6: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
5a6fa: 2668 001c moveal %a0@(28),%a3
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
5a6fe: 206b 001a moveal %a3@(26),%a0
5a702: 2468 0090 moveal %a0@(144),%a2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
5a706: 2f2a 007c movel %a2@(124),%sp@-
5a70a: 4eba fc60 jsr %pc@(5a36c <rtems_rfs_rtems_lock.isra.1>)
rc = rtems_rfs_file_close (fs, file);
5a70e: 2f0b movel %a3,%sp@-
5a710: 2f0a movel %a2,%sp@-
5a712: 4eb9 0005 7d54 jsr 57d54 <rtems_rfs_file_close>
if (rc > 0)
5a718: 4fef 000c lea %sp@(12),%sp
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
5a71c: 2400 movel %d0,%d2
if (rc > 0)
5a71e: 6f0c bles 5a72c <rtems_rfs_rtems_file_close+0x3e><== ALWAYS TAKEN
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
5a720: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a726: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a728: 2082 movel %d2,%a0@ <== NOT EXECUTED
5a72a: 74ff moveq #-1,%d2 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
5a72c: 2f0a movel %a2,%sp@-
5a72e: 4eba fbde jsr %pc@(5a30e <rtems_rfs_rtems_unlock>)
return rc;
}
5a732: 2002 movel %d2,%d0
5a734: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
5a73a: 4e5e unlk %fp <== NOT EXECUTED
0005a304 <rtems_rfs_rtems_file_ioctl>:
static int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
return 0;
}
5a304: 4280 clrl %d0 <== NOT EXECUTED
* @param buffer
*/
static int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
5a306: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return 0;
}
5a30a: 4e5e unlk %fp <== NOT EXECUTED
0005a434 <rtems_rfs_rtems_file_lseek>:
*/
static rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
5a434: 4e56 ffec linkw %fp,#-20
5a438: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
5a43c: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
5a440: 266a 001c moveal %a2@(28),%a3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
5a444: 206b 001a moveal %a3@(26),%a0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
5a448: 2068 0090 moveal %a0@(144),%a0
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
5a44c: 2f28 007c movel %a0@(124),%sp@-
5a450: 4eba ff1a jsr %pc@(5a36c <rtems_rfs_rtems_lock.isra.1>)
pos = iop->offset;
5a454: 202a 000c movel %a2@(12),%d0
5a458: 222a 0010 movel %a2@(16),%d1
5a45c: 204e moveal %fp,%a0
5a45e: 2101 movel %d1,%a0@-
5a460: 2100 movel %d0,%a0@-
rc = rtems_rfs_file_seek (file, pos, &pos);
5a462: 2f08 movel %a0,%sp@-
5a464: 2f01 movel %d1,%sp@-
5a466: 2f00 movel %d0,%sp@-
5a468: 2f0b movel %a3,%sp@-
5a46a: 4eb9 0005 837c jsr 5837c <rtems_rfs_file_seek>
5a470: 226b 001a moveal %a3@(26),%a1
5a474: 2400 movel %d0,%d2
if (rc)
5a476: 4fef 0014 lea %sp@(20),%sp
5a47a: 41fa fe92 lea %pc@(5a30e <rtems_rfs_rtems_unlock>),%a0
5a47e: 6718 beqs 5a498 <rtems_rfs_rtems_file_lseek+0x64><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
5a480: 2f29 0090 movel %a1@(144),%sp@- <== NOT EXECUTED
5a484: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
5a486: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a48c: 588f addql #4,%sp <== NOT EXECUTED
5a48e: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a490: 2082 movel %d2,%a0@ <== NOT EXECUTED
5a492: 70ff moveq #-1,%d0 <== NOT EXECUTED
5a494: 72ff moveq #-1,%d1 <== NOT EXECUTED
5a496: 6010 bras 5a4a8 <rtems_rfs_rtems_file_lseek+0x74><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
5a498: 2f29 0090 movel %a1@(144),%sp@-
5a49c: 4e90 jsr %a0@
return iop->offset;
5a49e: 588f addql #4,%sp
5a4a0: 202a 000c movel %a2@(12),%d0
5a4a4: 222a 0010 movel %a2@(16),%d1
}
5a4a8: 4cee 0c04 ffec moveml %fp@(-20),%d2/%a2-%a3
5a4ae: 4e5e unlk %fp <== NOT EXECUTED
0005a73e <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
5a73e: 4e56 fff0 linkw %fp,#-16
5a742: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
5a746: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
5a74a: 206b 0028 moveal %a3@(40),%a0
5a74e: 2468 0034 moveal %a0@(52),%a2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: path:%s ino:%" PRId32 " flags:%04" PRIx32 " mode:%04" PRIx32 "\n",
pathname, ino, flags, mode);
rtems_rfs_rtems_lock (fs);
5a752: 2f2a 007c movel %a2@(124),%sp@-
5a756: 4eba fc14 jsr %pc@(5a36c <rtems_rfs_rtems_lock.isra.1>)
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
5a75a: 486e fffc pea %fp@(-4)
5a75e: 42a7 clrl %sp@-
5a760: 2f2b 0018 movel %a3@(24),%sp@-
5a764: 2f0a movel %a2,%sp@-
5a766: 4eb9 0005 8702 jsr 58702 <rtems_rfs_file_open>
if (rc > 0)
5a76c: 4fef 0014 lea %sp@(20),%sp
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
5a770: 2400 movel %d0,%d2
if (rc > 0)
5a772: 6f16 bles 5a78a <rtems_rfs_rtems_file_open+0x4c> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
5a774: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5a776: 4eba fb96 jsr %pc@(5a30e <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
5a77a: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a780: 588f addql #4,%sp <== NOT EXECUTED
5a782: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a784: 70ff moveq #-1,%d0 <== NOT EXECUTED
5a786: 2082 movel %d2,%a0@ <== NOT EXECUTED
5a788: 6030 bras 5a7ba <rtems_rfs_rtems_file_open+0x7c> <== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
5a78a: 206e fffc moveal %fp@(-4),%a0
5a78e: 2068 001a moveal %a0@(26),%a0
5a792: 4868 007c pea %a0@(124)
5a796: 2f28 0090 movel %a0@(144),%sp@-
5a79a: 4eb9 0005 5988 jsr 55988 <rtems_rfs_block_get_size>
rtems_rfs_rtems_set_iop_file_handle (iop, file);
5a7a0: 276e fffc 001c movel %fp@(-4),%a3@(28)
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
5a7a6: 2740 0004 movel %d0,%a3@(4)
5a7aa: 2741 0008 movel %d1,%a3@(8)
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
5a7ae: 2f0a movel %a2,%sp@-
5a7b0: 4eba fb5c jsr %pc@(5a30e <rtems_rfs_rtems_unlock>)
return 0;
5a7b4: 4fef 000c lea %sp@(12),%sp
5a7b8: 4280 clrl %d0
}
5a7ba: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
5a7c0: 4e5e unlk %fp <== NOT EXECUTED
0005a608 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
5a608: 4e56 ffd8 linkw %fp,#-40
5a60c: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
5a610: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
5a614: 246b 001c moveal %a3@(28),%a2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
5a618: 206a 001a moveal %a2@(26),%a0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
5a61c: 2068 0090 moveal %a0@(144),%a0
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
5a620: 2f28 007c movel %a0@(124),%sp@-
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
5a624: 282e 0010 movel %fp@(16),%d4
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
5a628: 4eba fd42 jsr %pc@(5a36c <rtems_rfs_rtems_lock.isra.1>)
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
5a62c: 206a 001a moveal %a2@(26),%a0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
5a630: 242b 000c movel %a3@(12),%d2
5a634: 262b 0010 movel %a3@(16),%d3
5a638: 4868 007c pea %a0@(124)
5a63c: 2f28 0090 movel %a0@(144),%sp@-
if (pos < rtems_rfs_file_size (file))
5a640: 2a02 movel %d2,%d5
5a642: 2c03 movel %d3,%d6
5a644: 4eb9 0005 5988 jsr 55988 <rtems_rfs_block_get_size>
5a64a: 4fef 000c lea %sp@(12),%sp
5a64e: 9c81 subl %d1,%d6
5a650: 9b80 subxl %d0,%d5
5a652: 6562 bcss 5a6b6 <rtems_rfs_rtems_file_read+0xae> <== ALWAYS TAKEN
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
uint8_t* data = buffer;
ssize_t read = 0;
5a654: 4282 clrl %d2 <== NOT EXECUTED
5a656: 607e bras 5a6d6 <rtems_rfs_rtems_file_read+0xce> <== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
5a658: 4878 0001 pea 1 <ADD>
5a65c: 2f06 movel %d6,%sp@-
5a65e: 2f0a movel %a2,%sp@-
5a660: 4e95 jsr %a5@
if (rc > 0)
5a662: 4fef 000c lea %sp@(12),%sp
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
5a666: 2600 movel %d0,%d3
if (rc > 0)
5a668: 6e3e bgts 5a6a8 <rtems_rfs_rtems_file_read+0xa0> <== NEVER TAKEN
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
5a66a: 202e fffc movel %fp@(-4),%d0
5a66e: 6766 beqs 5a6d6 <rtems_rfs_rtems_file_read+0xce> <== NEVER TAKEN
break;
if (size > count)
5a670: b880 cmpl %d0,%d4
5a672: 6404 bccs 5a678 <rtems_rfs_rtems_file_read+0x70> <== ALWAYS TAKEN
size = count;
5a674: 2d44 fffc movel %d4,%fp@(-4) <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
5a678: 262e fffc movel %fp@(-4),%d3
data += size;
count -= size;
5a67c: 9883 subl %d3,%d4
read += size;
5a67e: d483 addl %d3,%d2
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
5a680: 206a 000a moveal %a2@(10),%a0
5a684: 2f03 movel %d3,%sp@-
5a686: 2068 001e moveal %a0@(30),%a0
5a68a: d1ea 0012 addal %a2@(18),%a0
5a68e: 2f08 movel %a0,%sp@-
5a690: 2f05 movel %d5,%sp@-
data += size;
5a692: da83 addl %d3,%d5
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
5a694: 4e94 jsr %a4@
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
5a696: 4878 0001 pea 1 <ADD>
5a69a: 2f03 movel %d3,%sp@-
5a69c: 2f0a movel %a2,%sp@-
5a69e: 4e93 jsr %a3@
if (rc > 0)
5a6a0: 4fef 0018 lea %sp@(24),%sp
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
5a6a4: 2600 movel %d0,%d3
if (rc > 0)
5a6a6: 6f2a bles 5a6d2 <rtems_rfs_rtems_file_read+0xca> <== ALWAYS TAKEN
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
5a6a8: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a6ae: 74ff moveq #-1,%d2 <== NOT EXECUTED
5a6b0: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a6b2: 2083 movel %d3,%a0@ <== NOT EXECUTED
5a6b4: 6020 bras 5a6d6 <rtems_rfs_rtems_file_read+0xce> <== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
5a6b6: 2c0e movel %fp,%d6
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
5a6b8: 4282 clrl %d2
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
5a6ba: 5986 subql #4,%d6
5a6bc: 4bf9 0005 7fc2 lea 57fc2 <rtems_rfs_file_io_start>,%a5
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
5a6c2: 49f9 0005 bf8c lea 5bf8c <memcpy>,%a4
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
5a6c8: 47f9 0005 8188 lea 58188 <rtems_rfs_file_io_end>,%a3
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
5a6ce: 2a2e 000c movel %fp@(12),%d5
{
while (count)
5a6d2: 4a84 tstl %d4
5a6d4: 6682 bnes 5a658 <rtems_rfs_rtems_file_read+0x50>
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
5a6d6: 206a 001a moveal %a2@(26),%a0
5a6da: 2f28 0090 movel %a0@(144),%sp@-
5a6de: 4eba fc2e jsr %pc@(5a30e <rtems_rfs_rtems_unlock>)
return read;
}
5a6e2: 2002 movel %d2,%d0
5a6e4: 4cee 3c7c ffd8 moveml %fp@(-40),%d2-%d6/%a2-%a5
5a6ea: 4e5e unlk %fp <== NOT EXECUTED
0005a4b2 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
5a4b2: 4e56 ffd4 linkw %fp,#-44
5a4b6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
5a4ba: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
5a4be: 246b 001c moveal %a3@(28),%a2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
5a4c2: 206a 001a moveal %a2@(26),%a0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
5a4c6: 2068 0090 moveal %a0@(144),%a0
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
5a4ca: 2f28 007c movel %a0@(124),%sp@-
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
5a4ce: 282e 0010 movel %fp@(16),%d4
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
5a4d2: 4eba fe98 jsr %pc@(5a36c <rtems_rfs_rtems_lock.isra.1>)
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
5a4d6: 206a 001a moveal %a2@(26),%a0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
5a4da: 242b 000c movel %a3@(12),%d2
5a4de: 262b 0010 movel %a3@(16),%d3
5a4e2: 4868 007c pea %a0@(124)
5a4e6: 2f28 0090 movel %a0@(144),%sp@-
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
5a4ea: 2a02 movel %d2,%d5
5a4ec: 2c03 movel %d3,%d6
5a4ee: 4eb9 0005 5988 jsr 55988 <rtems_rfs_block_get_size>
5a4f4: 4fef 000c lea %sp@(12),%sp
5a4f8: 9c81 subl %d1,%d6
5a4fa: 9b80 subxl %d0,%d5
5a4fc: 653a bcss 5a538 <rtems_rfs_rtems_file_write+0x86>
{
rc = rtems_rfs_file_set_size (file, pos + 1);
5a4fe: 4280 clrl %d0
5a500: 7201 moveq #1,%d1
5a502: d283 addl %d3,%d1
5a504: d182 addxl %d2,%d0
5a506: 2f01 movel %d1,%sp@-
5a508: 2f00 movel %d0,%sp@-
5a50a: 2f0a movel %a2,%sp@-
5a50c: 4eb9 0005 8404 jsr 58404 <rtems_rfs_file_set_size>
if (rc)
5a512: 4fef 000c lea %sp@(12),%sp
* more.
*/
if (pos >= rtems_rfs_file_size (file))
{
rc = rtems_rfs_file_set_size (file, pos + 1);
5a516: 2a00 movel %d0,%d5
if (rc)
5a518: 671e beqs 5a538 <rtems_rfs_rtems_file_write+0x86><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
5a51a: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
5a51e: 74ff moveq #-1,%d2 <== NOT EXECUTED
if (pos >= rtems_rfs_file_size (file))
{
rc = rtems_rfs_file_set_size (file, pos + 1);
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
5a520: 2f28 0090 movel %a0@(144),%sp@- <== NOT EXECUTED
5a524: 4eba fde8 jsr %pc@(5a30e <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
5a528: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a52e: 588f addql #4,%sp <== NOT EXECUTED
5a530: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a532: 2085 movel %d5,%a0@ <== NOT EXECUTED
5a534: 6000 00c6 braw 5a5fc <rtems_rfs_rtems_file_write+0x14a><== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
5a538: 486a 000e pea %a2@(14)
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
5a53c: 2e0e movel %fp,%d7
5a53e: 5987 subql #4,%d7
5a540: 2c3c 0005 7fc2 movel #360386,%d6
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
5a546: 4bf9 0005 bf8c lea 5bf8c <memcpy>,%a5
data += size;
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
5a54c: 49f9 0005 8188 lea 58188 <rtems_rfs_file_io_end>,%a4
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
5a552: 2f03 movel %d3,%sp@-
5a554: 2f02 movel %d2,%sp@-
5a556: 206a 001a moveal %a2@(26),%a0
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
const uint8_t* data = buffer;
ssize_t write = 0;
5a55a: 4282 clrl %d2
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
5a55c: 2f28 0090 movel %a0@(144),%sp@-
5a560: 4eb9 0005 58b6 jsr 558b6 <rtems_rfs_block_get_bpos>
const void* buffer,
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
const uint8_t* data = buffer;
5a566: 262e 000c movel %fp@(12),%d3
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
5a56a: 4fef 0010 lea %sp@(16),%sp
5a56e: 605e bras 5a5ce <rtems_rfs_rtems_file_write+0x11c>
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
5a570: 42a7 clrl %sp@-
5a572: 2046 moveal %d6,%a0
5a574: 2f07 movel %d7,%sp@-
rtems_rfs_file_set_bpos (file, pos);
while (count)
{
size_t size = count;
5a576: 2d44 fffc movel %d4,%fp@(-4)
rc = rtems_rfs_file_io_start (file, &size, false);
5a57a: 2f0a movel %a2,%sp@-
5a57c: 4e90 jsr %a0@
if (rc)
5a57e: 4fef 000c lea %sp@(12),%sp
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
5a582: 2a00 movel %d0,%d5
if (rc)
5a584: 663a bnes 5a5c0 <rtems_rfs_rtems_file_write+0x10e><== NEVER TAKEN
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
5a586: b8ae fffc cmpl %fp@(-4),%d4
5a58a: 6404 bccs 5a590 <rtems_rfs_rtems_file_write+0xde><== NEVER TAKEN
size = count;
5a58c: 2d44 fffc movel %d4,%fp@(-4)
memcpy (rtems_rfs_file_data (file), data, size);
5a590: 206a 000a moveal %a2@(10),%a0
5a594: 2f2e fffc movel %fp@(-4),%sp@-
5a598: 2f03 movel %d3,%sp@-
5a59a: 2068 001e moveal %a0@(30),%a0
5a59e: d1ea 0012 addal %a2@(18),%a0
5a5a2: 2f08 movel %a0,%sp@-
5a5a4: 4e95 jsr %a5@
data += size;
5a5a6: 202e fffc movel %fp@(-4),%d0
5a5aa: d680 addl %d0,%d3
count -= size;
5a5ac: 9880 subl %d0,%d4
write += size;
5a5ae: d480 addl %d0,%d2
rc = rtems_rfs_file_io_end (file, size, false);
5a5b0: 42a7 clrl %sp@-
5a5b2: 2f00 movel %d0,%sp@-
5a5b4: 2f0a movel %a2,%sp@-
5a5b6: 4e94 jsr %a4@
if (rc)
5a5b8: 4fef 0018 lea %sp@(24),%sp
data += size;
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
5a5bc: 2a00 movel %d0,%d5
if (rc)
5a5be: 670e beqs 5a5ce <rtems_rfs_rtems_file_write+0x11c><== ALWAYS TAKEN
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
5a5c0: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
5a5c6: 74ff moveq #-1,%d2 <== NOT EXECUTED
5a5c8: 2040 moveal %d0,%a0 <== NOT EXECUTED
5a5ca: 2085 movel %d5,%a0@ <== NOT EXECUTED
5a5cc: 6004 bras 5a5d2 <rtems_rfs_rtems_file_write+0x120><== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
5a5ce: 4a84 tstl %d4
5a5d0: 669e bnes 5a570 <rtems_rfs_rtems_file_write+0xbe>
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
5a5d2: 206a 001a moveal %a2@(26),%a0
5a5d6: 4868 007c pea %a0@(124)
5a5da: 2f28 0090 movel %a0@(144),%sp@-
5a5de: 4eb9 0005 5988 jsr 55988 <rtems_rfs_block_get_size>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
5a5e4: 206a 001a moveal %a2@(26),%a0
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
5a5e8: 2740 0004 movel %d0,%a3@(4)
5a5ec: 2741 0008 movel %d1,%a3@(8)
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
5a5f0: 2f28 0090 movel %a0@(144),%sp@-
5a5f4: 4eba fd18 jsr %pc@(5a30e <rtems_rfs_rtems_unlock>)
return write;
5a5f8: 4fef 000c lea %sp@(12),%sp
}
5a5fc: 2002 movel %d2,%d0
5a5fe: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
5a604: 4e5e unlk %fp <== NOT EXECUTED
0004f0c8 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
4f0c8: 4e56 ffc0 linkw %fp,#-64
4f0cc: 206e 0008 moveal %fp@(8),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4f0d0: 2268 0010 moveal %a0@(16),%a1
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
4f0d4: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4f0d8: 2410 movel %a0@,%d2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f0da: 49ee ffda lea %fp@(-38),%a4
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4f0de: 2669 0034 moveal %a1@(52),%a3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
4f0e2: 2f2b 007c movel %a3@(124),%sp@-
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
4f0e6: 246e 000c moveal %fp@(12),%a2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
4f0ea: 4eba f226 jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f0ee: 4878 0001 pea 1 <ADD>
4f0f2: 2f0c movel %a4,%sp@-
4f0f4: 2f02 movel %d2,%sp@-
4f0f6: 2f0b movel %a3,%sp@-
4f0f8: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc)
4f0fe: 4fef 0014 lea %sp@(20),%sp
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f102: 2400 movel %d0,%d2
if (rc)
4f104: 670a beqs 4f110 <rtems_rfs_rtems_fstat+0x48> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4f106: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f108: 4eba efea jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
4f10c: 6000 022a braw 4f338 <rtems_rfs_rtems_fstat+0x270> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
}
mode = rtems_rfs_inode_get_mode (&inode);
4f110: 286c 000c moveal %a4@(12),%a4
4f114: 4282 clrl %d2
4f116: 142c 0002 moveb %a4@(2),%d2
4f11a: 4280 clrl %d0
4f11c: 102c 0003 moveb %a4@(3),%d0
4f120: e18a lsll #8,%d2
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
4f122: 8480 orl %d0,%d2
4f124: 2002 movel %d2,%d0
4f126: 0280 0000 f000 andil #61440,%d0
4f12c: 0c80 0000 2000 cmpil #8192,%d0
4f132: 6708 beqs 4f13c <rtems_rfs_rtems_fstat+0x74> <== NEVER TAKEN
4f134: 0c80 0000 6000 cmpil #24576,%d0
4f13a: 6620 bnes 4f15c <rtems_rfs_rtems_fstat+0x94> <== ALWAYS TAKEN
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
4f13c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4f140: 4bfa f05e lea %pc@(4e1a0 <rtems_rfs_inode_get_block.isra.9>),%a5<== NOT EXECUTED
4f144: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4f146: 4e95 jsr %a5@ <== NOT EXECUTED
4f148: 508f addql #8,%sp <== NOT EXECUTED
4f14a: 2600 movel %d0,%d3 <== NOT EXECUTED
4f14c: 42a7 clrl %sp@- <== NOT EXECUTED
4f14e: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4f150: 4e95 jsr %a5@ <== NOT EXECUTED
4f152: 508f addql #8,%sp <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
4f154: 2540 0016 movel %d0,%a2@(22) <== NOT EXECUTED
4f158: 2543 001a movel %d3,%a2@(26) <== NOT EXECUTED
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
4f15c: 206b 000c moveal %a3@(12),%a0
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
4f160: 49ee ffda lea %fp@(-38),%a4
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
4f164: 2010 movel %a0@,%d0
4f166: 2228 0004 movel %a0@(4),%d1
buf->st_ino = rtems_rfs_inode_ino (&inode);
4f16a: 256e ffe2 0008 movel %fp@(-30),%a2@(8)
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
4f170: 2480 movel %d0,%a2@
4f172: 2541 0004 movel %d1,%a2@(4)
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
4f176: 2f02 movel %d2,%sp@-
4f178: 4eb9 0004 f5e0 jsr 4f5e0 <rtems_rfs_rtems_mode>
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
4f17e: 206c 000c moveal %a4@(12),%a0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
4f182: 4281 clrl %d1
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
4f184: 2540 000c movel %d0,%a2@(12)
4f188: 4280 clrl %d0
4f18a: 1010 moveb %a0@,%d0
4f18c: 1228 0001 moveb %a0@(1),%d1
4f190: e188 lsll #8,%d0
4f192: 8081 orl %d1,%d0
if (links == 0xffff)
4f194: 3200 movew %d0,%d1
links = 0;
4f196: 0c81 0000 ffff cmpil #65535,%d1
4f19c: 56c1 sne %d1
4f19e: 4881 extw %d1
4f1a0: c081 andl %d1,%d0
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4f1a2: 4281 clrl %d1
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
4f1a4: 3540 0010 movew %d0,%a2@(16)
4f1a8: 4280 clrl %d0
4f1aa: 1028 0006 moveb %a0@(6),%d0
4f1ae: 1228 0007 moveb %a0@(7),%d1
4f1b2: e188 lsll #8,%d0
4f1b4: 8081 orl %d1,%d0
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
4f1b6: 7218 moveq #24,%d1
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
4f1b8: 3540 0012 movew %d0,%a2@(18)
4f1bc: 4280 clrl %d0
4f1be: 1028 0004 moveb %a0@(4),%d0
4f1c2: e3a8 lsll %d1,%d0
4f1c4: 4281 clrl %d1
4f1c6: 1228 0005 moveb %a0@(5),%d1
4f1ca: 4841 swap %d1
4f1cc: 4241 clrw %d1
4f1ce: 8081 orl %d1,%d0
4f1d0: 4240 clrw %d0
4f1d2: 4840 swap %d0
4f1d4: 3540 0014 movew %d0,%a2@(20)
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
4f1d8: 2eae ffe2 movel %fp@(-30),%sp@
4f1dc: 2f0b movel %a3,%sp@-
4f1de: 4eb9 0005 86d6 jsr 586d6 <rtems_rfs_file_get_shared>
4f1e4: 242a 000c movel %a2@(12),%d2
4f1e8: 2040 moveal %d0,%a0
if (shared)
4f1ea: 508f addql #8,%sp
4f1ec: 0282 0000 f000 andil #61440,%d2
4f1f2: 4a80 tstl %d0
4f1f4: 673a beqs 4f230 <rtems_rfs_rtems_fstat+0x168> <== ALWAYS TAKEN
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
4f1f6: 2568 0084 0026 movel %a0@(132),%a2@(38) <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
4f1fc: 2568 0088 002e movel %a0@(136),%a2@(46) <== NOT EXECUTED
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
4f202: 2568 008c 0036 movel %a0@(140),%a2@(54) <== NOT EXECUTED
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
4f208: 2568 007c 0042 movel %a0@(124),%a2@(66) <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
4f20e: 0c82 0000 a000 cmpil #40960,%d2 <== NOT EXECUTED
4f214: 660a bnes 4f220 <rtems_rfs_rtems_fstat+0x158> <== NOT EXECUTED
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
4f216: 4280 clrl %d0 <== NOT EXECUTED
4f218: 3028 0082 movew %a0@(130),%d0 <== NOT EXECUTED
4f21c: 6000 00dc braw 4f2fa <rtems_rfs_rtems_fstat+0x232> <== NOT EXECUTED
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
4f220: 4868 007c pea %a0@(124) <== NOT EXECUTED
4f224: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f226: 4eb9 0005 5988 jsr 55988 <rtems_rfs_block_get_size> <== NOT EXECUTED
4f22c: 6000 00e0 braw 4f30e <rtems_rfs_rtems_fstat+0x246> <== NOT EXECUTED
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
4f230: 206c 000c moveal %a4@(12),%a0
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
4f234: 4280 clrl %d0
4f236: 1028 0010 moveb %a0@(16),%d0
4f23a: 7218 moveq #24,%d1
4f23c: e3a8 lsll %d1,%d0
4f23e: 4281 clrl %d1
4f240: 1228 0011 moveb %a0@(17),%d1
4f244: 4841 swap %d1
4f246: 4241 clrw %d1
4f248: 8081 orl %d1,%d0
4f24a: 4281 clrl %d1
4f24c: 1228 0013 moveb %a0@(19),%d1
4f250: 8081 orl %d1,%d0
4f252: 1228 0012 moveb %a0@(18),%d1
4f256: e189 lsll #8,%d1
4f258: 8081 orl %d1,%d0
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
4f25a: 7218 moveq #24,%d1
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
4f25c: 2540 0026 movel %d0,%a2@(38)
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
4f260: 4280 clrl %d0
4f262: 1028 0014 moveb %a0@(20),%d0
4f266: e3a8 lsll %d1,%d0
4f268: 4281 clrl %d1
4f26a: 1228 0015 moveb %a0@(21),%d1
4f26e: 4841 swap %d1
4f270: 4241 clrw %d1
4f272: 8081 orl %d1,%d0
4f274: 4281 clrl %d1
4f276: 1228 0017 moveb %a0@(23),%d1
4f27a: 8081 orl %d1,%d0
4f27c: 1228 0016 moveb %a0@(22),%d1
4f280: e189 lsll #8,%d1
4f282: 8081 orl %d1,%d0
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
4f284: 7218 moveq #24,%d1
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
4f286: 2540 002e movel %d0,%a2@(46)
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
4f28a: 4280 clrl %d0
4f28c: 1028 0018 moveb %a0@(24),%d0
4f290: e3a8 lsll %d1,%d0
4f292: 4281 clrl %d1
4f294: 1228 0019 moveb %a0@(25),%d1
4f298: 4841 swap %d1
4f29a: 4241 clrw %d1
4f29c: 8081 orl %d1,%d0
4f29e: 4281 clrl %d1
4f2a0: 1228 001b moveb %a0@(27),%d1
4f2a4: 8081 orl %d1,%d0
4f2a6: 1228 001a moveb %a0@(26),%d1
4f2aa: e189 lsll #8,%d1
4f2ac: 8081 orl %d1,%d0
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
4f2ae: 7218 moveq #24,%d1
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
4f2b0: 2540 0036 movel %d0,%a2@(54)
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
4f2b4: 4280 clrl %d0
4f2b6: 1028 000c moveb %a0@(12),%d0
4f2ba: e3a8 lsll %d1,%d0
4f2bc: 4281 clrl %d1
4f2be: 1228 000d moveb %a0@(13),%d1
4f2c2: 4841 swap %d1
4f2c4: 4241 clrw %d1
4f2c6: 8081 orl %d1,%d0
4f2c8: 4281 clrl %d1
4f2ca: 1228 000f moveb %a0@(15),%d1
4f2ce: 8081 orl %d1,%d0
4f2d0: 1228 000e moveb %a0@(14),%d1
4f2d4: e189 lsll #8,%d1
4f2d6: 8081 orl %d1,%d0
4f2d8: 2540 0042 movel %d0,%a2@(66)
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
4f2dc: 0c82 0000 a000 cmpil #40960,%d2
4f2e2: 6620 bnes 4f304 <rtems_rfs_rtems_fstat+0x23c>
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
4f2e4: 4280 clrl %d0
4f2e6: 1028 000a moveb %a0@(10),%d0
4f2ea: 4281 clrl %d1
4f2ec: 1228 000b moveb %a0@(11),%d1
4f2f0: e188 lsll #8,%d0
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
4f2f2: 8081 orl %d1,%d0
4f2f4: 0280 0000 ffff andil #65535,%d0
4f2fa: 42aa 001e clrl %a2@(30)
4f2fe: 2540 0022 movel %d0,%a2@(34)
4f302: 6014 bras 4f318 <rtems_rfs_rtems_fstat+0x250>
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
4f304: 2f0c movel %a4,%sp@-
4f306: 2f0b movel %a3,%sp@-
4f308: 4eb9 0004 dfb4 jsr 4dfb4 <rtems_rfs_inode_get_size>
4f30e: 508f addql #8,%sp
4f310: 2540 001e movel %d0,%a2@(30)
4f314: 2541 0022 movel %d1,%a2@(34)
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
4f318: 256b 0008 003e movel %a3@(8),%a2@(62)
rc = rtems_rfs_inode_close (fs, &inode);
4f31e: 486e ffda pea %fp@(-38)
4f322: 2f0b movel %a3,%sp@-
4f324: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
if (rc > 0)
4f32a: 508f addql #8,%sp
4f32c: 41fa edc6 lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
rc = rtems_rfs_inode_close (fs, &inode);
4f330: 2400 movel %d0,%d2
if (rc > 0)
4f332: 6f14 bles 4f348 <rtems_rfs_rtems_fstat+0x280> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4f334: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f336: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: closing inode", rc);
4f338: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4f33e: 588f addql #4,%sp <== NOT EXECUTED
4f340: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f342: 70ff moveq #-1,%d0 <== NOT EXECUTED
4f344: 2082 movel %d2,%a0@ <== NOT EXECUTED
4f346: 6008 bras 4f350 <rtems_rfs_rtems_fstat+0x288> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4f348: 2f0b movel %a3,%sp@-
4f34a: 4e90 jsr %a0@
return 0;
4f34c: 588f addql #4,%sp
4f34e: 4280 clrl %d0
}
4f350: 4cee 3c0c ffc0 moveml %fp@(-64),%d2-%d3/%a2-%a5
4f356: 4e5e unlk %fp <== NOT EXECUTED
0004e244 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
4e244: 4e56 fff0 linkw %fp,#-16
4e248: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
4e24c: 4878 0004 pea 4 <CONTEXT_ARG>
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
4e250: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
4e254: 4eb9 0004 5af0 jsr 45af0 <malloc>
if (!rtems)
4e25a: 588f addql #4,%sp
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
4e25c: 2440 moveal %d0,%a2
if (!rtems)
4e25e: 4a80 tstl %d0
4e260: 660e bnes 4e270 <rtems_rfs_rtems_initialise+0x2c><== ALWAYS TAKEN
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
4e262: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e268: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e26a: 700c moveq #12,%d0 <== NOT EXECUTED
4e26c: 2080 movel %d0,%a0@ <== NOT EXECUTED
4e26e: 6024 bras 4e294 <rtems_rfs_rtems_initialise+0x50><== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
4e270: 2f00 movel %d0,%sp@-
rtems = malloc (sizeof (rtems_rfs_rtems_private));
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
4e272: 4292 clrl %a2@
rc = rtems_rfs_mutex_create (&rtems->access);
4e274: 4eb9 0005 9c08 jsr 59c08 <rtems_rfs_mutex_create>
if (rc > 0)
4e27a: 588f addql #4,%sp
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
4e27c: 2400 movel %d0,%d2
if (rc > 0)
4e27e: 6f18 bles 4e298 <rtems_rfs_rtems_initialise+0x54><== ALWAYS TAKEN
{
free (rtems);
4e280: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e282: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
4e288: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e28e: 588f addql #4,%sp <== NOT EXECUTED
4e290: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e292: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e294: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e296: 6070 bras 4e308 <rtems_rfs_rtems_initialise+0xc4><== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
4e298: 2f12 movel %a2@,%sp@-
4e29a: 4eba ff50 jsr %pc@(4e1ec <rtems_rfs_mutex_lock.isra.15>)
if (rc > 0)
4e29e: 588f addql #4,%sp
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
4e2a0: 2400 movel %d0,%d2
if (rc > 0)
4e2a2: 6f1e bles 4e2c2 <rtems_rfs_rtems_initialise+0x7e><== ALWAYS TAKEN
{
rtems_rfs_mutex_destroy (&rtems->access);
4e2a4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e2a6: 4eb9 0005 9c6c jsr 59c6c <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
4e2ac: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e2ae: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
4e2b4: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e2ba: 508f addql #8,%sp <== NOT EXECUTED
4e2bc: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e2be: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e2c0: 60d2 bras 4e294 <rtems_rfs_rtems_initialise+0x50><== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, 0, &fs);
4e2c2: 486e fffc pea %fp@(-4)
4e2c6: 42a7 clrl %sp@-
4e2c8: 2f0a movel %a2,%sp@-
4e2ca: 2f2b 0070 movel %a3@(112),%sp@-
4e2ce: 4eb9 0005 8a74 jsr 58a74 <rtems_rfs_fs_open>
if (rc)
4e2d4: 4fef 0010 lea %sp@(16),%sp
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, 0, &fs);
4e2d8: 2400 movel %d0,%d2
if (rc)
4e2da: 66a4 bnes 4e280 <rtems_rfs_rtems_initialise+0x3c><== NEVER TAKEN
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
4e2dc: 7201 moveq #1,%d1
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
4e2de: 41f9 0006 dbb2 lea 6dbb2 <rtems_rfs_rtems_dir_handlers>,%a0
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
4e2e4: 202e fffc movel %fp@(-4),%d0
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
4e2e8: 2741 001c movel %d1,%a3@(28)
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
4e2ec: 223c 0006 c030 movel #442416,%d1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
4e2f2: 2740 0034 movel %d0,%a3@(52)
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
4e2f6: 2748 0024 movel %a0,%a3@(36)
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
4e2fa: 2741 0028 movel %d1,%a3@(40)
rtems_rfs_rtems_unlock (fs);
4e2fe: 2f00 movel %d0,%sp@-
4e300: 4eba fdf2 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
return 0;
4e304: 588f addql #4,%sp
4e306: 4280 clrl %d0
}
4e308: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4e30e: 4e5e unlk %fp <== NOT EXECUTED
0004e43a <rtems_rfs_rtems_link>:
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
4e43a: 4e56 fff0 linkw %fp,#-16
4e43e: 206e 0008 moveal %fp@(8),%a0
4e442: 48d7 041c moveml %d2-%d4/%a2,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
4e446: 2268 0010 moveal %a0@(16),%a1
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
4e44a: 2810 movel %a0@,%d4
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
4e44c: 206e 000c moveal %fp@(12),%a0
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
4e450: 2469 0034 moveal %a1@(52),%a2
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
4e454: 2610 movel %a0@,%d3
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
4e456: 2f2a 007c movel %a2@(124),%sp@-
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
4e45a: 242e 0010 movel %fp@(16),%d2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
4e45e: 4eba feb2 jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
4e462: 2f02 movel %d2,%sp@-
4e464: 4eb9 0005 cdac jsr 5cdac <strlen>
4e46a: 4297 clrl %sp@
4e46c: 2f04 movel %d4,%sp@-
4e46e: 2f03 movel %d3,%sp@-
4e470: 2f00 movel %d0,%sp@-
4e472: 2f02 movel %d2,%sp@-
4e474: 2f0a movel %a2,%sp@-
4e476: 4eb9 0005 9294 jsr 59294 <rtems_rfs_link>
if (rc)
4e47c: 4fef 001c lea %sp@(28),%sp
4e480: 41fa fc72 lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
4e484: 2400 movel %d0,%d2
if (rc)
4e486: 6714 beqs 4e49c <rtems_rfs_rtems_link+0x62> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e488: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e48a: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("link: linking", rc);
4e48c: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e492: 588f addql #4,%sp <== NOT EXECUTED
4e494: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e496: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e498: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e49a: 6008 bras 4e4a4 <rtems_rfs_rtems_link+0x6a> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e49c: 2f0a movel %a2,%sp@-
4e49e: 4e90 jsr %a0@
return 0;
4e4a0: 588f addql #4,%sp
4e4a2: 4280 clrl %d0
}
4e4a4: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4e4aa: 4e5e unlk %fp <== NOT EXECUTED
0005a36c <rtems_rfs_rtems_lock.isra.1>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
5a36c: 4e56 0000 linkw %fp,#0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
5a370: 206e 0008 moveal %fp@(8),%a0
5a374: 2f02 movel %d2,%sp@-
5a376: 42a7 clrl %sp@-
5a378: 42a7 clrl %sp@-
5a37a: 2f10 movel %a0@,%sp@-
5a37c: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
5a382: 4fef 000c lea %sp@(12),%sp
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
5a386: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
5a388: 672c beqs 5a3b6 <rtems_rfs_rtems_lock.isra.1+0x4a><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
5a38a: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
5a38e: 42a7 clrl %sp@- <== NOT EXECUTED
5a390: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5a396: 508f addql #8,%sp <== NOT EXECUTED
5a398: 4a00 tstb %d0 <== NOT EXECUTED
5a39a: 671a beqs 5a3b6 <rtems_rfs_rtems_lock.isra.1+0x4a><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
5a39c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5a39e: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
5a3a4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5a3a6: 4879 0006 c00a pea 6c00a <ramdisk_ops+0xbcc> <== NOT EXECUTED
5a3ac: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5a3b2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
}
5a3b6: 242e fffc movel %fp@(-4),%d2
5a3ba: 4e5e unlk %fp <== NOT EXECUTED
0005a07a <rtems_rfs_rtems_lock.isra.3>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
5a07a: 4e56 0000 linkw %fp,#0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
5a07e: 206e 0008 moveal %fp@(8),%a0
5a082: 2f02 movel %d2,%sp@-
5a084: 42a7 clrl %sp@-
5a086: 42a7 clrl %sp@-
5a088: 2f10 movel %a0@,%sp@-
5a08a: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
5a090: 4fef 000c lea %sp@(12),%sp
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
5a094: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
5a096: 672c beqs 5a0c4 <rtems_rfs_rtems_lock.isra.3+0x4a><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
5a098: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
5a09c: 42a7 clrl %sp@- <== NOT EXECUTED
5a09e: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5a0a4: 508f addql #8,%sp <== NOT EXECUTED
5a0a6: 4a00 tstb %d0 <== NOT EXECUTED
5a0a8: 671a beqs 5a0c4 <rtems_rfs_rtems_lock.isra.3+0x4a><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
5a0aa: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5a0ac: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
5a0b2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5a0b4: 4879 0006 c00a pea 6c00a <ramdisk_ops+0xbcc> <== NOT EXECUTED
5a0ba: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5a0c0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
}
5a0c4: 242e fffc movel %fp@(-4),%d2
5a0c8: 4e5e unlk %fp <== NOT EXECUTED
0004e8ce <rtems_rfs_rtems_mknod>:
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
4e8ce: 4e56 ffb0 linkw %fp,#-80
4e8d2: 206e 0018 moveal %fp@(24),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e8d6: 2268 0010 moveal %a0@(16),%a1
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
4e8da: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e8de: 2469 0034 moveal %a1@(52),%a2
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e8e2: 2810 movel %a0@,%d4
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
4e8e4: 242e 0008 movel %fp@(8),%d2
4e8e8: 262e 000c movel %fp@(12),%d3
4e8ec: 2c2e 0010 movel %fp@(16),%d6
4e8f0: 2a2e 0014 movel %fp@(20),%d5
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
4e8f4: 4eb9 0005 2bb8 jsr 52bb8 <geteuid>
4e8fa: 3640 moveaw %d0,%a3
gid = getegid ();
4e8fc: 4eb9 0005 2ba4 jsr 52ba4 <getegid>
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
4e902: 2f2a 007c movel %a2@(124),%sp@-
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
gid = getegid ();
4e906: 3840 moveaw %d0,%a4
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
4e908: 4eba fa08 jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
rtems_rfs_rtems_imode (mode),
4e90c: 2f03 movel %d3,%sp@-
4e90e: 4eb9 0004 f5d4 jsr 4f5d4 <rtems_rfs_rtems_imode>
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4e914: 2f02 movel %d2,%sp@-
rtems_rfs_rtems_imode (mode),
4e916: 3e00 movew %d0,%d7
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4e918: 4eb9 0005 cdac jsr 5cdac <strlen>
4e91e: 588f addql #4,%sp
4e920: 486e fffc pea %fp@(-4)
4e924: 3f0c movew %a4,%sp@-
4e926: 4267 clrw %sp@-
4e928: 3f0b movew %a3,%sp@-
4e92a: 4267 clrw %sp@-
4e92c: 4878 0001 pea 1 <ADD>
4e930: 3f07 movew %d7,%sp@-
4e932: 4267 clrw %sp@-
4e934: 2f00 movel %d0,%sp@-
4e936: 2f02 movel %d2,%sp@-
4e938: 2f04 movel %d4,%sp@-
4e93a: 2f0a movel %a2,%sp@-
4e93c: 4eb9 0004 dcc0 jsr 4dcc0 <rtems_rfs_inode_create>
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
4e942: 4fef 002c lea %sp@(44),%sp
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4e946: 2400 movel %d0,%d2
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
4e948: 6f0a bles 4e954 <rtems_rfs_rtems_mknod+0x86>
{
rtems_rfs_rtems_unlock (fs);
4e94a: 2f0a movel %a2,%sp@-
4e94c: 4eba f7a6 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>)
4e950: 6000 00c2 braw 4ea14 <rtems_rfs_rtems_mknod+0x146>
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e954: 4878 0001 pea 1 <ADD>
4e958: 240e movel %fp,%d2
4e95a: 0682 ffff ffd6 addil #-42,%d2
4e960: 2f02 movel %d2,%sp@-
4e962: 2f2e fffc movel %fp@(-4),%sp@-
4e966: 2f0a movel %a2,%sp@-
4e968: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
4e96e: 4fef 0010 lea %sp@(16),%sp
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e972: 2800 movel %d0,%d4
if (rc > 0)
4e974: 6f18 bles 4e98e <rtems_rfs_rtems_mknod+0xc0> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e976: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e978: 4eba f77a jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: inode open", rc);
4e97c: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e982: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e984: 2084 movel %d4,%a0@ <== NOT EXECUTED
4e986: 588f addql #4,%sp
4e988: 70ff moveq #-1,%d0
4e98a: 6000 009e braw 4ea2a <rtems_rfs_rtems_mknod+0x15c>
}
if (S_ISDIR(mode) || S_ISREG(mode))
4e98e: 0283 0000 f000 andil #61440,%d3
4e994: 0c83 0000 4000 cmpil #16384,%d3
4e99a: 675e beqs 4e9fa <rtems_rfs_rtems_mknod+0x12c>
4e99c: 0c83 0000 8000 cmpil #32768,%d3
4e9a2: 6756 beqs 4e9fa <rtems_rfs_rtems_mknod+0x12c> <== ALWAYS TAKEN
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
4e9a4: 0c83 0000 2000 cmpil #8192,%d3 <== NOT EXECUTED
4e9aa: 6708 beqs 4e9b4 <rtems_rfs_rtems_mknod+0xe6> <== NOT EXECUTED
4e9ac: 0c83 0000 6000 cmpil #24576,%d3 <== NOT EXECUTED
4e9b2: 6624 bnes 4e9d8 <rtems_rfs_rtems_mknod+0x10a> <== NOT EXECUTED
{
int major;
int minor;
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_rfs_inode_set_block (&inode, 0, major);
4e9b4: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4e9b6: 240e movel %fp,%d2 <== NOT EXECUTED
4e9b8: 0682 ffff ffd6 addil #-42,%d2 <== NOT EXECUTED
4e9be: 47fa f650 lea %pc@(4e010 <rtems_rfs_inode_set_block>),%a3<== NOT EXECUTED
4e9c2: 42a7 clrl %sp@- <== NOT EXECUTED
4e9c4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e9c6: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
4e9c8: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4e9ca: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4e9ce: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e9d0: 4e93 jsr %a3@ <== NOT EXECUTED
if (S_ISDIR(mode) || S_ISREG(mode))
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
{
4e9d2: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4e9d6: 6022 bras 4e9fa <rtems_rfs_rtems_mknod+0x12c> <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
4e9d8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
4e9da: 7616 moveq #22,%d3 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
4e9dc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e9de: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4e9e4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e9e6: 4eba f70c jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
4e9ea: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e9f0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4e9f4: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e9f6: 2083 movel %d3,%a0@ <== NOT EXECUTED
4e9f8: 608e bras 4e988 <rtems_rfs_rtems_mknod+0xba> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
4e9fa: 486e ffd6 pea %fp@(-42)
4e9fe: 2f0a movel %a2,%sp@-
4ea00: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
if (rc > 0)
4ea06: 508f addql #8,%sp
4ea08: 41fa f6ea lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
4ea0c: 2400 movel %d0,%d2
if (rc > 0)
4ea0e: 6f12 bles 4ea22 <rtems_rfs_rtems_mknod+0x154> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4ea10: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ea12: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
4ea14: 4eb9 0005 b6e4 jsr 5b6e4 <__errno>
4ea1a: 2040 moveal %d0,%a0
4ea1c: 2082 movel %d2,%a0@
4ea1e: 6000 ff66 braw 4e986 <rtems_rfs_rtems_mknod+0xb8>
}
rtems_rfs_rtems_unlock (fs);
4ea22: 2f0a movel %a2,%sp@-
4ea24: 4e90 jsr %a0@
return 0;
4ea26: 588f addql #4,%sp
4ea28: 4280 clrl %d0
}
4ea2a: 4cee 1cfc ffb0 moveml %fp@(-80),%d2-%d7/%a2-%a4
4ea30: 4e5e unlk %fp <== NOT EXECUTED
0004e804 <rtems_rfs_rtems_node_type>:
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
4e804: 4e56 ffc8 linkw %fp,#-56
4e808: 206e 0008 moveal %fp@(8),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e80c: 2268 0010 moveal %a0@(16),%a1
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
4e810: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e814: 2410 movel %a0@,%d2
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e816: 47ee ffda lea %fp@(-38),%a3
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e81a: 2469 0034 moveal %a1@(52),%a2
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
4e81e: 2f2a 007c movel %a2@(124),%sp@-
4e822: 4eba faee jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e826: 4878 0001 pea 1 <ADD>
4e82a: 2f0b movel %a3,%sp@-
4e82c: 2f02 movel %d2,%sp@-
4e82e: 2f0a movel %a2,%sp@-
4e830: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
4e836: 4fef 0014 lea %sp@(20),%sp
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e83a: 2400 movel %d0,%d2
if (rc > 0)
4e83c: 6f12 bles 4e850 <rtems_rfs_rtems_node_type+0x4c> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e83e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e840: 4eba f8b2 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
4e844: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e84a: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e84c: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e84e: 6066 bras 4e8b6 <rtems_rfs_rtems_node_type+0xb2> <== NOT EXECUTED
* system. All directory entries are links to an inode. A link such as a HARD
* link is actually the normal path to a regular file, directory, device
* etc's inode. Links to inodes can be considered "the real" one, yet they
* are all links.
*/
mode = rtems_rfs_inode_get_mode (&inode);
4e850: 206b 000c moveal %a3@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4e854: 4280 clrl %d0
4e856: 1028 0002 moveb %a0@(2),%d0
4e85a: e188 lsll #8,%d0
if (RTEMS_RFS_S_ISDIR (mode))
4e85c: 0280 0000 f000 andil #61440,%d0
4e862: 0c80 0000 4000 cmpil #16384,%d0
4e868: 671a beqs 4e884 <rtems_rfs_rtems_node_type+0x80>
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
4e86a: 0c80 0000 a000 cmpil #40960,%d0
4e870: 6716 beqs 4e888 <rtems_rfs_rtems_node_type+0x84>
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
4e872: 0c80 0000 6000 cmpil #24576,%d0
4e878: 6712 beqs 4e88c <rtems_rfs_rtems_node_type+0x88> <== NEVER TAKEN
4e87a: 0c80 0000 2000 cmpil #8192,%d0
4e880: 660e bnes 4e890 <rtems_rfs_rtems_node_type+0x8c> <== ALWAYS TAKEN
4e882: 6008 bras 4e88c <rtems_rfs_rtems_node_type+0x88> <== NOT EXECUTED
* etc's inode. Links to inodes can be considered "the real" one, yet they
* are all links.
*/
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISDIR (mode))
type = RTEMS_FILESYSTEM_DIRECTORY;
4e884: 7401 moveq #1,%d2
4e886: 600a bras 4e892 <rtems_rfs_rtems_node_type+0x8e>
else if (RTEMS_RFS_S_ISLNK (mode))
type = RTEMS_FILESYSTEM_SYM_LINK;
4e888: 7404 moveq #4,%d2
4e88a: 6006 bras 4e892 <rtems_rfs_rtems_node_type+0x8e>
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
type = RTEMS_FILESYSTEM_DEVICE;
4e88c: 7402 moveq #2,%d2 <== NOT EXECUTED
4e88e: 6002 bras 4e892 <rtems_rfs_rtems_node_type+0x8e> <== NOT EXECUTED
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
4e890: 7405 moveq #5,%d2
rc = rtems_rfs_inode_close (fs, &inode);
4e892: 486e ffda pea %fp@(-38)
4e896: 2f0a movel %a2,%sp@-
4e898: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
if (rc > 0)
4e89e: 508f addql #8,%sp
4e8a0: 41fa f852 lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
type = RTEMS_FILESYSTEM_DEVICE;
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
rc = rtems_rfs_inode_close (fs, &inode);
4e8a4: 2600 movel %d0,%d3
if (rc > 0)
4e8a6: 6f14 bles 4e8bc <rtems_rfs_rtems_node_type+0xb8> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e8a8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e8aa: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
4e8ac: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e8b2: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e8b4: 2083 movel %d3,%a0@ <== NOT EXECUTED
4e8b6: 588f addql #4,%sp <== NOT EXECUTED
4e8b8: 74ff moveq #-1,%d2 <== NOT EXECUTED
4e8ba: 6006 bras 4e8c2 <rtems_rfs_rtems_node_type+0xbe> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e8bc: 2f0a movel %a2,%sp@-
4e8be: 4e90 jsr %a0@
return type;
4e8c0: 588f addql #4,%sp
}
4e8c2: 2002 movel %d2,%d0
4e8c4: 4cee 0c0c ffc8 moveml %fp@(-56),%d2-%d3/%a2-%a3
4e8ca: 4e5e unlk %fp <== NOT EXECUTED
0004e324 <rtems_rfs_rtems_rename>:
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
4e324: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED
4e328: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
4e32c: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
4e330: 48d7 047c moveml %d2-%d6/%a2,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
4e334: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
rtems_rfs_ino new_parent;
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
4e338: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
4e33c: 2811 movel %a1@,%d4 <== NOT EXECUTED
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
4e33e: 226e 0010 moveal %fp@(16),%a1 <== NOT EXECUTED
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
4e342: 2410 movel %a0@,%d2 <== NOT EXECUTED
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
4e344: 2c11 movel %a1@,%d6 <== NOT EXECUTED
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
4e346: 2a28 0004 movel %a0@(4),%d5 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))
printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
ino, doff, new_parent, new_name);
rtems_rfs_rtems_lock (fs);
4e34a: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
4e34e: 262e 0014 movel %fp@(20),%d3 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))
printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
ino, doff, new_parent, new_name);
rtems_rfs_rtems_lock (fs);
4e352: 4eba ffbe jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)<== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, strlen (new_name), new_parent, ino, true);
4e356: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4e358: 4eb9 0005 cdac jsr 5cdac <strlen> <== NOT EXECUTED
4e35e: 7201 moveq #1,%d1 <== NOT EXECUTED
4e360: 2e81 movel %d1,%sp@ <== NOT EXECUTED
4e362: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e364: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4e366: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4e368: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4e36a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e36c: 4eb9 0005 9294 jsr 59294 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
4e372: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, strlen (new_name), new_parent, ino, true);
4e376: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc)
4e378: 6712 beqs 4e38c <rtems_rfs_rtems_rename+0x68> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e37a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e37c: 4eba fd76 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: linking", rc);
4e380: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e386: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e388: 2083 movel %d3,%a0@ <== NOT EXECUTED
4e38a: 602c bras 4e3b8 <rtems_rfs_rtems_rename+0x94> <== NOT EXECUTED
/*
* Unlink all inodes even directories with the dir option as false because a
* directory may not be empty.
*/
rc = rtems_rfs_unlink (fs, old_parent, ino, doff,
4e38c: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
4e390: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4e392: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e394: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4e396: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e398: 4eb9 0005 9442 jsr 59442 <rtems_rfs_unlink> <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
4e39e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4e3a2: 41fa fd50 lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
/*
* Unlink all inodes even directories with the dir option as false because a
* directory may not be empty.
*/
rc = rtems_rfs_unlink (fs, old_parent, ino, doff,
4e3a6: 2400 movel %d0,%d2 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
4e3a8: 6714 beqs 4e3be <rtems_rfs_rtems_rename+0x9a> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e3aa: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e3ac: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: unlinking", rc);
4e3ae: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e3b4: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e3b6: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e3b8: 588f addql #4,%sp <== NOT EXECUTED
4e3ba: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e3bc: 6008 bras 4e3c6 <rtems_rfs_rtems_rename+0xa2> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e3be: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e3c0: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
4e3c2: 588f addql #4,%sp <== NOT EXECUTED
4e3c4: 4280 clrl %d0 <== NOT EXECUTED
}
4e3c6: 4cee 047c ffe8 moveml %fp@(-24),%d2-%d6/%a2 <== NOT EXECUTED
4e3cc: 4e5e unlk %fp <== NOT EXECUTED
0004e4ae <rtems_rfs_rtems_rmnod>:
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
4e4ae: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
4e4b2: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e4b6: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
4e4ba: 48d7 041c moveml %d2-%d4/%a2,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e4be: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
4e4c2: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e4c6: 2610 movel %a0@,%d3 <== NOT EXECUTED
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
4e4c8: 2411 movel %a1@,%d2 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
4e4ca: 2828 0004 movel %a0@(4),%d4 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RMNOD))
printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
4e4ce: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
4e4d2: 4eba fe3e jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)<== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
4e4d6: 42a7 clrl %sp@- <== NOT EXECUTED
4e4d8: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4e4da: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4e4dc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e4de: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e4e0: 4eb9 0005 9442 jsr 59442 <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
4e4e6: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4e4ea: 41fa fc08 lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
4e4ee: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
4e4f0: 6714 beqs 4e506 <rtems_rfs_rtems_rmnod+0x58> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e4f2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e4f4: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("rmnod: unlinking", rc);
4e4f6: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e4fc: 588f addql #4,%sp <== NOT EXECUTED
4e4fe: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e500: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e502: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e504: 6008 bras 4e50e <rtems_rfs_rtems_rmnod+0x60> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e506: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e508: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
4e50a: 588f addql #4,%sp <== NOT EXECUTED
4e50c: 4280 clrl %d0 <== NOT EXECUTED
}
4e50e: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 <== NOT EXECUTED
4e514: 4e5e unlk %fp <== NOT EXECUTED
0004f544 <rtems_rfs_rtems_set_handlers>:
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4f544: 4280 clrl %d0
4f546: 4281 clrl %d1
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
4f548: 4e56 0000 linkw %fp,#0
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
4f54c: 226e 000c moveal %fp@(12),%a1
4f550: 2269 000c moveal %a1@(12),%a1
4f554: 1029 0002 moveb %a1@(2),%d0
4f558: 1229 0003 moveb %a1@(3),%d1
4f55c: e188 lsll #8,%d0
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
4f55e: 206e 0008 moveal %fp@(8),%a0
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
4f562: 8081 orl %d1,%d0
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
4f564: 42a8 0008 clrl %a0@(8)
if (RTEMS_RFS_S_ISDIR (mode))
4f568: 2200 movel %d0,%d1
4f56a: 0281 0000 f000 andil #61440,%d1
4f570: 0c81 0000 4000 cmpil #16384,%d1
4f576: 6608 bnes 4f580 <rtems_rfs_rtems_set_handlers+0x3c>
loc->handlers = rtems_rfs_rtems_handlers (dir);
4f578: 203c 0006 dbb2 movel #449458,%d0
4f57e: 6016 bras 4f596 <rtems_rfs_rtems_set_handlers+0x52>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
4f580: 0c81 0000 2000 cmpil #8192,%d1
4f586: 6708 beqs 4f590 <rtems_rfs_rtems_set_handlers+0x4c><== NEVER TAKEN
4f588: 0c81 0000 6000 cmpil #24576,%d1
4f58e: 660e bnes 4f59e <rtems_rfs_rtems_set_handlers+0x5a><== ALWAYS TAKEN
loc->handlers = rtems_rfs_rtems_handlers (device);
4f590: 203c 0006 db7a movel #449402,%d0 <== NOT EXECUTED
4f596: 2140 0008 movel %d0,%a0@(8)
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
4f59a: 7001 moveq #1,%d0
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
4f59c: 6032 bras 4f5d0 <rtems_rfs_rtems_set_handlers+0x8c>
else if (RTEMS_RFS_S_ISLNK (mode))
4f59e: 0c81 0000 a000 cmpil #40960,%d1
4f5a4: 6608 bnes 4f5ae <rtems_rfs_rtems_set_handlers+0x6a>
loc->handlers = rtems_rfs_rtems_handlers (link);
4f5a6: 203c 0006 c078 movel #442488,%d0
4f5ac: 60e8 bras 4f596 <rtems_rfs_rtems_set_handlers+0x52>
else if (RTEMS_RFS_S_ISREG (mode))
4f5ae: 0c81 0000 8000 cmpil #32768,%d1
4f5b4: 6608 bnes 4f5be <rtems_rfs_rtems_set_handlers+0x7a><== NEVER TAKEN
loc->handlers = rtems_rfs_rtems_handlers (file);
4f5b6: 203c 0006 dbea movel #449514,%d0
4f5bc: 60d8 bras 4f596 <rtems_rfs_rtems_set_handlers+0x52>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
4f5be: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4f5c0: 4879 0006 c0b0 pea 6c0b0 <rtems_rfs_rtems_link_handlers+0x38><== NOT EXECUTED
4f5c6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
return false;
4f5cc: 508f addql #8,%sp <== NOT EXECUTED
4f5ce: 4200 clrb %d0 <== NOT EXECUTED
}
return true;
}
4f5d0: 4e5e unlk %fp <== NOT EXECUTED
0004e064 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
4e064: 4e56 fff8 linkw %fp,#-8 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e068: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
4e06c: 2068 0010 moveal %a0@(16),%a0 <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
4e070: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e072: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
4e076: 2f0a movel %a2,%sp@- <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
4e078: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4e07c: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
4e080: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
4e084: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4e086: 4eb9 0004 d696 jsr 4d696 <rtems_rfs_group_usage> <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
4e08c: 24ab 0008 movel %a3@(8),%a2@ <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
4e090: 206b 000c moveal %a3@(12),%a0 <== NOT EXECUTED
4e094: 2568 0024 0004 movel %a0@(36),%a2@(4) <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
4e09a: 2028 001c movel %a0@(28),%d0 <== NOT EXECUTED
4e09e: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
4e0a2: 202b 0004 movel %a3@(4),%d0 <== NOT EXECUTED
4e0a6: 90ae fff8 subl %fp@(-8),%d0 <== NOT EXECUTED
4e0aa: 2540 0014 movel %d0,%a2@(20) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
4e0ae: 2540 001c movel %d0,%a2@(28) <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
4e0b2: 202b 0010 movel %a3@(16),%d0 <== NOT EXECUTED
4e0b6: 2540 0020 movel %d0,%a2@(32) <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
4e0ba: 90ae fffc subl %fp@(-4),%d0 <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
4e0be: 2553 0030 movel %a3@,%a2@(48) <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
4e0c2: 256b 0018 0034 movel %a3@(24),%a2@(52) <== NOT EXECUTED
return 0;
}
4e0c8: 266e fff4 moveal %fp@(-12),%a3 <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
4e0cc: 2540 0024 movel %d0,%a2@(36) <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
4e0d0: 2540 0028 movel %d0,%a2@(40) <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
4e0d4: 203c 2809 2001 movel #671686657,%d0 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
4e0da: 42aa 0008 clrl %a2@(8) <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
4e0de: 2540 002c movel %d0,%a2@(44) <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
4e0e2: 4280 clrl %d0 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
4e0e4: 42aa 0010 clrl %a2@(16) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
4e0e8: 42aa 0018 clrl %a2@(24) <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
4e0ec: 246e fff0 moveal %fp@(-16),%a2 <== NOT EXECUTED
4e0f0: 4e5e unlk %fp <== NOT EXECUTED
0004e582 <rtems_rfs_rtems_symlink>:
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
4e582: 4e56 ffe0 linkw %fp,#-32
4e586: 206e 0008 moveal %fp@(8),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
4e58a: 2268 0010 moveal %a0@(16),%a1
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
4e58e: 48d7 0cfc moveml %d2-%d7/%a2-%a3,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
4e592: 2469 0034 moveal %a1@(52),%a2
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
link_name, strlen (link_name),
4e596: 47f9 0005 cdac lea 5cdac <strlen>,%a3
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
4e59c: 2e10 movel %a0@,%d7
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
4e59e: 242e 0010 movel %fp@(16),%d2
4e5a2: 262e 000c movel %fp@(12),%d3
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
4e5a6: 4eb9 0005 2bb8 jsr 52bb8 <geteuid>
4e5ac: 3a00 movew %d0,%d5
gid = getegid ();
4e5ae: 4eb9 0005 2ba4 jsr 52ba4 <getegid>
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
4e5b4: 2f2a 007c movel %a2@(124),%sp@-
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
gid = getegid ();
4e5b8: 3c00 movew %d0,%d6
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
4e5ba: 4eba fd56 jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
link_name, strlen (link_name),
4e5be: 2f03 movel %d3,%sp@-
4e5c0: 4e93 jsr %a3@
4e5c2: 2800 movel %d0,%d4
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
4e5c4: 2e82 movel %d2,%sp@
4e5c6: 4e93 jsr %a3@
4e5c8: 2e87 movel %d7,%sp@
4e5ca: 3f06 movew %d6,%sp@-
4e5cc: 4267 clrw %sp@-
4e5ce: 3f05 movew %d5,%sp@-
4e5d0: 4267 clrw %sp@-
4e5d2: 2f04 movel %d4,%sp@-
4e5d4: 2f03 movel %d3,%sp@-
4e5d6: 2f00 movel %d0,%sp@-
4e5d8: 2f02 movel %d2,%sp@-
4e5da: 2f0a movel %a2,%sp@-
4e5dc: 4eb9 0005 97c8 jsr 597c8 <rtems_rfs_symlink>
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
4e5e2: 4fef 0024 lea %sp@(36),%sp
4e5e6: 41fa fb0c lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
4e5ea: 2400 movel %d0,%d2
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
4e5ec: 6714 beqs 4e602 <rtems_rfs_rtems_symlink+0x80> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e5ee: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e5f0: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("symlink: linking", rc);
4e5f2: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e5f8: 588f addql #4,%sp <== NOT EXECUTED
4e5fa: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e5fc: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e5fe: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e600: 6008 bras 4e60a <rtems_rfs_rtems_symlink+0x88> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e602: 2f0a movel %a2,%sp@-
4e604: 4e90 jsr %a0@
return 0;
4e606: 588f addql #4,%sp
4e608: 4280 clrl %d0
}
4e60a: 4cee 0cfc ffe0 moveml %fp@(-32),%d2-%d7/%a2-%a3
4e610: 4e5e unlk %fp <== NOT EXECUTED
0004e3d0 <rtems_rfs_rtems_unlink>:
*/
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
4e3d0: 4e56 fff0 linkw %fp,#-16
4e3d4: 226e 0008 moveal %fp@(8),%a1
4e3d8: 48d7 041c moveml %d2-%d4/%a2,%sp@
4e3dc: 206e 000c moveal %fp@(12),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
4e3e0: 2469 0010 moveal %a1@(16),%a2
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
4e3e4: 2411 movel %a1@,%d2
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
4e3e6: 2610 movel %a0@,%d3
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
4e3e8: 2828 0004 movel %a0@(4),%d4
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
4e3ec: 246a 0034 moveal %a2@(52),%a2
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
int rc;
rtems_rfs_rtems_lock (fs);
4e3f0: 2f2a 007c movel %a2@(124),%sp@-
4e3f4: 4eba ff1c jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))
printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
parent, doff, ino);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
4e3f8: 42a7 clrl %sp@-
4e3fa: 2f04 movel %d4,%sp@-
4e3fc: 2f03 movel %d3,%sp@-
4e3fe: 2f02 movel %d2,%sp@-
4e400: 2f0a movel %a2,%sp@-
4e402: 4eb9 0005 9442 jsr 59442 <rtems_rfs_unlink>
if (rc)
4e408: 4fef 0018 lea %sp@(24),%sp
4e40c: 41fa fce6 lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))
printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
parent, doff, ino);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
4e410: 2400 movel %d0,%d2
if (rc)
4e412: 6714 beqs 4e428 <rtems_rfs_rtems_unlink+0x58> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e414: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e416: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
4e418: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e41e: 588f addql #4,%sp <== NOT EXECUTED
4e420: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e422: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e424: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e426: 6008 bras 4e430 <rtems_rfs_rtems_unlink+0x60> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e428: 2f0a movel %a2,%sp@-
4e42a: 4e90 jsr %a0@
return 0;
4e42c: 588f addql #4,%sp
4e42e: 4280 clrl %d0
}
4e430: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4e436: 4e5e unlk %fp <== NOT EXECUTED
0004e0f4 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
4e0f4: 4e56 0000 linkw %fp,#0
4e0f8: 206e 0008 moveal %fp@(8),%a0
4e0fc: 2f0a movel %a2,%sp@-
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
4e0fe: 2468 007c moveal %a0@(124),%a2
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
4e102: 2f02 movel %d2,%sp@-
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
4e104: 2f08 movel %a0,%sp@-
4e106: 4eb9 0005 6aca jsr 56aca <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
4e10c: 2f12 movel %a2@,%sp@-
4e10e: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
4e114: 508f addql #8,%sp
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
4e116: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
4e118: 672c beqs 4e146 <rtems_rfs_rtems_unlock+0x52> <== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4e11a: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4e11e: 42a7 clrl %sp@- <== NOT EXECUTED
4e120: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
4e126: 508f addql #8,%sp <== NOT EXECUTED
4e128: 4a00 tstb %d0 <== NOT EXECUTED
4e12a: 671a beqs 4e146 <rtems_rfs_rtems_unlock+0x52> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
4e12c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e12e: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
4e134: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4e136: 4879 0006 bfe4 pea 6bfe4 <ramdisk_ops+0xba6> <== NOT EXECUTED
4e13c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
4e142: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_mutex_unlock (&rtems->access);
}
4e146: 242e fff8 movel %fp@(-8),%d2
4e14a: 246e fffc moveal %fp@(-4),%a2
4e14e: 4e5e unlk %fp <== NOT EXECUTED
0004e614 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
4e614: 4e56 ffc4 linkw %fp,#-60 <== NOT EXECUTED
4e618: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e61c: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
4e620: 48d7 043c moveml %d2-%d5/%a2,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e624: 2a10 movel %a0@,%d5 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e626: 280e movel %fp,%d4 <== NOT EXECUTED
4e628: 0684 ffff ffda addil #-38,%d4 <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e62e: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
4e632: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
4e636: 262e 000c movel %fp@(12),%d3 <== NOT EXECUTED
4e63a: 242e 0010 movel %fp@(16),%d2 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
4e63e: 4eba fcd2 jsr %pc@(4e312 <rtems_rfs_rtems_lock.isra.16>)<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e642: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4e646: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4e648: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4e64a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e64c: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
4e652: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e656: 2a00 movel %d0,%d5 <== NOT EXECUTED
if (rc)
4e658: 6712 beqs 4e66c <rtems_rfs_rtems_utime+0x58> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e65a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e65c: 4eba fa96 jsr %pc@(4e0f4 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: read inode", rc);
4e660: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e666: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e668: 2085 movel %d5,%a0@ <== NOT EXECUTED
4e66a: 606a bras 4e6d6 <rtems_rfs_rtems_utime+0xc2> <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4e66c: 206e ffe6 moveal %fp@(-26),%a0 <== NOT EXECUTED
4e670: 7218 moveq #24,%d1 <== NOT EXECUTED
4e672: 2003 movel %d3,%d0 <== NOT EXECUTED
4e674: e2a8 lsrl %d1,%d0 <== NOT EXECUTED
4e676: 1140 0010 moveb %d0,%a0@(16) <== NOT EXECUTED
4e67a: 2003 movel %d3,%d0 <== NOT EXECUTED
4e67c: 4240 clrw %d0 <== NOT EXECUTED
4e67e: 4840 swap %d0 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4e680: 1142 0017 moveb %d2,%a0@(23) <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4e684: 1143 0013 moveb %d3,%a0@(19) <== NOT EXECUTED
4e688: 1140 0011 moveb %d0,%a0@(17) <== NOT EXECUTED
4e68c: 2003 movel %d3,%d0 <== NOT EXECUTED
4e68e: e088 lsrl #8,%d0 <== NOT EXECUTED
4e690: 1140 0012 moveb %d0,%a0@(18) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4e694: 7001 moveq #1,%d0 <== NOT EXECUTED
4e696: 1d40 ffea moveb %d0,%fp@(-22) <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4e69a: 2002 movel %d2,%d0 <== NOT EXECUTED
4e69c: e2a8 lsrl %d1,%d0 <== NOT EXECUTED
4e69e: 1140 0014 moveb %d0,%a0@(20) <== NOT EXECUTED
4e6a2: 2002 movel %d2,%d0 <== NOT EXECUTED
4e6a4: 4240 clrw %d0 <== NOT EXECUTED
4e6a6: 4840 swap %d0 <== NOT EXECUTED
4e6a8: 1140 0015 moveb %d0,%a0@(21) <== NOT EXECUTED
4e6ac: 2002 movel %d2,%d0 <== NOT EXECUTED
4e6ae: e088 lsrl #8,%d0 <== NOT EXECUTED
4e6b0: 1140 0016 moveb %d0,%a0@(22) <== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
4e6b4: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4e6b6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e6b8: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
4e6be: 508f addql #8,%sp <== NOT EXECUTED
4e6c0: 41fa fa32 lea %pc@(4e0f4 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
4e6c4: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
4e6c6: 6714 beqs 4e6dc <rtems_rfs_rtems_utime+0xc8> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e6c8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e6ca: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: closing inode", rc);
4e6cc: 4eb9 0005 b6e4 jsr 5b6e4 <__errno> <== NOT EXECUTED
4e6d2: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e6d4: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e6d6: 588f addql #4,%sp <== NOT EXECUTED
4e6d8: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e6da: 6008 bras 4e6e4 <rtems_rfs_rtems_utime+0xd0> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e6dc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e6de: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
4e6e0: 588f addql #4,%sp <== NOT EXECUTED
4e6e2: 4280 clrl %d0 <== NOT EXECUTED
}
4e6e4: 4cee 043c ffc4 moveml %fp@(-60),%d2-%d5/%a2 <== NOT EXECUTED
4e6ea: 4e5e unlk %fp <== NOT EXECUTED
0004c5f6 <rtems_rfs_rup_quotient>:
* Return a rounded up integer quotient given a dividend and divisor. That is:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
4c5f6: 4e56 0000 linkw %fp,#0
4c5fa: 202e 0008 movel %fp@(8),%d0
4c5fe: 222e 000c movel %fp@(12),%d1
4c602: 2f02 movel %d2,%sp@-
if (dividend == 0)
4c604: 4a80 tstl %d0
4c606: 670a beqs 4c612 <rtems_rfs_rup_quotient+0x1c> <== NEVER TAKEN
return 1;
return ((dividend - 1) / divisor) + 1;
4c608: 5380 subql #1,%d0
4c60a: 4c41 0000 remul %d1,%d0,%d0
4c60e: 5280 addql #1,%d0
4c610: 6002 bras 4c614 <rtems_rfs_rup_quotient+0x1e>
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
4c612: 7001 moveq #1,%d0 <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
}
4c614: 241f movel %sp@+,%d2
4c616: 4e5e unlk %fp <== NOT EXECUTED
000564a0 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
564a0: 4e56 ffe8 linkw %fp,#-24
564a4: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
564a8: 286e 0008 moveal %fp@(8),%a4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
564ac: 246c 0008 moveal %a4@(8),%a2
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
564b0: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
564b4: 266e 000c moveal %fp@(12),%a3
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
564b8: 42a7 clrl %sp@-
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
564ba: 242e 0010 movel %fp@(16),%d2
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
564be: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
564c4: 508f addql #8,%sp
564c6: 4a00 tstb %d0
564c8: 677a beqs 56544 <rtems_rfs_scan_chain+0xa4> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
564ca: 2f02 movel %d2,%sp@- <== NOT EXECUTED
564cc: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
564ce: 4879 0006 c7d3 pea 6c7d3 <CSWTCH.1+0x119> <== NOT EXECUTED
564d4: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
564da: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
564de: 6064 bras 56544 <rtems_rfs_scan_chain+0xa4> <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
564e0: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
564e4: 2043 moveal %d3,%a0
564e6: 42a7 clrl %sp@-
564e8: 4e90 jsr %a0@
564ea: 508f addql #8,%sp
564ec: 4a00 tstb %d0
564ee: 670e beqs 564fe <rtems_rfs_scan_chain+0x5e> <== ALWAYS TAKEN
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
564f0: 2f2a 0036 movel %a2@(54),%sp@- <== NOT EXECUTED
564f4: 4879 0006 c802 pea 6c802 <CSWTCH.1+0x148> <== NOT EXECUTED
564fa: 4e95 jsr %a5@ <== NOT EXECUTED
564fc: 508f addql #8,%sp <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
564fe: b4aa 0036 cmpl %a2@(54),%d2
56502: 663a bnes 5653e <rtems_rfs_scan_chain+0x9e>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
56504: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
56508: 42a7 clrl %sp@-
5650a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56510: 508f addql #8,%sp
56512: 4a00 tstb %d0
56514: 6712 beqs 56528 <rtems_rfs_scan_chain+0x88> <== ALWAYS TAKEN
printf (": found block=%" PRIuPTR "\n",
56516: 2f2a 0036 movel %a2@(54),%sp@- <== NOT EXECUTED
5651a: 4879 0006 c807 pea 6c807 <CSWTCH.1+0x14d> <== NOT EXECUTED
56520: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
56526: 508f addql #8,%sp <== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
56528: 5393 subql #1,%a3@
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
5652a: 2f0a movel %a2,%sp@-
5652c: 4eb9 0004 9a3c jsr 49a3c <_Chain_Extract>
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
56532: 588f addql #4,%sp
56534: 200a movel %a2,%d0
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
56536: 42aa 0004 clrl %a2@(4)
5653a: 4292 clrl %a2@
5653c: 6038 bras 56576 <rtems_rfs_scan_chain+0xd6>
true);
if ((rc > 0) && (rrc == 0))
rrc = rc;
return rrc;
}
5653e: 246a 0004 moveal %a2@(4),%a2
56542: 600c bras 56550 <rtems_rfs_scan_chain+0xb0>
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
56544: 4bf9 0005 c170 lea 5c170 <printf>,%a5
5654a: 263c 0004 f5ec movel #325100,%d3
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
56550: b9ca cmpal %a2,%a4
56552: 668c bnes 564e0 <rtems_rfs_scan_chain+0x40>
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
56554: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
56558: 42a7 clrl %sp@-
5655a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
56560: 508f addql #8,%sp
56562: 4a00 tstb %d0
56564: 670e beqs 56574 <rtems_rfs_scan_chain+0xd4> <== ALWAYS TAKEN
printf (": not found\n");
56566: 4879 0006 c81a pea 6c81a <CSWTCH.1+0x160> <== NOT EXECUTED
5656c: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
56572: 588f addql #4,%sp <== NOT EXECUTED
return NULL;
56574: 4280 clrl %d0
}
56576: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
5657c: 4e5e unlk %fp <== NOT EXECUTED
000550b8 <rtems_rfs_search_map_for_clear_bit.constprop.1>:
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
550b8: 4e56 ffbc linkw %fp,#-68
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
550bc: 206e 0010 moveal %fp@(16),%a0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
550c0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
550c4: 4210 clrb %a0@
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
550c6: 246e 0008 moveal %fp@(8),%a2
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
550ca: 486e fffc pea %fp@(-4)
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
550ce: 242e 0014 movel %fp@(20),%d2
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
550d2: 2f0a movel %a2,%sp@-
550d4: 4eba ff96 jsr %pc@(5506c <rtems_rfs_bitmap_load_map>)
if (rc > 0)
550d8: 508f addql #8,%sp
550da: 4a80 tstl %d0
550dc: 6e00 0166 bgtw 55244 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18c>
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
550e0: 206e 000c moveal %fp@(12),%a0
end_bit = test_bit + (window * direction);
550e4: 2202 movel %d2,%d1
550e6: 760b moveq #11,%d3
550e8: e7a9 lsll %d3,%d1
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
550ea: 2010 movel %a0@,%d0
end_bit = test_bit + (window * direction);
550ec: d280 addl %d0,%d1
if (end_bit < 0)
550ee: 6b0e bmis 550fe <rtems_rfs_search_map_for_clear_bit.constprop.1+0x46>
end_bit = 0;
else if (end_bit >= control->size)
550f0: 206a 000c moveal %a2@(12),%a0
550f4: b1c1 cmpal %d1,%a0
550f6: 6208 bhis 55100 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48><== NEVER TAKEN
end_bit = control->size - 1;
550f8: 2208 movel %a0,%d1
550fa: 5381 subql #1,%d1
550fc: 6002 bras 55100 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
*/
test_bit = *bit;
end_bit = test_bit + (window * direction);
if (end_bit < 0)
end_bit = 0;
550fe: 4281 clrl %d1
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
55100: 2c00 movel %d0,%d6
55102: 7e0a moveq #10,%d7
55104: eea6 asrl %d7,%d6
if (end_bit < 0)
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
55106: 2a00 movel %d0,%d5
55108: ea85 asrl #5,%d5
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
5510a: 781f moveq #31,%d4
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
5510c: 761f moveq #31,%d3
search_bits = &control->search_bits[search_index];
5510e: e58e lsll #2,%d6
55110: 226a 0014 moveal %a2@(20),%a1
55114: d3c6 addal %d6,%a1
map_bits = &map[map_index];
55116: 2c05 movel %d5,%d6
55118: e58e lsll #2,%d6
5511a: 206e fffc moveal %fp@(-4),%a0
5511e: d1c6 addal %d6,%a0
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
55120: 2c02 movel %d2,%d6
55122: e58e lsll #2,%d6
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
55124: c880 andl %d0,%d4
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
55126: c685 andl %d5,%d3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
55128: 2a46 moveal %d6,%a5
5512a: 4a82 tstl %d2
5512c: 6f04 bles 55132 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x7a>
5512e: 4286 clrl %d6
55130: 600c bras 5513e <rtems_rfs_search_map_for_clear_bit.constprop.1+0x86>
55132: 7c1f moveq #31,%d6
55134: 6008 bras 5513e <rtems_rfs_search_map_for_clear_bit.constprop.1+0x86>
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
55136: 761f moveq #31,%d3 <== NOT EXECUTED
55138: 6010 bras 5514a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x92><== NOT EXECUTED
5513a: 4283 clrl %d3 <== NOT EXECUTED
5513c: 600c bras 5514a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x92><== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
5513e: 2e02 movel %d2,%d7
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
55140: 387c 0001 moveaw #1,%a4
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
55144: eb8f lsll #5,%d7
55146: 2d47 ffe8 movel %d7,%fp@(-24)
/*
* If any bit is clear find that bit and then search the map element. If
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
5514a: 2d51 fff8 movel %a1@,%fp@(-8)
5514e: 6700 00ac beqw 551fc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
55152: 2e05 movel %d5,%d7
55154: de82 addl %d2,%d7
55156: eb8f lsll #5,%d7
55158: 2d44 fff0 movel %d4,%fp@(-16)
5515c: de86 addl %d6,%d7
5515e: 6000 008e braw 551ee <rtems_rfs_search_map_for_clear_bit.constprop.1+0x136>
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
55162: 280c movel %a4,%d4
55164: e7ac lsll %d3,%d4
55166: 2d44 fff4 movel %d4,%fp@(-12)
5516a: c8ae fff8 andl %fp@(-8),%d4
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
5516e: 675c beqs 551cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x114>
55170: 2d43 ffe4 movel %d3,%fp@(-28)
55174: 282e fff0 movel %fp@(-16),%d4
55178: 6048 bras 551c2 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x10a>
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
5517a: 260c movel %a4,%d3
5517c: e9ab lsll %d4,%d3
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
5517e: 2d50 fff0 movel %a0@,%fp@(-16)
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
55182: 2643 moveal %d3,%a3
55184: c6ae fff0 andl %fp@(-16),%d3
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
55188: 6730 beqs 551ba <rtems_rfs_search_map_for_clear_bit.constprop.1+0x102>
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
5518a: 220b movel %a3,%d1
5518c: 4681 notl %d1
5518e: c2ae fff0 andl %fp@(-16),%d1
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
55192: 2081 movel %d1,%a0@
if (rtems_rfs_bitmap_match(*map_bits,
55194: 6608 bnes 5519e <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe6>
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
55196: 222e fff4 movel %fp@(-12),%d1
5519a: 4681 notl %d1
5519c: c391 andl %d1,%a1@
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
5519e: 53aa 0010 subql #1,%a2@(16)
*bit = test_bit;
551a2: 206e 000c moveal %fp@(12),%a0
551a6: 2080 movel %d0,%a0@
*found = true;
551a8: 206e 0010 moveal %fp@(16),%a0
551ac: 10bc 0001 moveb #1,%a0@
rtems_rfs_buffer_mark_dirty (control->buffer);
551b0: 2052 moveal %a2@,%a0
551b2: 10bc 0001 moveb #1,%a0@
551b6: 6000 008a braw 55242 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18a>
return 0;
}
if (test_bit == end_bit)
551ba: b280 cmpl %d0,%d1
551bc: 670a beqs 551c8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x110>
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
551be: d882 addl %d2,%d4
551c0: d082 addl %d2,%d0
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
551c2: 761f moveq #31,%d3
551c4: b684 cmpl %d4,%d3
551c6: 64b2 bccs 5517a <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc2><== ALWAYS TAKEN
551c8: 262e ffe4 movel %fp@(-28),%d3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
551cc: d1cd addal %a5,%a0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
551ce: da82 addl %d2,%d5
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
551d0: 2007 movel %d7,%d0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
551d2: d682 addl %d2,%d3
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
551d4: 4a82 tstl %d2
551d6: 6c06 bges 551de <rtems_rfs_search_map_for_clear_bit.constprop.1+0x126>
551d8: b287 cmpl %d7,%d1
551da: 6d0a blts 551e6 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12e><== NEVER TAKEN
551dc: 604c bras 5522a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x172>
|| ((direction > 0) && (test_bit >= end_bit)))
551de: 4a82 tstl %d2
551e0: 6704 beqs 551e6 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12e><== NEVER TAKEN
551e2: b287 cmpl %d7,%d1
551e4: 6f44 bles 5522a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x172>
551e6: deae ffe8 addl %fp@(-24),%d7
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
551ea: 2d46 fff0 movel %d6,%fp@(-16)
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
551ee: 781f moveq #31,%d4
551f0: b883 cmpl %d3,%d4
551f2: 6400 ff6e bccw 55162 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xaa>
551f6: 282e fff0 movel %fp@(-16),%d4 <== NOT EXECUTED
551fa: 6030 bras 5522c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x174><== NOT EXECUTED
*
* Align test_bit either up or down depending on the direction to next 32
* bit boundary.
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
551fc: 7ee0 moveq #-32,%d7 <== NOT EXECUTED
551fe: c087 andl %d7,%d0 <== NOT EXECUTED
if (direction > 0)
55200: 4a82 tstl %d2 <== NOT EXECUTED
55202: 6f0e bles 55212 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15a><== NOT EXECUTED
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
55204: 7e20 moveq #32,%d7 <== NOT EXECUTED
55206: 9e83 subl %d3,%d7 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
55208: 2607 movel %d7,%d3 <== NOT EXECUTED
map_offset = 0;
5520a: 4284 clrl %d4 <== NOT EXECUTED
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
5520c: eb8b lsll #5,%d3 <== NOT EXECUTED
5520e: d083 addl %d3,%d0 <== NOT EXECUTED
55210: 600c bras 5521e <rtems_rfs_search_map_for_clear_bit.constprop.1+0x166><== NOT EXECUTED
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
55212: 2e03 movel %d3,%d7 <== NOT EXECUTED
55214: 5287 addql #1,%d7 <== NOT EXECUTED
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
55216: 781f moveq #31,%d4 <== NOT EXECUTED
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
55218: eb8b lsll #5,%d3 <== NOT EXECUTED
5521a: 4683 notl %d3 <== NOT EXECUTED
5521c: d083 addl %d3,%d0 <== NOT EXECUTED
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
5521e: 4c02 7800 mulsl %d2,%d7 <== NOT EXECUTED
map_index += direction * bits_skipped;
55222: da87 addl %d7,%d5 <== NOT EXECUTED
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
55224: 41f0 7c00 lea %a0@(00000000,%d7:l:4),%a0 <== NOT EXECUTED
55228: 6002 bras 5522c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x174><== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
5522a: 2806 movel %d6,%d4
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
5522c: d3cd addal %a5,%a1
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
5522e: 4a82 tstl %d2
55230: 6e0a bgts 5523c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x184>
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
55232: 670e beqs 55242 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18a><== NEVER TAKEN
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
}
while (((direction < 0) && (test_bit >= end_bit))
55234: b280 cmpl %d0,%d1
55236: 6f00 fefe blew 55136 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x7e>
5523a: 6006 bras 55242 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18a>
|| ((direction > 0) && (test_bit <= end_bit)));
5523c: b280 cmpl %d0,%d1
5523e: 6c00 fefa bgew 5513a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x82>
return 0;
55242: 4280 clrl %d0
}
55244: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
5524a: 4e5e unlk %fp <== NOT EXECUTED
000597c8 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
597c8: 4e56 ff54 linkw %fp,#-172
597cc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
597d0: 42a7 clrl %sp@-
597d2: 4878 0002 pea 2 <DOUBLE_FLOAT>
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
597d6: 246e 0008 moveal %fp@(8),%a2
597da: 242e 000c movel %fp@(12),%d2
597de: 2c2e 0014 movel %fp@(20),%d6
597e2: 262e 0018 movel %fp@(24),%d3
597e6: 2a2e 0024 movel %fp@(36),%d5
597ea: 3e2e 001e movew %fp@(30),%d7
597ee: 386e 0022 moveaw %fp@(34),%a4
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
597f2: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
597f8: 508f addql #8,%sp
597fa: 4a00 tstb %d0
597fc: 6758 beqs 59856 <rtems_rfs_symlink+0x8e> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
597fe: 2f05 movel %d5,%sp@- <== NOT EXECUTED
59800: 4879 0006 dae3 pea 6dae3 <CSWTCH.1+0x1429> <== NOT EXECUTED
59806: 2642 moveal %d2,%a3 <== NOT EXECUTED
for (c = 0; c < length; c++)
59808: 4284 clrl %d4 <== NOT EXECUTED
printf ("%c", name[c]);
5980a: 4bf9 0005 c1b0 lea 5c1b0 <putchar>,%a5 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
59810: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
59816: 508f addql #8,%sp <== NOT EXECUTED
59818: 600c bras 59826 <rtems_rfs_symlink+0x5e> <== NOT EXECUTED
5981a: 5284 addql #1,%d4 <== NOT EXECUTED
printf ("%c", name[c]);
5981c: 101b moveb %a3@+,%d0 <== NOT EXECUTED
5981e: 49c0 extbl %d0 <== NOT EXECUTED
59820: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59822: 4e95 jsr %a5@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
59824: 588f addql #4,%sp <== NOT EXECUTED
59826: b8ae 0010 cmpl %fp@(16),%d4 <== NOT EXECUTED
5982a: 6dee blts 5981a <rtems_rfs_symlink+0x52> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
5982c: 4879 0006 db08 pea 6db08 <CSWTCH.1+0x144e> <== NOT EXECUTED
59832: 2646 moveal %d6,%a3 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
59834: 4284 clrl %d4 <== NOT EXECUTED
printf ("%c", link[c]);
59836: 4bf9 0005 c1b0 lea 5c1b0 <putchar>,%a5 <== NOT EXECUTED
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
5983c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
59842: 588f addql #4,%sp <== NOT EXECUTED
59844: 600c bras 59852 <rtems_rfs_symlink+0x8a> <== NOT EXECUTED
59846: 5284 addql #1,%d4 <== NOT EXECUTED
printf ("%c", link[c]);
59848: 101b moveb %a3@+,%d0 <== NOT EXECUTED
5984a: 49c0 extbl %d0 <== NOT EXECUTED
5984c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5984e: 4e95 jsr %a5@ <== NOT EXECUTED
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
for (c = 0; c < link_length; c++)
59850: 588f addql #4,%sp <== NOT EXECUTED
59852: b684 cmpl %d4,%d3 <== NOT EXECUTED
59854: 6ef0 bgts 59846 <rtems_rfs_symlink+0x7e> <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
59856: b6aa 0008 cmpl %a2@(8),%d3
5985a: 6400 01c2 bccw 59a1e <rtems_rfs_symlink+0x256>
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
5985e: 2f02 movel %d2,%sp@-
59860: 4eb9 0005 cdac jsr 5cdac <strlen>
59866: 588f addql #4,%sp
59868: 486e fff8 pea %fp@(-8)
5986c: 3f0c movew %a4,%sp@-
5986e: 4267 clrw %sp@-
59870: 3f07 movew %d7,%sp@-
59872: 4267 clrw %sp@-
59874: 4878 0001 pea 1 <ADD>
59878: 2f3c 0000 a1ff movel #41471,%sp@-
5987e: 2f00 movel %d0,%sp@-
59880: 2f02 movel %d2,%sp@-
59882: 2f05 movel %d5,%sp@-
59884: 2f0a movel %a2,%sp@-
59886: 4eb9 0004 dcc0 jsr 4dcc0 <rtems_rfs_inode_create>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
5988c: 4fef 0024 lea %sp@(36),%sp
}
if (link_length >= rtems_rfs_fs_block_size (fs))
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
59890: 2400 movel %d0,%d2
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
59892: 6e00 018c bgtw 59a20 <rtems_rfs_symlink+0x258>
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
59896: 4878 0001 pea 1 <ADD>
5989a: 280e movel %fp,%d4
5989c: 0684 ffff ffc8 addil #-56,%d4
598a2: 2f04 movel %d4,%sp@-
598a4: 2f2e fff8 movel %fp@(-8),%sp@-
598a8: 2f0a movel %a2,%sp@-
598aa: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc > 0)
598b0: 4fef 0010 lea %sp@(16),%sp
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
598b4: 2400 movel %d0,%d2
if (rc > 0)
598b6: 6e00 0168 bgtw 59a20 <rtems_rfs_symlink+0x258>
/*
* If the link length is less than the length of data union in the inode
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
598ba: 7013 moveq #19,%d0
598bc: b083 cmpl %d3,%d0
598be: 6554 bcss 59914 <rtems_rfs_symlink+0x14c> <== NEVER TAKEN
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
598c0: 4878 0014 pea 14 <OPER2>
598c4: 206e ffd4 moveal %fp@(-44),%a0
598c8: 41e8 001c lea %a0@(28),%a0
598cc: 42a7 clrl %sp@-
598ce: 2f08 movel %a0,%sp@-
598d0: 4eb9 0005 c0e4 jsr 5c0e4 <memset>
memcpy (inode.node->data.name, link, link_length);
598d6: 206e ffd4 moveal %fp@(-44),%a0
598da: 41e8 001c lea %a0@(28),%a0
598de: 2f03 movel %d3,%sp@-
598e0: 2f06 movel %d6,%sp@-
598e2: 2f08 movel %a0,%sp@-
598e4: 4eb9 0005 bf8c jsr 5bf8c <memcpy>
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
598ea: 206e ffd4 moveal %fp@(-44),%a0
rtems_rfs_buffer_mark_dirty (&handle->buffer);
598ee: 4fef 0018 lea %sp@(24),%sp
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
598f2: 4200 clrb %d0
598f4: 1140 000c moveb %d0,%a0@(12)
598f8: 206e ffd4 moveal %fp@(-44),%a0
598fc: 1140 000d moveb %d0,%a0@(13)
59900: 206e ffd4 moveal %fp@(-44),%a0
59904: 1140 000e moveb %d0,%a0@(14)
59908: 206e ffd4 moveal %fp@(-44),%a0
5990c: 1140 000f moveb %d0,%a0@(15)
59910: 6000 00e0 braw 599f2 <rtems_rfs_symlink+0x22a>
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
59914: 2a0e movel %fp,%d5 <== NOT EXECUTED
59916: 0685 ffff ff7e addil #-130,%d5 <== NOT EXECUTED
5991c: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5991e: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59920: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59922: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
59928: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
5992c: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
5992e: 6e00 00b6 bgtw 599e6 <rtems_rfs_symlink+0x21e> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
59932: 486e fffc pea %fp@(-4) <== NOT EXECUTED
59936: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5993a: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5993c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5993e: 4eb9 0005 5eb6 jsr 55eb6 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
59944: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
59948: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
5994a: 6e2e bgts 5997a <rtems_rfs_symlink+0x1b2> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
5994c: 42a7 clrl %sp@- <== NOT EXECUTED
5994e: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
59952: 2e0e movel %fp,%d7 <== NOT EXECUTED
59954: 0687 ffff ffee addil #-18,%d7 <== NOT EXECUTED
5995a: 2f07 movel %d7,%sp@- <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
5995c: 4200 clrb %d0 <== NOT EXECUTED
5995e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59960: 1d40 ffee moveb %d0,%fp@(-18) <== NOT EXECUTED
handle->bnum = 0;
59964: 42ae fff0 clrl %fp@(-16) <== NOT EXECUTED
handle->buffer = NULL;
59968: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
5996c: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
59972: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
59976: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
59978: 6f1c bles 59996 <rtems_rfs_symlink+0x1ce> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
5997a: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5997c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5997e: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
59984: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59986: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59988: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
5998e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
59992: 6000 008c braw 59a20 <rtems_rfs_symlink+0x258> <== NOT EXECUTED
}
data = rtems_rfs_buffer_data (&buffer);
59996: 206e fff4 moveal %fp@(-12),%a0 <== NOT EXECUTED
5999a: 2428 001e movel %a0@(30),%d2 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
5999e: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
599a2: 4878 00ff pea ff <DBL_MANT_DIG+0xca> <== NOT EXECUTED
599a6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
599a8: 4eb9 0005 c0e4 jsr 5c0e4 <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
599ae: 2f03 movel %d3,%sp@- <== NOT EXECUTED
599b0: 2f06 movel %d6,%sp@- <== NOT EXECUTED
599b2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
599b4: 4eb9 0005 bf8c jsr 5bf8c <memcpy> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
599ba: 2f07 movel %d7,%sp@- <== NOT EXECUTED
599bc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
599be: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
599c4: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
599c8: 2e85 movel %d5,%sp@ <== NOT EXECUTED
handle->dirty = false;
599ca: 4200 clrb %d0 <== NOT EXECUTED
599cc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
599ce: 1d40 ffee moveb %d0,%fp@(-18) <== NOT EXECUTED
handle->bnum = 0;
599d2: 42ae fff0 clrl %fp@(-16) <== NOT EXECUTED
handle->buffer = NULL;
599d6: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
599da: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
599e0: 508f addql #8,%sp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
599e2: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
599e4: 6f0c bles 599f2 <rtems_rfs_symlink+0x22a> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
599e6: 2f04 movel %d4,%sp@- <== NOT EXECUTED
599e8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
599ea: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
599f0: 6028 bras 59a1a <rtems_rfs_symlink+0x252> <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
599f2: 206e ffd4 moveal %fp@(-44),%a0
599f6: 2003 movel %d3,%d0
599f8: e088 lsrl #8,%d0
599fa: 1140 000a moveb %d0,%a0@(10)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
599fe: 7001 moveq #1,%d0
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
59a00: 206e ffd4 moveal %fp@(-44),%a0
59a04: 1143 000b moveb %d3,%a0@(11)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
59a08: 1d40 ffd8 moveb %d0,%fp@(-40)
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
59a0c: 486e ffc8 pea %fp@(-56)
59a10: 2f0a movel %a2,%sp@-
59a12: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
59a18: 2400 movel %d0,%d2
return rc;
59a1a: 508f addql #8,%sp
59a1c: 6002 bras 59a20 <rtems_rfs_symlink+0x258>
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
return ENAMETOOLONG;
59a1e: 745b moveq #91,%d2 <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
59a20: 2002 movel %d2,%d0
59a22: 4cee 3cfc ff54 moveml %fp@(-172),%d2-%d7/%a2-%a5
59a28: 4e5e unlk %fp <== NOT EXECUTED
00059a2c <rtems_rfs_symlink_read>:
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
59a2c: 4e56 ff64 linkw %fp,#-156
59a30: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
59a34: 42a7 clrl %sp@-
59a36: 4878 0004 pea 4 <CONTEXT_ARG>
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
59a3a: 242e 0008 movel %fp@(8),%d2
59a3e: 262e 000c movel %fp@(12),%d3
59a42: 266e 0010 moveal %fp@(16),%a3
59a46: 286e 0018 moveal %fp@(24),%a4
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
59a4a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
59a50: 508f addql #8,%sp
59a52: 4a00 tstb %d0
59a54: 6710 beqs 59a66 <rtems_rfs_symlink_read+0x3a> <== ALWAYS TAKEN
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
59a56: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59a58: 4879 0006 db0f pea 6db0f <CSWTCH.1+0x1455> <== NOT EXECUTED
59a5e: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
59a64: 508f addql #8,%sp <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
59a66: 4878 0001 pea 1 <ADD>
59a6a: 45ee ffcc lea %fp@(-52),%a2
59a6e: 2f0a movel %a2,%sp@-
59a70: 2f03 movel %d3,%sp@-
59a72: 2f02 movel %d2,%sp@-
59a74: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc)
59a7a: 4fef 0010 lea %sp@(16),%sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
59a7e: 2600 movel %d0,%d3
if (rc)
59a80: 6600 0178 bnew 59bfa <rtems_rfs_symlink_read+0x1ce>
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
59a84: 206a 000c moveal %a2@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
59a88: 4280 clrl %d0
59a8a: 1028 0002 moveb %a0@(2),%d0
59a8e: e188 lsll #8,%d0
59a90: 0280 0000 f000 andil #61440,%d0
59a96: 0c80 0000 a000 cmpil #40960,%d0
59a9c: 6714 beqs 59ab2 <rtems_rfs_symlink_read+0x86> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
59a9e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
return EINVAL;
59aa0: 163c 0016 moveb #22,%d3 <== NOT EXECUTED
if (rc)
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
59aa4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59aa6: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
return EINVAL;
59aac: 508f addql #8,%sp <== NOT EXECUTED
59aae: 6000 014a braw 59bfa <rtems_rfs_symlink_read+0x1ce> <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
59ab2: 4281 clrl %d1
59ab4: 1228 000a moveb %a0@(10),%d1
59ab8: 4280 clrl %d0
59aba: 1028 000b moveb %a0@(11),%d0
59abe: e189 lsll #8,%d1
}
*length = rtems_rfs_inode_get_block_offset (&inode);
59ac0: 8280 orl %d0,%d1
59ac2: 2881 movel %d1,%a4@
if (size < *length)
59ac4: b2ae 0014 cmpl %fp@(20),%d1
59ac8: 6312 blss 59adc <rtems_rfs_symlink_read+0xb0>
{
rtems_rfs_inode_close (fs, &inode);
59aca: 2f0a movel %a2,%sp@-
return EINVAL;
59acc: 7616 moveq #22,%d3
*length = rtems_rfs_inode_get_block_offset (&inode);
if (size < *length)
{
rtems_rfs_inode_close (fs, &inode);
59ace: 2f02 movel %d2,%sp@-
59ad0: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
return EINVAL;
59ad6: 508f addql #8,%sp
59ad8: 6000 0120 braw 59bfa <rtems_rfs_symlink_read+0x1ce>
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
59adc: 4280 clrl %d0
59ade: 1028 000c moveb %a0@(12),%d0
59ae2: 7618 moveq #24,%d3
59ae4: e7a8 lsll %d3,%d0
59ae6: 4283 clrl %d3
59ae8: 1628 000d moveb %a0@(13),%d3
59aec: 4843 swap %d3
59aee: 4243 clrw %d3
59af0: 8083 orl %d3,%d0
59af2: 4283 clrl %d3
59af4: 1628 000f moveb %a0@(15),%d3
59af8: 8083 orl %d3,%d0
59afa: 1628 000e moveb %a0@(14),%d3
59afe: e18b lsll #8,%d3
59b00: 8083 orl %d3,%d0
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
59b02: 6616 bnes 59b1a <rtems_rfs_symlink_read+0xee> <== NEVER TAKEN
{
memcpy (path, inode.node->data.name, *length);
59b04: 2f01 movel %d1,%sp@-
59b06: 4868 001c pea %a0@(28)
59b0a: 2f0b movel %a3,%sp@-
59b0c: 4eb9 0005 bf8c jsr 5bf8c <memcpy>
59b12: 4fef 000c lea %sp@(12),%sp
59b16: 6000 00ca braw 59be2 <rtems_rfs_symlink_read+0x1b6>
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
59b1a: 280e movel %fp,%d4 <== NOT EXECUTED
59b1c: 0684 ffff ff82 addil #-126,%d4 <== NOT EXECUTED
59b22: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59b24: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59b26: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59b28: 4eb9 0005 59da jsr 559da <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
59b2e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
59b32: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
59b34: 6e00 00a0 bgtw 59bd6 <rtems_rfs_symlink_read+0x1aa> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
59b38: 486e fffc pea %fp@(-4) <== NOT EXECUTED
59b3c: 42a7 clrl %sp@- <== NOT EXECUTED
59b3e: 42a7 clrl %sp@- <== NOT EXECUTED
59b40: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59b42: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59b44: 4eb9 0005 5e06 jsr 55e06 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
59b4a: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
59b4e: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
59b50: 6e2e bgts 59b80 <rtems_rfs_symlink_read+0x154> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
59b52: 42a7 clrl %sp@- <== NOT EXECUTED
59b54: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
59b58: 2a0e movel %fp,%d5 <== NOT EXECUTED
59b5a: 0685 ffff fff2 addil #-14,%d5 <== NOT EXECUTED
59b60: 2f05 movel %d5,%sp@- <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
59b62: 4200 clrb %d0 <== NOT EXECUTED
59b64: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59b66: 1d40 fff2 moveb %d0,%fp@(-14) <== NOT EXECUTED
handle->bnum = 0;
59b6a: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
handle->buffer = NULL;
59b6e: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
59b72: 4eb9 0005 66f8 jsr 566f8 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
59b78: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
59b7c: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
59b7e: 6f1a bles 59b9a <rtems_rfs_symlink_read+0x16e> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
59b80: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59b82: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59b84: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
59b8a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59b8c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59b8e: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
59b94: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
59b98: 6060 bras 59bfa <rtems_rfs_symlink_read+0x1ce> <== NOT EXECUTED
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
59b9a: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
59b9c: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
59ba0: 2f28 001e movel %a0@(30),%sp@- <== NOT EXECUTED
59ba4: 2f0b movel %a3,%sp@- <== NOT EXECUTED
59ba6: 4eb9 0005 bf8c jsr 5bf8c <memcpy> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
59bac: 2f05 movel %d5,%sp@- <== NOT EXECUTED
59bae: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59bb0: 4eb9 0005 6580 jsr 56580 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
59bb6: 4201 clrb %d1 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
59bb8: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59bba: 1d41 fff2 moveb %d1,%fp@(-14) <== NOT EXECUTED
59bbe: 2f02 movel %d2,%sp@- <== NOT EXECUTED
handle->bnum = 0;
59bc0: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
handle->buffer = NULL;
59bc4: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
59bc8: 4eb9 0005 5b60 jsr 55b60 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
59bce: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
59bd2: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
59bd4: 6f0c bles 59be2 <rtems_rfs_symlink_read+0x1b6> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
59bd6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59bd8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59bda: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
59be0: 6016 bras 59bf8 <rtems_rfs_symlink_read+0x1cc> <== NOT EXECUTED
return rc;
}
}
path[*length] = '\0';
59be2: 2014 movel %a4@,%d0
59be4: 4203 clrb %d3
59be6: 1783 0800 moveb %d3,%a3@(00000000,%d0:l)
rc = rtems_rfs_inode_close (fs, &inode);
59bea: 486e ffcc pea %fp@(-52)
59bee: 2f02 movel %d2,%sp@-
59bf0: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close>
59bf6: 2600 movel %d0,%d3
return rc;
59bf8: 508f addql #8,%sp
}
59bfa: 2003 movel %d3,%d0
59bfc: 4cee 1c3c ff64 moveml %fp@(-156),%d2-%d5/%a2-%a4
59c02: 4e5e unlk %fp
...
0004f63e <rtems_rfs_trace_clear_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
4f63e: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
4f642: 2239 0006 f7a0 movel 6f7a0 <rtems_rfs_trace_flags+0x4>,%d1 <== NOT EXECUTED
return state;
}
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
4f648: 2f03 movel %d3,%sp@- <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
4f64a: 262e 0008 movel %fp@(8),%d3 <== NOT EXECUTED
4f64e: 4683 notl %d3 <== NOT EXECUTED
return state;
}
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
4f650: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
4f652: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
4f656: 4682 notl %d2 <== NOT EXECUTED
}
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
4f658: 2039 0006 f79c movel 6f79c <rtems_rfs_trace_flags>,%d0 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
4f65e: c481 andl %d1,%d2 <== NOT EXECUTED
4f660: c680 andl %d0,%d3 <== NOT EXECUTED
4f662: 23c2 0006 f7a0 movel %d2,6f7a0 <rtems_rfs_trace_flags+0x4> <== NOT EXECUTED
return state;
}
4f668: 241f movel %sp@+,%d2 <== NOT EXECUTED
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
4f66a: 23c3 0006 f79c movel %d3,6f79c <rtems_rfs_trace_flags> <== NOT EXECUTED
return state;
}
4f670: 261f movel %sp@+,%d3 <== NOT EXECUTED
4f672: 4e5e unlk %fp <== NOT EXECUTED
0004f60e <rtems_rfs_trace_set_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
4f60e: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
4f612: 2039 0006 f79c movel 6f79c <rtems_rfs_trace_flags>,%d0 <== NOT EXECUTED
return result;
}
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
4f618: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags |= mask;
4f61a: 242e 0008 movel %fp@(8),%d2 <== NOT EXECUTED
4f61e: 8480 orl %d0,%d2 <== NOT EXECUTED
}
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
4f620: 2239 0006 f7a0 movel 6f7a0 <rtems_rfs_trace_flags+0x4>,%d1 <== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
4f626: 23c2 0006 f79c movel %d2,6f79c <rtems_rfs_trace_flags> <== NOT EXECUTED
4f62c: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
4f630: 8481 orl %d1,%d2 <== NOT EXECUTED
4f632: 23c2 0006 f7a0 movel %d2,6f7a0 <rtems_rfs_trace_flags+0x4> <== NOT EXECUTED
return state;
}
4f638: 241f movel %sp@+,%d2 <== NOT EXECUTED
4f63a: 4e5e unlk %fp <== NOT EXECUTED
0004f676 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
4f676: 4e56 ff30 linkw %fp,#-208 <== NOT EXECUTED
4f67a: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
const char* table[] =
4f67e: 4878 0098 pea 98 <DBL_MANT_DIG+0x63> <== NOT EXECUTED
4f682: 240e movel %fp,%d2 <== NOT EXECUTED
4f684: 4879 0006 c30a pea 6c30a <rtems_rfs_rtems_link_handlers+0x292><== NOT EXECUTED
4f68a: 0682 ffff ff68 addil #-152,%d2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f690: 7801 moveq #1,%d4 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
4f692: 47f9 0005 c7f8 lea 5c7f8 <strcmp>,%a3 <== NOT EXECUTED
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
set_value = 1 << t;
else
clear_value = 1 << t;
4f698: 7a01 moveq #1,%d5 <== NOT EXECUTED
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
4f69a: 2c2e 000c movel %fp@(12),%d6 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
4f69e: 2846 moveal %d6,%a4 <== NOT EXECUTED
4f6a0: 588c addql #4,%a4 <== NOT EXECUTED
{
const char* table[] =
4f6a2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
4f6a4: 7601 moveq #1,%d3 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
4f6a6: 4eb9 0005 bf8c jsr 5bf8c <memcpy> <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f6ac: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
"file-close",
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
4f6b0: 4280 clrl %d0 <== NOT EXECUTED
4f6b2: 4281 clrl %d1 <== NOT EXECUTED
4f6b4: 2d40 ff58 movel %d0,%fp@(-168) <== NOT EXECUTED
4f6b8: 2d41 ff5c movel %d1,%fp@(-164) <== NOT EXECUTED
"file-open",
"file-close",
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
4f6bc: 2d40 ff60 movel %d0,%fp@(-160) <== NOT EXECUTED
4f6c0: 2d41 ff64 movel %d1,%fp@(-156) <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f6c4: 6000 0142 braw 4f808 <rtems_rfs_trace_shell_command+0x192><== NOT EXECUTED
{
if (argv[arg][0] == '-')
4f6c8: 245c moveal %a4@+,%a2 <== NOT EXECUTED
4f6ca: 722d moveq #45,%d1 <== NOT EXECUTED
4f6cc: 1012 moveb %a2@,%d0 <== NOT EXECUTED
4f6ce: 49c0 extbl %d0 <== NOT EXECUTED
4f6d0: b280 cmpl %d0,%d1 <== NOT EXECUTED
4f6d2: 6670 bnes 4f744 <rtems_rfs_trace_shell_command+0xce><== NOT EXECUTED
{
switch (argv[arg][1])
4f6d4: 123c 0068 moveb #104,%d1 <== NOT EXECUTED
4f6d8: 102a 0001 moveb %a2@(1),%d0 <== NOT EXECUTED
4f6dc: 49c0 extbl %d0 <== NOT EXECUTED
4f6de: b280 cmpl %d0,%d1 <== NOT EXECUTED
4f6e0: 670a beqs 4f6ec <rtems_rfs_trace_shell_command+0x76><== NOT EXECUTED
4f6e2: 123c 006c moveb #108,%d1 <== NOT EXECUTED
4f6e6: b280 cmpl %d0,%d1 <== NOT EXECUTED
4f6e8: 6646 bnes 4f730 <rtems_rfs_trace_shell_command+0xba><== NOT EXECUTED
4f6ea: 6016 bras 4f702 <rtems_rfs_trace_shell_command+0x8c><== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
4f6ec: 2046 moveal %d6,%a0 <== NOT EXECUTED
4f6ee: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4f6f0: 4879 0006 c0d4 pea 6c0d4 <rtems_rfs_rtems_link_handlers+0x5c><== NOT EXECUTED
4f6f6: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
return 0;
4f6fc: 508f addql #8,%sp <== NOT EXECUTED
4f6fe: 6000 0110 braw 4f810 <rtems_rfs_trace_shell_command+0x19a><== NOT EXECUTED
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
4f702: 2046 moveal %d6,%a0 <== NOT EXECUTED
4f704: 47f9 0005 c170 lea 5c170 <printf>,%a3 <== NOT EXECUTED
4f70a: 45ee ff68 lea %fp@(-152),%a2 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
4f70e: 240e movel %fp,%d2 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
4f710: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4f712: 4879 0006 c0f9 pea 6c0f9 <rtems_rfs_rtems_link_handlers+0x81><== NOT EXECUTED
4f718: 4e93 jsr %a3@ <== NOT EXECUTED
4f71a: 600a bras 4f726 <rtems_rfs_trace_shell_command+0xb0><== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
4f71c: 2f1a movel %a2@+,%sp@- <== NOT EXECUTED
4f71e: 4879 0006 c11f pea 6c11f <rtems_rfs_rtems_link_handlers+0xa7><== NOT EXECUTED
4f724: 4e93 jsr %a3@ <== NOT EXECUTED
4f726: 508f addql #8,%sp <== NOT EXECUTED
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
4f728: b48a cmpl %a2,%d2 <== NOT EXECUTED
4f72a: 66f0 bnes 4f71c <rtems_rfs_trace_shell_command+0xa6><== NOT EXECUTED
4f72c: 6000 00e2 braw 4f810 <rtems_rfs_trace_shell_command+0x19a><== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
4f730: 4879 0006 c125 pea 6c125 <rtems_rfs_rtems_link_handlers+0xad><== NOT EXECUTED
4f736: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
return 1;
4f73c: 588f addql #4,%sp <== NOT EXECUTED
4f73e: 7001 moveq #1,%d0 <== NOT EXECUTED
4f740: 6000 00d0 braw 4f812 <rtems_rfs_trace_shell_command+0x19c><== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
4f744: 4879 0006 aa9e pea 6aa9e <rtems_filesystem_table+0x4dc> <== NOT EXECUTED
4f74a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f74c: 4e93 jsr %a3@ <== NOT EXECUTED
4f74e: 508f addql #8,%sp <== NOT EXECUTED
4f750: 4a80 tstl %d0 <== NOT EXECUTED
4f752: 6602 bnes 4f756 <rtems_rfs_trace_shell_command+0xe0><== NOT EXECUTED
set = true;
4f754: 7601 moveq #1,%d3 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
4f756: 4879 0006 c13b pea 6c13b <rtems_rfs_rtems_link_handlers+0xc3><== NOT EXECUTED
4f75c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f75e: 4e93 jsr %a3@ <== NOT EXECUTED
4f760: 508f addql #8,%sp <== NOT EXECUTED
4f762: 4a80 tstl %d0 <== NOT EXECUTED
4f764: 6764 beqs 4f7ca <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
4f766: 4879 0006 de28 pea 6de28 <_global_impure_ptr+0x54> <== NOT EXECUTED
4f76c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f76e: 4e93 jsr %a3@ <== NOT EXECUTED
4f770: 508f addql #8,%sp <== NOT EXECUTED
4f772: 4a80 tstl %d0 <== NOT EXECUTED
4f774: 6708 beqs 4f77e <rtems_rfs_trace_shell_command+0x108><== NOT EXECUTED
4f776: 4bee ff68 lea %fp@(-152),%a5 <== NOT EXECUTED
4f77a: 4282 clrl %d2 <== NOT EXECUTED
4f77c: 6012 bras 4f790 <rtems_rfs_trace_shell_command+0x11a><== NOT EXECUTED
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
4f77e: 70ff moveq #-1,%d0 <== NOT EXECUTED
4f780: 72ff moveq #-1,%d1 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
4f782: 4a03 tstb %d3 <== NOT EXECUTED
4f784: 6748 beqs 4f7ce <rtems_rfs_trace_shell_command+0x158><== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
4f786: 2d40 ff60 movel %d0,%fp@(-160) <== NOT EXECUTED
4f78a: 2d41 ff64 movel %d1,%fp@(-156) <== NOT EXECUTED
4f78e: 6046 bras 4f7d6 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
4f790: 2f1d movel %a5@+,%sp@- <== NOT EXECUTED
4f792: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f794: 4e93 jsr %a3@ <== NOT EXECUTED
4f796: 508f addql #8,%sp <== NOT EXECUTED
4f798: 4a80 tstl %d0 <== NOT EXECUTED
4f79a: 6624 bnes 4f7c0 <rtems_rfs_trace_shell_command+0x14a><== NOT EXECUTED
{
if (set)
set_value = 1 << t;
4f79c: 2005 movel %d5,%d0 <== NOT EXECUTED
4f79e: e5a8 lsll %d2,%d0 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
4f7a0: 4a03 tstb %d3 <== NOT EXECUTED
4f7a2: 670e beqs 4f7b2 <rtems_rfs_trace_shell_command+0x13c><== NOT EXECUTED
set_value = 1 << t;
4f7a4: 2d40 ff64 movel %d0,%fp@(-156) <== NOT EXECUTED
4f7a8: 5bc1 smi %d1 <== NOT EXECUTED
4f7aa: 49c1 extbl %d1 <== NOT EXECUTED
4f7ac: 2d41 ff60 movel %d1,%fp@(-160) <== NOT EXECUTED
4f7b0: 6024 bras 4f7d6 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
else
clear_value = 1 << t;
4f7b2: 2d40 ff5c movel %d0,%fp@(-164) <== NOT EXECUTED
4f7b6: 5bc1 smi %d1 <== NOT EXECUTED
4f7b8: 49c1 extbl %d1 <== NOT EXECUTED
4f7ba: 2d41 ff58 movel %d1,%fp@(-168) <== NOT EXECUTED
4f7be: 6016 bras 4f7d6 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
4f7c0: 5282 addql #1,%d2 <== NOT EXECUTED
4f7c2: 7026 moveq #38,%d0 <== NOT EXECUTED
4f7c4: b082 cmpl %d2,%d0 <== NOT EXECUTED
4f7c6: 66c8 bnes 4f790 <rtems_rfs_trace_shell_command+0x11a><== NOT EXECUTED
4f7c8: 600c bras 4f7d6 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
4f7ca: 4203 clrb %d3 <== NOT EXECUTED
4f7cc: 6008 bras 4f7d6 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
4f7ce: 2d40 ff58 movel %d0,%fp@(-168) <== NOT EXECUTED
4f7d2: 2d41 ff5c movel %d1,%fp@(-164) <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
4f7d6: 242e ff60 movel %fp@(-160),%d2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f7da: 5284 addql #1,%d4 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
4f7dc: 202e ff64 movel %fp@(-156),%d0 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
4f7e0: 2e2e ff58 movel %fp@(-168),%d7 <== NOT EXECUTED
4f7e4: 4687 notl %d7 <== NOT EXECUTED
4f7e6: 222e ff5c movel %fp@(-164),%d1 <== NOT EXECUTED
4f7ea: 4681 notl %d1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
4f7ec: 84b9 0006 f79c orl 6f79c <rtems_rfs_trace_flags>,%d2 <== NOT EXECUTED
4f7f2: 80b9 0006 f7a0 orl 6f7a0 <rtems_rfs_trace_flags+0x4>,%d0 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
4f7f8: ce82 andl %d2,%d7 <== NOT EXECUTED
4f7fa: c280 andl %d0,%d1 <== NOT EXECUTED
4f7fc: 23c7 0006 f79c movel %d7,6f79c <rtems_rfs_trace_flags> <== NOT EXECUTED
4f802: 23c1 0006 f7a0 movel %d1,6f7a0 <rtems_rfs_trace_flags+0x4> <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f808: b8ae 0008 cmpl %fp@(8),%d4 <== NOT EXECUTED
4f80c: 6d00 feba bltw 4f6c8 <rtems_rfs_trace_shell_command+0x52><== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
4f810: 4280 clrl %d0 <== NOT EXECUTED
}
4f812: 4cee 3cfc ff30 moveml %fp@(-208),%d2-%d7/%a2-%a5 <== NOT EXECUTED
4f818: 4e5e unlk %fp <== NOT EXECUTED
00059442 <rtems_rfs_unlink>:
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
59442: 4e56 ff98 linkw %fp,#-104
59446: 48d7 04fc moveml %d2-%d7/%a2,%sp@
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
5944a: 2f3c 0200 0000 movel #33554432,%sp@-
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
59450: 262e 0008 movel %fp@(8),%d3
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
59454: 42a7 clrl %sp@-
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
59456: 2c2e 000c movel %fp@(12),%d6
5945a: 282e 0010 movel %fp@(16),%d4
5945e: 2e2e 0018 movel %fp@(24),%d7
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
59462: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
59468: 508f addql #8,%sp
5946a: 4a00 tstb %d0
5946c: 6714 beqs 59482 <rtems_rfs_unlink+0x40> <== ALWAYS TAKEN
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
5946e: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59470: 2f06 movel %d6,%sp@- <== NOT EXECUTED
59472: 4879 0006 d935 pea 6d935 <CSWTCH.1+0x127b> <== NOT EXECUTED
59478: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5947e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
59482: 4878 0001 pea 1 <ADD>
59486: 45ee ffda lea %fp@(-38),%a2
5948a: 2f0a movel %a2,%sp@-
5948c: 2f04 movel %d4,%sp@-
5948e: 2f03 movel %d3,%sp@-
59490: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc)
59496: 4fef 0010 lea %sp@(16),%sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
5949a: 2400 movel %d0,%d2
if (rc)
5949c: 6600 031e bnew 597bc <rtems_rfs_unlink+0x37a>
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
594a0: 206a 000c moveal %a2@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
594a4: 4280 clrl %d0
594a6: 1028 0002 moveb %a0@(2),%d0
594aa: e188 lsll #8,%d0
594ac: 0280 0000 f000 andil #61440,%d0
594b2: 0c80 0000 4000 cmpil #16384,%d0
594b8: 57c5 seq %d5
594ba: 4485 negl %d5
if (dir)
594bc: 4a05 tstb %d5
594be: 677e beqs 5953e <rtems_rfs_unlink+0xfc> <== ALWAYS TAKEN
{
switch (dir_mode)
594c0: 4a87 tstl %d7 <== NOT EXECUTED
594c2: 6708 beqs 594cc <rtems_rfs_unlink+0x8a> <== NOT EXECUTED
594c4: 7001 moveq #1,%d0 <== NOT EXECUTED
594c6: b087 cmpl %d7,%d0 <== NOT EXECUTED
594c8: 6674 bnes 5953e <rtems_rfs_unlink+0xfc> <== NOT EXECUTED
594ca: 6036 bras 59502 <rtems_rfs_unlink+0xc0> <== NOT EXECUTED
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
594cc: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
594d2: 42a7 clrl %sp@- <== NOT EXECUTED
594d4: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
594da: 508f addql #8,%sp <== NOT EXECUTED
594dc: 4a00 tstb %d0 <== NOT EXECUTED
594de: 670e beqs 594ee <rtems_rfs_unlink+0xac> <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
594e0: 4879 0006 d960 pea 6d960 <CSWTCH.1+0x12a6> <== NOT EXECUTED
594e6: 4eb9 0005 c26a jsr 5c26a <puts> <== NOT EXECUTED
594ec: 588f addql #4,%sp <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
594ee: 486e ffda pea %fp@(-38) <== NOT EXECUTED
return EISDIR;
594f2: 7415 moveq #21,%d2 <== NOT EXECUTED
switch (dir_mode)
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
594f4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
594f6: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
return EISDIR;
594fc: 508f addql #8,%sp <== NOT EXECUTED
594fe: 6000 02bc braw 597bc <rtems_rfs_unlink+0x37a> <== NOT EXECUTED
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
59502: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59504: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59506: 4eb9 0005 7b5a jsr 57b5a <rtems_rfs_dir_empty> <== NOT EXECUTED
if (rc > 0)
5950c: 508f addql #8,%sp <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
5950e: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
59510: 6f2c bles 5953e <rtems_rfs_unlink+0xfc> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
59512: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
59518: 42a7 clrl %sp@- <== NOT EXECUTED
5951a: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
59520: 508f addql #8,%sp <== NOT EXECUTED
59522: 4a00 tstb %d0 <== NOT EXECUTED
59524: 6700 0248 beqw 5976e <rtems_rfs_unlink+0x32c> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
59528: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5952a: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
59530: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59532: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59534: 4879 0006 d97f pea 6d97f <CSWTCH.1+0x12c5> <== NOT EXECUTED
5953a: 6000 0228 braw 59764 <rtems_rfs_unlink+0x322> <== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
5953e: 4878 0001 pea 1 <ADD>
59542: 45ee ffb4 lea %fp@(-76),%a2
59546: 2f0a movel %a2,%sp@-
59548: 2f06 movel %d6,%sp@-
5954a: 2f03 movel %d3,%sp@-
5954c: 4eb9 0004 d7d0 jsr 4d7d0 <rtems_rfs_inode_open>
if (rc)
59552: 4fef 0010 lea %sp@(16),%sp
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
59556: 2400 movel %d0,%d2
if (rc)
59558: 672c beqs 59586 <rtems_rfs_unlink+0x144> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
5955a: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
59560: 42a7 clrl %sp@- <== NOT EXECUTED
59562: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
59568: 508f addql #8,%sp <== NOT EXECUTED
5956a: 4a00 tstb %d0 <== NOT EXECUTED
5956c: 6700 0200 beqw 5976e <rtems_rfs_unlink+0x32c> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
59570: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59572: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
59578: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5957a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5957c: 4879 0006 d99d pea 6d99d <CSWTCH.1+0x12e3> <== NOT EXECUTED
59582: 6000 01e0 braw 59764 <rtems_rfs_unlink+0x322> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
59586: 2f2e 0014 movel %fp@(20),%sp@-
5958a: 2f04 movel %d4,%sp@-
5958c: 2f0a movel %a2,%sp@-
5958e: 2f03 movel %d3,%sp@-
59590: 4eb9 0005 74b2 jsr 574b2 <rtems_rfs_dir_del_entry>
if (rc > 0)
59596: 4fef 0010 lea %sp@(16),%sp
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
5959a: 2400 movel %d0,%d2
if (rc > 0)
5959c: 6f2c bles 595ca <rtems_rfs_unlink+0x188> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
5959e: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
595a4: 42a7 clrl %sp@- <== NOT EXECUTED
595a6: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
595ac: 508f addql #8,%sp <== NOT EXECUTED
595ae: 4a00 tstb %d0 <== NOT EXECUTED
595b0: 6700 0160 beqw 59712 <rtems_rfs_unlink+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
595b4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
595b6: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
595bc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
595be: 2f02 movel %d2,%sp@- <== NOT EXECUTED
595c0: 4879 0006 d9c9 pea 6d9c9 <CSWTCH.1+0x130f> <== NOT EXECUTED
595c6: 6000 0140 braw 59708 <rtems_rfs_unlink+0x2c6> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
595ca: 206e ffe6 moveal %fp@(-26),%a0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
595ce: 4280 clrl %d0
595d0: 1010 moveb %a0@,%d0
595d2: 4282 clrl %d2
595d4: 1428 0001 moveb %a0@(1),%d2
595d8: e188 lsll #8,%d0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
595da: 2f3c 0200 0000 movel #33554432,%sp@-
595e0: 8480 orl %d0,%d2
if (links == 0xffff)
595e2: 4280 clrl %d0
595e4: 3002 movew %d2,%d0
595e6: 42a7 clrl %sp@-
links = 0;
595e8: 0c80 0000 ffff cmpil #65535,%d0
595ee: 56c0 sne %d0
595f0: 4880 extw %d0
595f2: c480 andl %d0,%d2
595f4: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace>
595fa: 508f addql #8,%sp
595fc: 4a00 tstb %d0
595fe: 6716 beqs 59616 <rtems_rfs_unlink+0x1d4> <== ALWAYS TAKEN
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
59600: 3f02 movew %d2,%sp@- <== NOT EXECUTED
59602: 4267 clrw %sp@- <== NOT EXECUTED
59604: 2f04 movel %d4,%sp@- <== NOT EXECUTED
59606: 4879 0006 d9f4 pea 6d9f4 <CSWTCH.1+0x133a> <== NOT EXECUTED
5960c: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
59612: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
if (links > 1)
59616: 4280 clrl %d0
59618: 7201 moveq #1,%d1
5961a: 3002 movew %d2,%d0
5961c: b280 cmpl %d0,%d1
5961e: 641e bccs 5963e <rtems_rfs_unlink+0x1fc>
{
links--;
59620: 5382 subql #1,%d2
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
59622: 2002 movel %d2,%d0
59624: e088 lsrl #8,%d0
59626: 206e ffe6 moveal %fp@(-26),%a0
5962a: 1080 moveb %d0,%a0@
rtems_rfs_buffer_mark_dirty (&handle->buffer);
5962c: 7801 moveq #1,%d4
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
5962e: 206e ffe6 moveal %fp@(-26),%a0
59632: 1142 0001 moveb %d2,%a0@(1)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
59636: 1d44 ffea moveb %d4,%fp@(-22)
5963a: 6000 0086 braw 596c2 <rtems_rfs_unlink+0x280>
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
5963e: 486e ffda pea %fp@(-38)
59642: 2f03 movel %d3,%sp@-
59644: 4eb9 0004 d9e8 jsr 4d9e8 <rtems_rfs_inode_delete>
if (rc > 0)
5964a: 508f addql #8,%sp
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
5964c: 2400 movel %d0,%d2
if (rc > 0)
5964e: 6f2c bles 5967c <rtems_rfs_unlink+0x23a> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
59650: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
59656: 42a7 clrl %sp@- <== NOT EXECUTED
59658: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5965e: 508f addql #8,%sp <== NOT EXECUTED
59660: 4a00 tstb %d0 <== NOT EXECUTED
59662: 6700 00ae beqw 59712 <rtems_rfs_unlink+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
59666: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59668: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
5966e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59670: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59672: 4879 0006 da1c pea 6da1c <CSWTCH.1+0x1362> <== NOT EXECUTED
59678: 6000 008e braw 59708 <rtems_rfs_unlink+0x2c6> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
5967c: 4a05 tstb %d5
5967e: 6742 beqs 596c2 <rtems_rfs_unlink+0x280> <== ALWAYS TAKEN
{
links = rtems_rfs_inode_get_links (&parent_inode);
59680: 206e ffc0 moveal %fp@(-64),%a0 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
59684: 4280 clrl %d0 <== NOT EXECUTED
59686: 1010 moveb %a0@,%d0 <== NOT EXECUTED
59688: 4281 clrl %d1 <== NOT EXECUTED
5968a: 1228 0001 moveb %a0@(1),%d1 <== NOT EXECUTED
if (links == 0xffff)
5968e: 4282 clrl %d2 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
59690: e188 lsll #8,%d0 <== NOT EXECUTED
59692: 8081 orl %d1,%d0 <== NOT EXECUTED
if (links == 0xffff)
59694: 3400 movew %d0,%d2 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
59696: 3200 movew %d0,%d1 <== NOT EXECUTED
if (links == 0xffff)
59698: 0c82 0000 ffff cmpil #65535,%d2 <== NOT EXECUTED
5969e: 670c beqs 596ac <rtems_rfs_unlink+0x26a> <== NOT EXECUTED
if (links > 1)
596a0: 7801 moveq #1,%d4 <== NOT EXECUTED
596a2: b882 cmpl %d2,%d4 <== NOT EXECUTED
596a4: 6408 bccs 596ae <rtems_rfs_unlink+0x26c> <== NOT EXECUTED
links--;
596a6: 2200 movel %d0,%d1 <== NOT EXECUTED
596a8: 5381 subql #1,%d1 <== NOT EXECUTED
596aa: 6002 bras 596ae <rtems_rfs_unlink+0x26c> <== NOT EXECUTED
links = 0;
596ac: 4241 clrw %d1 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
596ae: 2001 movel %d1,%d0 <== NOT EXECUTED
596b0: e088 lsrl #8,%d0 <== NOT EXECUTED
596b2: 1080 moveb %d0,%a0@ <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
596b4: 7001 moveq #1,%d0 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
596b6: 206e ffc0 moveal %fp@(-64),%a0 <== NOT EXECUTED
596ba: 1141 0001 moveb %d1,%a0@(1) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
596be: 1d40 ffc4 moveb %d0,%fp@(-60) <== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
596c2: 4878 0001 pea 1 <ADD>
596c6: 280e movel %fp,%d4
596c8: 4878 0001 pea 1 <ADD>
596cc: 0684 ffff ffb4 addil #-76,%d4
596d2: 2f04 movel %d4,%sp@-
596d4: 4eb9 0004 daba jsr 4daba <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
596da: 4fef 000c lea %sp@(12),%sp
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
596de: 2400 movel %d0,%d2
if (rc > 0)
596e0: 6f4a bles 5972c <rtems_rfs_unlink+0x2ea> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
596e2: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
596e8: 42a7 clrl %sp@- <== NOT EXECUTED
596ea: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
596f0: 508f addql #8,%sp <== NOT EXECUTED
596f2: 4a00 tstb %d0 <== NOT EXECUTED
596f4: 671c beqs 59712 <rtems_rfs_unlink+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
596f6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
596f8: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
596fe: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59700: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59702: 4879 0006 da49 pea 6da49 <CSWTCH.1+0x138f> <== NOT EXECUTED
59708: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5970e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
59712: 486e ffb4 pea %fp@(-76) <== NOT EXECUTED
59716: 45f9 0004 d966 lea 4d966 <rtems_rfs_inode_close>,%a2 <== NOT EXECUTED
5971c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5971e: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
59720: 486e ffda pea %fp@(-38) <== NOT EXECUTED
59724: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59726: 4e92 jsr %a2@ <== NOT EXECUTED
59728: 6000 008e braw 597b8 <rtems_rfs_unlink+0x376> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
5972c: 2f04 movel %d4,%sp@-
5972e: 45f9 0004 d966 lea 4d966 <rtems_rfs_inode_close>,%a2
59734: 2f03 movel %d3,%sp@-
59736: 4e92 jsr %a2@
if (rc > 0)
59738: 508f addql #8,%sp
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
5973a: 2400 movel %d0,%d2
if (rc > 0)
5973c: 6f40 bles 5977e <rtems_rfs_unlink+0x33c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
5973e: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
59744: 42a7 clrl %sp@- <== NOT EXECUTED
59746: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5974c: 508f addql #8,%sp <== NOT EXECUTED
5974e: 4a00 tstb %d0 <== NOT EXECUTED
59750: 671c beqs 5976e <rtems_rfs_unlink+0x32c> <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
59752: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59754: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
5975a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5975c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5975e: 4879 0006 da7b pea 6da7b <CSWTCH.1+0x13c1> <== NOT EXECUTED
59764: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
5976a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
5976e: 486e ffda pea %fp@(-38) <== NOT EXECUTED
59772: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59774: 4eb9 0004 d966 jsr 4d966 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
5977a: 508f addql #8,%sp <== NOT EXECUTED
5977c: 603e bras 597bc <rtems_rfs_unlink+0x37a> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
5977e: 486e ffda pea %fp@(-38)
59782: 2f03 movel %d3,%sp@-
59784: 4e92 jsr %a2@
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
59786: 508f addql #8,%sp
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
59788: 2400 movel %d0,%d2
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
5978a: 6f30 bles 597bc <rtems_rfs_unlink+0x37a> <== ALWAYS TAKEN
5978c: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
59792: 42a7 clrl %sp@- <== NOT EXECUTED
59794: 4eb9 0004 f5ec jsr 4f5ec <rtems_rfs_trace> <== NOT EXECUTED
5979a: 508f addql #8,%sp <== NOT EXECUTED
5979c: 4a00 tstb %d0 <== NOT EXECUTED
5979e: 671c beqs 597bc <rtems_rfs_unlink+0x37a> <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
597a0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
597a2: 4eb9 0005 cd90 jsr 5cd90 <strerror> <== NOT EXECUTED
597a8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
597aa: 2f02 movel %d2,%sp@- <== NOT EXECUTED
597ac: 4879 0006 daaf pea 6daaf <CSWTCH.1+0x13f5> <== NOT EXECUTED
597b2: 4eb9 0005 c170 jsr 5c170 <printf> <== NOT EXECUTED
597b8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
597bc: 2002 movel %d2,%d0
597be: 4cee 04fc ff98 moveml %fp@(-104),%d2-%d7/%a2
597c4: 4e5e unlk %fp <== NOT EXECUTED
00046030 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
46030: 7003 moveq #3,%d0
*/
void rtems_shutdown_executive(
uint32_t result
)
{
46032: 4e56 0000 linkw %fp,#0
if ( _System_state_Is_up( _System_state_Get() ) ) {
46036: b0b9 0005 ecdc cmpl 5ecdc <_System_state_Current>,%d0
4603c: 6624 bnes 46062 <rtems_shutdown_executive+0x32>
#if defined(RTEMS_SMP)
_SMP_Request_other_cores_to_shutdown();
#endif
_Per_CPU_Information[0].idle->Wait.return_code = result;
4603e: 2079 0005 f002 moveal 5f002 <_Per_CPU_Information+0x14>,%a0
46044: 103c 0004 moveb #4,%d0
46048: 216e 0008 0034 movel %fp@(8),%a0@(52)
* if we were running within the same context, it would work.
*
* And we will not return to this thread, so there is no point of
* saving the context.
*/
_Context_Restart_self( &_Thread_BSP_context );
4604e: 4879 0005 eb64 pea 5eb64 <_Thread_BSP_context>
46054: 23c0 0005 ecdc movel %d0,5ecdc <_System_state_Current>
4605a: 4eb9 0004 8c92 jsr 48c92 <_CPU_Context_Restart_self>
46060: 588f addql #4,%sp <== NOT EXECUTED
****** AND THEN TO BOOT_CARD() ******
*******************************************************************
*******************************************************************
*******************************************************************/
}
_Internal_error_Occurred(
46062: 4878 0014 pea 14 <OPER2>
46066: 4878 0001 pea 1 <ADD>
4606a: 42a7 clrl %sp@-
4606c: 4eb9 0004 6bdc jsr 46bdc <_Internal_error_Occurred>
...
00050b0c <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
50b0c: 4e56 fffc linkw %fp,#-4
50b10: 2f03 movel %d3,%sp@-
50b12: 2f02 movel %d2,%sp@-
50b14: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
50b18: 6776 beqs 50b90 <rtems_signal_send+0x84>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
50b1a: 486e fffc pea %fp@(-4)
50b1e: 2f2e 0008 movel %fp@(8),%sp@-
50b22: 4eb9 0005 4adc jsr 54adc <_Thread_Get>
switch ( location ) {
50b28: 508f addql #8,%sp
50b2a: 4aae fffc tstl %fp@(-4)
50b2e: 6664 bnes 50b94 <rtems_signal_send+0x88>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
50b30: 2240 moveal %d0,%a1
50b32: 2069 00fe moveal %a1@(254),%a0
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
50b36: 4aa8 000a tstl %a0@(10)
50b3a: 674a beqs 50b86 <rtems_signal_send+0x7a>
50b3c: 223c 0000 0700 movel #1792,%d1
if ( asr->is_enabled ) {
50b42: 4a28 0008 tstb %a0@(8)
50b46: 6726 beqs 50b6e <rtems_signal_send+0x62>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
50b48: 40c3 movew %sr,%d3
50b4a: 8283 orl %d3,%d1
50b4c: 46c1 movew %d1,%sr
*signal_set |= signals;
50b4e: 85a8 0012 orl %d2,%a0@(18)
_ISR_Enable( _level );
50b52: 46c3 movew %d3,%sr
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
50b54: 4ab9 0007 6fa2 tstl 76fa2 <_Per_CPU_Information+0x8>
50b5a: 6720 beqs 50b7c <rtems_signal_send+0x70>
50b5c: b0b9 0007 6fa6 cmpl 76fa6 <_Per_CPU_Information+0xc>,%d0
50b62: 6618 bnes 50b7c <rtems_signal_send+0x70> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
50b64: 7001 moveq #1,%d0
50b66: 13c0 0007 6fb2 moveb %d0,76fb2 <_Per_CPU_Information+0x18>
50b6c: 600e bras 50b7c <rtems_signal_send+0x70>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
50b6e: 2001 movel %d1,%d0
50b70: 40c1 movew %sr,%d1
50b72: 8081 orl %d1,%d0
50b74: 46c0 movew %d0,%sr
*signal_set |= signals;
50b76: 85a8 0016 orl %d2,%a0@(22)
_ISR_Enable( _level );
50b7a: 46c1 movew %d1,%sr
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
50b7c: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
50b82: 4280 clrl %d0
50b84: 6010 bras 50b96 <rtems_signal_send+0x8a>
}
_Thread_Enable_dispatch();
50b86: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
50b8c: 700b moveq #11,%d0
50b8e: 6006 bras 50b96 <rtems_signal_send+0x8a>
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
50b90: 700a moveq #10,%d0
50b92: 6002 bras 50b96 <rtems_signal_send+0x8a>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
50b94: 7004 moveq #4,%d0
}
50b96: 242e fff4 movel %fp@(-12),%d2
50b9a: 262e fff8 movel %fp@(-8),%d3
50b9e: 4e5e unlk %fp
...
00042668 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
42668: 4e56 0000 linkw %fp,#0
4266c: 206e 0008 moveal %fp@(8),%a0
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
42670: 4aa8 0008 tstl %a0@(8)
42674: 671c beqs 42692 <rtems_stack_checker_begin_extension+0x2a><== NEVER TAKEN
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
42676: 4878 0010 pea 10 <INVALID_OPERATION>
4267a: 4879 0006 1214 pea 61214 <Stack_check_Pattern>
42680: 2068 00b6 moveal %a0@(182),%a0
42684: 5088 addql #8,%a0
42686: 2f08 movel %a0,%sp@-
42688: 4eb9 0004 fa64 jsr 4fa64 <memcpy>
4268e: 4fef 000c lea %sp@(12),%sp
}
42692: 4e5e unlk %fp <== NOT EXECUTED
00042634 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
42634: 4e56 0000 linkw %fp,#0
42638: 2f0a movel %a2,%sp@-
4263a: 246e 000c moveal %fp@(12),%a2
Stack_check_Initialize();
4263e: 4eb9 0004 25bc jsr 425bc <Stack_check_Initialize>
if (the_thread)
42644: 4a8a tstl %a2
42646: 6716 beqs 4265e <rtems_stack_checker_create_extension+0x2a><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
42648: 2f2a 00b2 movel %a2@(178),%sp@-
4264c: 4878 00a5 pea a5 <DBL_MANT_DIG+0x70>
42650: 2f2a 00b6 movel %a2@(182),%sp@-
42654: 4eb9 0004 fad4 jsr 4fad4 <memset>
4265a: 4fef 000c lea %sp@(12),%sp
return true;
}
4265e: 246e fffc moveal %fp@(-4),%a2
42662: 4e5e unlk %fp
42664: 7001 moveq #1,%d0 <== NOT EXECUTED
000427a4 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
427a4: 4e56 0000 linkw %fp,#0
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
427a8: 2279 0006 1852 moveal 61852 <_Per_CPU_Information+0xc>,%a1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
427ae: 2069 00b6 moveal %a1@(182),%a0
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
427b2: 2f02 movel %d2,%sp@-
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
427b4: b1ce cmpal %fp,%a0
427b6: 620e bhis 427c6 <rtems_stack_checker_is_blown+0x22><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
427b8: 2008 movel %a0,%d0
427ba: d0a9 00b2 addl %a1@(178),%d0
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
427be: b08e cmpl %fp,%d0
427c0: 54c2 scc %d2
427c2: 4482 negl %d2
427c4: 6002 bras 427c8 <rtems_stack_checker_is_blown+0x24>
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
427c6: 4202 clrb %d2 <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
427c8: 4ab9 0006 0a08 tstl 60a08 <Stack_check_Initialized>
427ce: 6720 beqs 427f0 <rtems_stack_checker_is_blown+0x4c><== NEVER TAKEN
pattern_ok = (!memcmp(
427d0: 4878 0010 pea 10 <INVALID_OPERATION>
427d4: 4879 0006 1214 pea 61214 <Stack_check_Pattern>
427da: 4868 0008 pea %a0@(8)
427de: 4eb9 0004 f9dc jsr 4f9dc <memcmp>
427e4: 4fef 000c lea %sp@(12),%sp
427e8: 4a80 tstl %d0
427ea: 57c0 seq %d0
427ec: 4480 negl %d0
427ee: 6002 bras 427f2 <rtems_stack_checker_is_blown+0x4e>
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
427f0: 7001 moveq #1,%d0 <== NOT EXECUTED
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
427f2: 4a02 tstb %d2
427f4: 6704 beqs 427fa <rtems_stack_checker_is_blown+0x56><== NEVER TAKEN
427f6: 4a00 tstb %d0
427f8: 6614 bnes 4280e <rtems_stack_checker_is_blown+0x6a><== ALWAYS TAKEN
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
427fa: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
42800: 2f00 movel %d0,%sp@- <== NOT EXECUTED
42802: 2f39 0006 1852 movel 61852 <_Per_CPU_Information+0xc>,%sp@-<== NOT EXECUTED
42808: 4eb9 0004 2696 jsr 42696 <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
4280e: 242e fffc movel %fp@(-4),%d2
42812: 4e5e unlk %fp
42814: 4200 clrb %d0 <== NOT EXECUTED
0004287e <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
4287e: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
42882: 4879 0004 439c pea 4439c <printk_plugin> <== NOT EXECUTED
42888: 42a7 clrl %sp@- <== NOT EXECUTED
4288a: 4eb9 0004 2818 jsr 42818 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
42890: 508f addql #8,%sp <== NOT EXECUTED
}
42892: 4e5e unlk %fp <== NOT EXECUTED
...
00042818 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
42818: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
4281c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4281e: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
42822: 2f02 movel %d2,%sp@- <== NOT EXECUTED
42824: 242e 0008 movel %fp@(8),%d2 <== NOT EXECUTED
if ( !print )
42828: 4a8a tstl %a2 <== NOT EXECUTED
4282a: 6746 beqs 42872 <rtems_stack_checker_report_usage_with_plugin+0x5a><== NOT EXECUTED
return;
print_context = context;
print_handler = print;
(*print)( context, "Stack usage by thread\n");
4282c: 4879 0005 e49d pea 5e49d <map.6435+0x12d> <== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
42832: 23c2 0006 0a10 movel %d2,60a10 <print_context> <== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
42838: 2f02 movel %d2,%sp@- <== NOT EXECUTED
{
if ( !print )
return;
print_context = context;
print_handler = print;
4283a: 23ca 0006 0a0c movel %a2,60a0c <print_handler> <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
42840: 4e92 jsr %a2@ <== NOT EXECUTED
(*print)( context,
42842: 4879 0005 e4b4 pea 5e4b4 <map.6435+0x144> <== NOT EXECUTED
42848: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4284a: 4e92 jsr %a2@ <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
4284c: 4879 0004 24a0 pea 424a0 <Stack_check_Dump_threads_usage> <== NOT EXECUTED
42852: 4eb9 0004 9158 jsr 49158 <rtems_iterate_over_all_threads> <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
42858: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
4285c: 4eb9 0004 24a0 jsr 424a0 <Stack_check_Dump_threads_usage> <== NOT EXECUTED
#endif
print_context = NULL;
print_handler = NULL;
42862: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
#endif
print_context = NULL;
42866: 42b9 0006 0a10 clrl 60a10 <print_context> <== NOT EXECUTED
print_handler = NULL;
4286c: 42b9 0006 0a0c clrl 60a0c <print_handler> <== NOT EXECUTED
}
42872: 242e fff8 movel %fp@(-8),%d2 <== NOT EXECUTED
42876: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
4287a: 4e5e unlk %fp <== NOT EXECUTED
0004273c <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
4273c: 4e56 0000 linkw %fp,#0
42740: 2f0a movel %a2,%sp@-
42742: 246e 0008 moveal %fp@(8),%a2
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
42746: 222a 00b6 movel %a2@(182),%d1
4274a: 5081 addql #8,%d1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
4274c: 202a 00b6 movel %a2@(182),%d0
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
42750: 2f02 movel %d2,%sp@-
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
42752: b08e cmpl %fp,%d0
42754: 620c bhis 42762 <rtems_stack_checker_switch_extension+0x26><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
42756: d0aa 00b2 addl %a2@(178),%d0
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
4275a: b08e cmpl %fp,%d0
4275c: 54c2 scc %d2
4275e: 4482 negl %d2
42760: 6002 bras 42764 <rtems_stack_checker_switch_extension+0x28>
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
42762: 4202 clrb %d2 <== NOT EXECUTED
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
42764: 4878 0010 pea 10 <INVALID_OPERATION>
42768: 4879 0006 1214 pea 61214 <Stack_check_Pattern>
4276e: 2f01 movel %d1,%sp@-
42770: 4eb9 0004 f9dc jsr 4f9dc <memcmp>
42776: 4fef 000c lea %sp@(12),%sp
4277a: 4a80 tstl %d0
4277c: 57c0 seq %d0
4277e: 4480 negl %d0
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
42780: 4a02 tstb %d2
42782: 6704 beqs 42788 <rtems_stack_checker_switch_extension+0x4c><== NEVER TAKEN
42784: 4a00 tstb %d0
42786: 6610 bnes 42798 <rtems_stack_checker_switch_extension+0x5c><== ALWAYS TAKEN
Stack_check_report_blown_task( running, pattern_ok );
42788: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
4278e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
42790: 2f0a movel %a2,%sp@- <== NOT EXECUTED
42792: 4eb9 0004 2696 jsr 42696 <Stack_check_report_blown_task> <== NOT EXECUTED
}
}
42798: 242e fff8 movel %fp@(-8),%d2
4279c: 246e fffc moveal %fp@(-4),%a2
427a0: 4e5e unlk %fp <== NOT EXECUTED
0004bb80 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
4bb80: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED
4bb84: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ <== NOT EXECUTED
4bb88: 282e 0008 movel %fp@(8),%d4 <== NOT EXECUTED
4bb8c: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
4bb90: 266e 0010 moveal %fp@(16),%a3 <== NOT EXECUTED
double result;
char *end;
if ( !n )
4bb94: 4a8a tstl %a2 <== NOT EXECUTED
4bb96: 6700 009c beqw 4bc34 <rtems_string_to_double+0xb4> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bb9a: 4eb9 0004 e794 jsr 4e794 <__errno> <== NOT EXECUTED
*n = 0;
4bba0: 4281 clrl %d1 <== NOT EXECUTED
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bba2: 2040 moveal %d0,%a0 <== NOT EXECUTED
*n = 0;
4bba4: 4280 clrl %d0 <== NOT EXECUTED
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bba6: 4290 clrl %a0@ <== NOT EXECUTED
*n = 0;
4bba8: 2480 movel %d0,%a2@ <== NOT EXECUTED
4bbaa: 2541 0004 movel %d1,%a2@(4) <== NOT EXECUTED
result = strtod( s, &end );
4bbae: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4bbb2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4bbb4: 4eb9 0005 1338 jsr 51338 <strtod> <== NOT EXECUTED
if ( endptr )
4bbba: 508f addql #8,%sp <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
4bbbc: 2400 movel %d0,%d2 <== NOT EXECUTED
4bbbe: 2601 movel %d1,%d3 <== NOT EXECUTED
if ( endptr )
4bbc0: 4a8b tstl %a3 <== NOT EXECUTED
4bbc2: 6704 beqs 4bbc8 <rtems_string_to_double+0x48> <== NOT EXECUTED
*endptr = end;
4bbc4: 26ae fffc movel %fp@(-4),%a3@ <== NOT EXECUTED
if ( end == s )
4bbc8: b8ae fffc cmpl %fp@(-4),%d4 <== NOT EXECUTED
4bbcc: 676a beqs 4bc38 <rtems_string_to_double+0xb8> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bbce: 4eb9 0004 e794 jsr 4e794 <__errno> <== NOT EXECUTED
4bbd4: 7222 moveq #34,%d1 <== NOT EXECUTED
4bbd6: 2040 moveal %d0,%a0 <== NOT EXECUTED
4bbd8: b290 cmpl %a0@,%d1 <== NOT EXECUTED
4bbda: 664e bnes 4bc2a <rtems_string_to_double+0xaa> <== NOT EXECUTED
4bbdc: 42a7 clrl %sp@- <== NOT EXECUTED
4bbde: 42a7 clrl %sp@- <== NOT EXECUTED
4bbe0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4bbe2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4bbe4: 4eb9 0004 26e4 jsr 426e4 <__eqdf2> <== NOT EXECUTED
4bbea: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4bbee: 4a80 tstl %d0 <== NOT EXECUTED
4bbf0: 674a beqs 4bc3c <rtems_string_to_double+0xbc> <== NOT EXECUTED
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4bbf2: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
4bbf6: 2f3c 7fef ffff movel #2146435071,%sp@- <== NOT EXECUTED
4bbfc: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4bbfe: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4bc00: 4eb9 0005 ccc8 jsr 5ccc8 <__gtdf2> <== NOT EXECUTED
4bc06: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4bc0a: 4a80 tstl %d0 <== NOT EXECUTED
4bc0c: 6e2e bgts 4bc3c <rtems_string_to_double+0xbc> <== NOT EXECUTED
4bc0e: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
4bc12: 2f3c ffef ffff movel #-1048577,%sp@- <== NOT EXECUTED
4bc18: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4bc1a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4bc1c: 4eb9 0005 cd10 jsr 5cd10 <__ltdf2> <== NOT EXECUTED
4bc22: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4bc26: 4a80 tstl %d0 <== NOT EXECUTED
4bc28: 6d12 blts 4bc3c <rtems_string_to_double+0xbc> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
4bc2a: 2482 movel %d2,%a2@ <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4bc2c: 4280 clrl %d0 <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
4bc2e: 2543 0004 movel %d3,%a2@(4) <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4bc32: 600a bras 4bc3e <rtems_string_to_double+0xbe> <== NOT EXECUTED
{
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bc34: 7009 moveq #9,%d0 <== NOT EXECUTED
4bc36: 6006 bras 4bc3e <rtems_string_to_double+0xbe> <== NOT EXECUTED
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bc38: 700b moveq #11,%d0 <== NOT EXECUTED
4bc3a: 6002 bras 4bc3e <rtems_string_to_double+0xbe> <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
4bc3c: 700a moveq #10,%d0 <== NOT EXECUTED
*n = result;
return RTEMS_SUCCESSFUL;
}
4bc3e: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3 <== NOT EXECUTED
4bc44: 4e5e unlk %fp <== NOT EXECUTED
0004bc48 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
4bc48: 4e56 ffec linkw %fp,#-20
4bc4c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bc50: 262e 0008 movel %fp@(8),%d3
4bc54: 246e 000c moveal %fp@(12),%a2
4bc58: 266e 0010 moveal %fp@(16),%a3
float result;
char *end;
if ( !n )
4bc5c: 4a8a tstl %a2
4bc5e: 677e beqs 4bcde <rtems_string_to_float+0x96>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bc60: 4eb9 0004 e794 jsr 4e794 <__errno>
4bc66: 2040 moveal %d0,%a0
4bc68: 4290 clrl %a0@
*n = 0;
4bc6a: 24bc 0000 0000 movel #0,%a2@
result = strtof( s, &end );
4bc70: 486e fffc pea %fp@(-4)
4bc74: 2f03 movel %d3,%sp@-
4bc76: 4eb9 0005 1358 jsr 51358 <strtof>
if ( endptr )
4bc7c: 508f addql #8,%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
4bc7e: 2400 movel %d0,%d2
if ( endptr )
4bc80: 4a8b tstl %a3
4bc82: 6704 beqs 4bc88 <rtems_string_to_float+0x40>
*endptr = end;
4bc84: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bc88: b6ae fffc cmpl %fp@(-4),%d3
4bc8c: 6754 beqs 4bce2 <rtems_string_to_float+0x9a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bc8e: 4eb9 0004 e794 jsr 4e794 <__errno>
4bc94: 7222 moveq #34,%d1
4bc96: 2040 moveal %d0,%a0
4bc98: b290 cmpl %a0@,%d1
4bc9a: 663c bnes 4bcd8 <rtems_string_to_float+0x90>
4bc9c: 2f3c 0000 0000 movel #0,%sp@-
4bca2: 2f02 movel %d2,%sp@-
4bca4: 4eb9 0004 2708 jsr 42708 <__eqsf2>
4bcaa: 508f addql #8,%sp
4bcac: 4a80 tstl %d0
4bcae: 6736 beqs 4bce6 <rtems_string_to_float+0x9e> <== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4bcb0: 2f3c 7f7f ffff movel #2139095039,%sp@-
4bcb6: 2f02 movel %d2,%sp@-
4bcb8: 4eb9 0005 cd58 jsr 5cd58 <__gtsf2>
4bcbe: 508f addql #8,%sp
4bcc0: 4a80 tstl %d0
4bcc2: 6e22 bgts 4bce6 <rtems_string_to_float+0x9e> <== NEVER TAKEN
4bcc4: 2f3c ff7f ffff movel #-8388609,%sp@-
4bcca: 2f02 movel %d2,%sp@-
4bccc: 4eb9 0005 cd74 jsr 5cd74 <__ltsf2>
4bcd2: 508f addql #8,%sp
4bcd4: 4a80 tstl %d0
4bcd6: 6d0e blts 4bce6 <rtems_string_to_float+0x9e> <== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
4bcd8: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bcda: 4280 clrl %d0
4bcdc: 600a bras 4bce8 <rtems_string_to_float+0xa0>
{
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bcde: 7009 moveq #9,%d0
4bce0: 6006 bras 4bce8 <rtems_string_to_float+0xa0>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bce2: 700b moveq #11,%d0
4bce4: 6002 bras 4bce8 <rtems_string_to_float+0xa0>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
4bce6: 700a moveq #10,%d0 <== NOT EXECUTED
*n = result;
return RTEMS_SUCCESSFUL;
}
4bce8: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bcee: 4e5e unlk %fp
...
0004bcf4 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
4bcf4: 4e56 ffec linkw %fp,#-20
4bcf8: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bcfc: 262e 0008 movel %fp@(8),%d3
4bd00: 246e 000c moveal %fp@(12),%a2
4bd04: 266e 0010 moveal %fp@(16),%a3
long result;
char *end;
if ( !n )
4bd08: 4a8a tstl %a2
4bd0a: 6758 beqs 4bd64 <rtems_string_to_int+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bd0c: 4eb9 0004 e794 jsr 4e794 <__errno>
4bd12: 2040 moveal %d0,%a0
4bd14: 4290 clrl %a0@
*n = 0;
4bd16: 4292 clrl %a2@
result = strtol( s, &end, base );
4bd18: 2f2e 0014 movel %fp@(20),%sp@-
4bd1c: 486e fffc pea %fp@(-4)
4bd20: 2f03 movel %d3,%sp@-
4bd22: 4eb9 0005 1528 jsr 51528 <strtol>
if ( endptr )
4bd28: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4bd2c: 2400 movel %d0,%d2
if ( endptr )
4bd2e: 4a8b tstl %a3
4bd30: 6704 beqs 4bd36 <rtems_string_to_int+0x42>
*endptr = end;
4bd32: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bd36: b6ae fffc cmpl %fp@(-4),%d3
4bd3a: 672c beqs 4bd68 <rtems_string_to_int+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bd3c: 4eb9 0004 e794 jsr 4e794 <__errno>
4bd42: 7222 moveq #34,%d1
4bd44: 2040 moveal %d0,%a0
4bd46: b290 cmpl %a0@,%d1
4bd48: 6614 bnes 4bd5e <rtems_string_to_int+0x6a>
4bd4a: 4a82 tstl %d2
4bd4c: 671e beqs 4bd6c <rtems_string_to_int+0x78> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4bd4e: 0c82 7fff ffff cmpil #2147483647,%d2
4bd54: 6716 beqs 4bd6c <rtems_string_to_int+0x78>
4bd56: 0c82 8000 0000 cmpil #-2147483648,%d2
4bd5c: 670e beqs 4bd6c <rtems_string_to_int+0x78> <== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4bd5e: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bd60: 4280 clrl %d0
4bd62: 600a bras 4bd6e <rtems_string_to_int+0x7a>
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bd64: 7009 moveq #9,%d0
4bd66: 6006 bras 4bd6e <rtems_string_to_int+0x7a>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bd68: 700b moveq #11,%d0
4bd6a: 6002 bras 4bd6e <rtems_string_to_int+0x7a>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4bd6c: 700a moveq #10,%d0
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4bd6e: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bd74: 4e5e unlk %fp <== NOT EXECUTED
0004be18 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
4be18: 4e56 ffec linkw %fp,#-20
4be1c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4be20: 262e 0008 movel %fp@(8),%d3
4be24: 246e 000c moveal %fp@(12),%a2
4be28: 266e 0010 moveal %fp@(16),%a3
long result;
char *end;
if ( !n )
4be2c: 4a8a tstl %a2
4be2e: 6758 beqs 4be88 <rtems_string_to_long+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4be30: 4eb9 0004 e794 jsr 4e794 <__errno>
4be36: 2040 moveal %d0,%a0
4be38: 4290 clrl %a0@
*n = 0;
4be3a: 4292 clrl %a2@
result = strtol( s, &end, base );
4be3c: 2f2e 0014 movel %fp@(20),%sp@-
4be40: 486e fffc pea %fp@(-4)
4be44: 2f03 movel %d3,%sp@-
4be46: 4eb9 0005 1528 jsr 51528 <strtol>
if ( endptr )
4be4c: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4be50: 2400 movel %d0,%d2
if ( endptr )
4be52: 4a8b tstl %a3
4be54: 6704 beqs 4be5a <rtems_string_to_long+0x42>
*endptr = end;
4be56: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4be5a: b6ae fffc cmpl %fp@(-4),%d3
4be5e: 672c beqs 4be8c <rtems_string_to_long+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4be60: 4eb9 0004 e794 jsr 4e794 <__errno>
4be66: 7222 moveq #34,%d1
4be68: 2040 moveal %d0,%a0
4be6a: b290 cmpl %a0@,%d1
4be6c: 6614 bnes 4be82 <rtems_string_to_long+0x6a>
4be6e: 4a82 tstl %d2
4be70: 671e beqs 4be90 <rtems_string_to_long+0x78> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4be72: 0c82 7fff ffff cmpil #2147483647,%d2
4be78: 6716 beqs 4be90 <rtems_string_to_long+0x78>
4be7a: 0c82 8000 0000 cmpil #-2147483648,%d2
4be80: 670e beqs 4be90 <rtems_string_to_long+0x78> <== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
4be82: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4be84: 4280 clrl %d0
4be86: 600a bras 4be92 <rtems_string_to_long+0x7a>
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4be88: 7009 moveq #9,%d0
4be8a: 6006 bras 4be92 <rtems_string_to_long+0x7a>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4be8c: 700b moveq #11,%d0
4be8e: 6002 bras 4be92 <rtems_string_to_long+0x7a>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4be90: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4be92: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4be98: 4e5e unlk %fp <== NOT EXECUTED
0004bd78 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
4bd78: 4e56 ffe8 linkw %fp,#-24
4bd7c: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
4bd80: 282e 0008 movel %fp@(8),%d4
4bd84: 246e 000c moveal %fp@(12),%a2
4bd88: 266e 0010 moveal %fp@(16),%a3
long long result;
char *end;
if ( !n )
4bd8c: 4a8a tstl %a2
4bd8e: 6774 beqs 4be04 <rtems_string_to_long_long+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bd90: 4eb9 0004 e794 jsr 4e794 <__errno>
4bd96: 2040 moveal %d0,%a0
*n = 0;
4bd98: 4280 clrl %d0
4bd9a: 4281 clrl %d1
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bd9c: 4290 clrl %a0@
*n = 0;
4bd9e: 2480 movel %d0,%a2@
4bda0: 2541 0004 movel %d1,%a2@(4)
result = strtoll( s, &end, base );
4bda4: 2f2e 0014 movel %fp@(20),%sp@-
4bda8: 486e fffc pea %fp@(-4)
4bdac: 2f04 movel %d4,%sp@-
4bdae: 4eb9 0005 1548 jsr 51548 <strtoll>
if ( endptr )
4bdb4: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
4bdb8: 2400 movel %d0,%d2
4bdba: 2601 movel %d1,%d3
if ( endptr )
4bdbc: 4a8b tstl %a3
4bdbe: 6704 beqs 4bdc4 <rtems_string_to_long_long+0x4c>
*endptr = end;
4bdc0: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bdc4: b8ae fffc cmpl %fp@(-4),%d4
4bdc8: 673e beqs 4be08 <rtems_string_to_long_long+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bdca: 4eb9 0004 e794 jsr 4e794 <__errno>
4bdd0: 7222 moveq #34,%d1
4bdd2: 2040 moveal %d0,%a0
4bdd4: b290 cmpl %a0@,%d1
4bdd6: 6622 bnes 4bdfa <rtems_string_to_long_long+0x82>
4bdd8: 2002 movel %d2,%d0
4bdda: 8083 orl %d3,%d0
4bddc: 672e beqs 4be0c <rtems_string_to_long_long+0x94> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4bdde: 203c 7fff ffff movel #2147483647,%d0
4bde4: 72ff moveq #-1,%d1
4bde6: 9283 subl %d3,%d1
4bde8: 9182 subxl %d2,%d0
4bdea: 6720 beqs 4be0c <rtems_string_to_long_long+0x94>
4bdec: 203c 8000 0000 movel #-2147483648,%d0
4bdf2: 4281 clrl %d1
4bdf4: 9283 subl %d3,%d1
4bdf6: 9182 subxl %d2,%d0
4bdf8: 6712 beqs 4be0c <rtems_string_to_long_long+0x94> <== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
4bdfa: 4280 clrl %d0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4bdfc: 2482 movel %d2,%a2@
4bdfe: 2543 0004 movel %d3,%a2@(4)
return RTEMS_SUCCESSFUL;
4be02: 600a bras 4be0e <rtems_string_to_long_long+0x96>
{
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4be04: 7009 moveq #9,%d0
4be06: 6006 bras 4be0e <rtems_string_to_long_long+0x96>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4be08: 700b moveq #11,%d0
4be0a: 6002 bras 4be0e <rtems_string_to_long_long+0x96>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4be0c: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4be0e: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3
4be14: 4e5e unlk %fp <== NOT EXECUTED
0004beb8 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
4beb8: 4e56 ffec linkw %fp,#-20
4bebc: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bec0: 262e 0008 movel %fp@(8),%d3
4bec4: 246e 000c moveal %fp@(12),%a2
4bec8: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4becc: 4a8a tstl %a2
4bece: 6764 beqs 4bf34 <rtems_string_to_unsigned_char+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bed0: 4eb9 0004 e794 jsr 4e794 <__errno>
4bed6: 2040 moveal %d0,%a0
4bed8: 4290 clrl %a0@
*n = 0;
4beda: 4212 clrb %a2@
result = strtoul( s, &end, base );
4bedc: 2f2e 0014 movel %fp@(20),%sp@-
4bee0: 486e fffc pea %fp@(-4)
4bee4: 2f03 movel %d3,%sp@-
4bee6: 4eb9 0005 1986 jsr 51986 <strtoul>
if ( endptr )
4beec: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4bef0: 2400 movel %d0,%d2
if ( endptr )
4bef2: 4a8b tstl %a3
4bef4: 6704 beqs 4befa <rtems_string_to_unsigned_char+0x42>
*endptr = end;
4bef6: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4befa: b6ae fffc cmpl %fp@(-4),%d3
4befe: 6738 beqs 4bf38 <rtems_string_to_unsigned_char+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bf00: 4eb9 0004 e794 jsr 4e794 <__errno>
4bf06: 7222 moveq #34,%d1
4bf08: 2040 moveal %d0,%a0
4bf0a: b290 cmpl %a0@,%d1
4bf0c: 660a bnes 4bf18 <rtems_string_to_unsigned_char+0x60>
(( result == 0 ) || ( result == ULONG_MAX )))
4bf0e: 2002 movel %d2,%d0
4bf10: 5380 subql #1,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bf12: 72fd moveq #-3,%d1
4bf14: b280 cmpl %d0,%d1
4bf16: 6524 bcss 4bf3c <rtems_string_to_unsigned_char+0x84><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
4bf18: 0c82 0000 00ff cmpil #255,%d2
4bf1e: 630e blss 4bf2e <rtems_string_to_unsigned_char+0x76>
errno = ERANGE;
4bf20: 4eb9 0004 e794 jsr 4e794 <__errno>
4bf26: 2040 moveal %d0,%a0
4bf28: 7022 moveq #34,%d0
4bf2a: 2080 movel %d0,%a0@
4bf2c: 600e bras 4bf3c <rtems_string_to_unsigned_char+0x84>
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
4bf2e: 4280 clrl %d0
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4bf30: 1482 moveb %d2,%a2@
return RTEMS_SUCCESSFUL;
4bf32: 600a bras 4bf3e <rtems_string_to_unsigned_char+0x86>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bf34: 7009 moveq #9,%d0
4bf36: 6006 bras 4bf3e <rtems_string_to_unsigned_char+0x86>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bf38: 700b moveq #11,%d0
4bf3a: 6002 bras 4bf3e <rtems_string_to_unsigned_char+0x86>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4bf3c: 700a moveq #10,%d0
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4bf3e: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bf44: 4e5e unlk %fp <== NOT EXECUTED
0004bf48 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
4bf48: 4e56 ffec linkw %fp,#-20
4bf4c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bf50: 262e 0008 movel %fp@(8),%d3
4bf54: 246e 000c moveal %fp@(12),%a2
4bf58: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4bf5c: 4a8a tstl %a2
4bf5e: 674e beqs 4bfae <rtems_string_to_unsigned_int+0x66>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bf60: 4eb9 0004 e794 jsr 4e794 <__errno>
4bf66: 2040 moveal %d0,%a0
4bf68: 4290 clrl %a0@
*n = 0;
4bf6a: 4292 clrl %a2@
result = strtoul( s, &end, base );
4bf6c: 2f2e 0014 movel %fp@(20),%sp@-
4bf70: 486e fffc pea %fp@(-4)
4bf74: 2f03 movel %d3,%sp@-
4bf76: 4eb9 0005 1986 jsr 51986 <strtoul>
if ( endptr )
4bf7c: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4bf80: 2400 movel %d0,%d2
if ( endptr )
4bf82: 4a8b tstl %a3
4bf84: 6704 beqs 4bf8a <rtems_string_to_unsigned_int+0x42>
*endptr = end;
4bf86: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bf8a: b6ae fffc cmpl %fp@(-4),%d3
4bf8e: 6722 beqs 4bfb2 <rtems_string_to_unsigned_int+0x6a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bf90: 4eb9 0004 e794 jsr 4e794 <__errno>
4bf96: 7222 moveq #34,%d1
4bf98: 2040 moveal %d0,%a0
4bf9a: b290 cmpl %a0@,%d1
4bf9c: 660a bnes 4bfa8 <rtems_string_to_unsigned_int+0x60>
(( result == 0 ) || ( result == ULONG_MAX )))
4bf9e: 2002 movel %d2,%d0
4bfa0: 5380 subql #1,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bfa2: 72fd moveq #-3,%d1
4bfa4: b280 cmpl %d0,%d1
4bfa6: 650e bcss 4bfb6 <rtems_string_to_unsigned_int+0x6e><== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4bfa8: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bfaa: 4280 clrl %d0
4bfac: 600a bras 4bfb8 <rtems_string_to_unsigned_int+0x70>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bfae: 7009 moveq #9,%d0
4bfb0: 6006 bras 4bfb8 <rtems_string_to_unsigned_int+0x70>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bfb2: 700b moveq #11,%d0
4bfb4: 6002 bras 4bfb8 <rtems_string_to_unsigned_int+0x70>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4bfb6: 700a moveq #10,%d0
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4bfb8: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bfbe: 4e5e unlk %fp
...
0004c054 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
4c054: 4e56 ffec linkw %fp,#-20
4c058: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4c05c: 262e 0008 movel %fp@(8),%d3
4c060: 246e 000c moveal %fp@(12),%a2
4c064: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4c068: 4a8a tstl %a2
4c06a: 674e beqs 4c0ba <rtems_string_to_unsigned_long+0x66>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4c06c: 4eb9 0004 e794 jsr 4e794 <__errno>
4c072: 2040 moveal %d0,%a0
4c074: 4290 clrl %a0@
*n = 0;
4c076: 4292 clrl %a2@
result = strtoul( s, &end, base );
4c078: 2f2e 0014 movel %fp@(20),%sp@-
4c07c: 486e fffc pea %fp@(-4)
4c080: 2f03 movel %d3,%sp@-
4c082: 4eb9 0005 1986 jsr 51986 <strtoul>
if ( endptr )
4c088: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4c08c: 2400 movel %d0,%d2
if ( endptr )
4c08e: 4a8b tstl %a3
4c090: 6704 beqs 4c096 <rtems_string_to_unsigned_long+0x42>
*endptr = end;
4c092: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4c096: b6ae fffc cmpl %fp@(-4),%d3
4c09a: 6722 beqs 4c0be <rtems_string_to_unsigned_long+0x6a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4c09c: 4eb9 0004 e794 jsr 4e794 <__errno>
4c0a2: 7222 moveq #34,%d1
4c0a4: 2040 moveal %d0,%a0
4c0a6: b290 cmpl %a0@,%d1
4c0a8: 660a bnes 4c0b4 <rtems_string_to_unsigned_long+0x60>
(( result == 0 ) || ( result == ULONG_MAX )))
4c0aa: 2002 movel %d2,%d0
4c0ac: 5380 subql #1,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4c0ae: 72fd moveq #-3,%d1
4c0b0: b280 cmpl %d0,%d1
4c0b2: 650e bcss 4c0c2 <rtems_string_to_unsigned_long+0x6e><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4c0b4: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4c0b6: 4280 clrl %d0
4c0b8: 600a bras 4c0c4 <rtems_string_to_unsigned_long+0x70>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4c0ba: 7009 moveq #9,%d0
4c0bc: 6006 bras 4c0c4 <rtems_string_to_unsigned_long+0x70>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4c0be: 700b moveq #11,%d0
4c0c0: 6002 bras 4c0c4 <rtems_string_to_unsigned_long+0x70>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4c0c2: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4c0c4: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4c0ca: 4e5e unlk %fp
...
0004bfc4 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
4bfc4: 4e56 ffe4 linkw %fp,#-28
4bfc8: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
4bfcc: 282e 0008 movel %fp@(8),%d4
4bfd0: 246e 000c moveal %fp@(12),%a2
4bfd4: 266e 0010 moveal %fp@(16),%a3
unsigned long long result;
char *end;
if ( !n )
4bfd8: 4a8a tstl %a2
4bfda: 6764 beqs 4c040 <rtems_string_to_unsigned_long_long+0x7c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bfdc: 4eb9 0004 e794 jsr 4e794 <__errno>
4bfe2: 2040 moveal %d0,%a0
*n = 0;
4bfe4: 4280 clrl %d0
4bfe6: 4281 clrl %d1
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bfe8: 4290 clrl %a0@
*n = 0;
4bfea: 2480 movel %d0,%a2@
4bfec: 2541 0004 movel %d1,%a2@(4)
result = strtoull( s, &end, base );
4bff0: 2f2e 0014 movel %fp@(20),%sp@-
4bff4: 486e fffc pea %fp@(-4)
4bff8: 2f04 movel %d4,%sp@-
4bffa: 4eb9 0005 19a8 jsr 519a8 <strtoull>
if ( endptr )
4c000: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
4c004: 2400 movel %d0,%d2
4c006: 2601 movel %d1,%d3
if ( endptr )
4c008: 4a8b tstl %a3
4c00a: 6704 beqs 4c010 <rtems_string_to_unsigned_long_long+0x4c>
*endptr = end;
4c00c: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4c010: b8ae fffc cmpl %fp@(-4),%d4
4c014: 672e beqs 4c044 <rtems_string_to_unsigned_long_long+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4c016: 4eb9 0004 e794 jsr 4e794 <__errno>
4c01c: 7222 moveq #34,%d1
4c01e: 2040 moveal %d0,%a0
4c020: b290 cmpl %a0@,%d1
4c022: 6612 bnes 4c036 <rtems_string_to_unsigned_long_long+0x72>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4c024: 70ff moveq #-1,%d0
4c026: 72ff moveq #-1,%d1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4c028: 78ff moveq #-1,%d4
4c02a: 7afd moveq #-3,%d5
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4c02c: d283 addl %d3,%d1
4c02e: d182 addxl %d2,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4c030: 9a81 subl %d1,%d5
4c032: 9980 subxl %d0,%d4
4c034: 6512 bcss 4c048 <rtems_string_to_unsigned_long_long+0x84><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
4c036: 4280 clrl %d0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4c038: 2482 movel %d2,%a2@
4c03a: 2543 0004 movel %d3,%a2@(4)
return RTEMS_SUCCESSFUL;
4c03e: 600a bras 4c04a <rtems_string_to_unsigned_long_long+0x86>
{
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4c040: 7009 moveq #9,%d0
4c042: 6006 bras 4c04a <rtems_string_to_unsigned_long_long+0x86>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4c044: 700b moveq #11,%d0
4c046: 6002 bras 4c04a <rtems_string_to_unsigned_long_long+0x86>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
4c048: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4c04a: 4cee 0c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a3
4c050: 4e5e unlk %fp <== NOT EXECUTED
00042500 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
42500: 4e56 fe40 linkw %fp,#-448
42504: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
42508: 2e2e 0008 movel %fp@(8),%d7
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
4250c: 2f07 movel %d7,%sp@-
4250e: 4eb9 0005 1160 jsr 51160 <strlen>
42514: 4297 clrl %sp@
42516: 486e ffd4 pea %fp@(-44)
4251a: 42a7 clrl %sp@-
4251c: 2f00 movel %d0,%sp@-
4251e: 2f07 movel %d7,%sp@-
42520: 4eb9 0004 2f74 jsr 42f74 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
42526: 4fef 0014 lea %sp@(20),%sp
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
4252a: 2800 movel %d0,%d4
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
4252c: 6600 01a4 bnew 426d2 <rtems_tarfs_load+0x1d2>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
42530: 202e ffe0 movel %fp@(-32),%d0
42534: 0c80 0006 0a82 cmpil #395906,%d0
4253a: 6710 beqs 4254c <rtems_tarfs_load+0x4c>
4253c: 0c80 0006 12d6 cmpil #398038,%d0
42542: 6708 beqs 4254c <rtems_tarfs_load+0x4c> <== NEVER TAKEN
42544: 6000 018c braw 426d2 <rtems_tarfs_load+0x1d2>
42548: 2443 moveal %d3,%a2
4254a: 6026 bras 42572 <rtems_tarfs_load+0x72>
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
4254c: 2c0e movel %fp,%d6
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
4254e: 2a0e movel %fp,%d5
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
42550: 240e movel %fp,%d2
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
42552: 95ca subal %a2,%a2
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
42554: 0686 ffff ff70 addil #-144,%d6
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
4255a: 0685 ffff ffe8 addil #-24,%d5
42560: 4bee ffd4 lea %fp@(-44),%a5
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
42564: 0682 ffff fe70 addil #-400,%d2
4256a: 2d44 fe6c movel %d4,%fp@(-404)
4256e: 2d47 fe68 movel %d7,%fp@(-408)
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
42572: 260a movel %a2,%d3
42574: 0683 0000 0200 addil #512,%d3
4257a: b6ae 0010 cmpl %fp@(16),%d3
4257e: 6200 0156 bhiw 426d6 <rtems_tarfs_load+0x1d6>
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
42582: 4878 0005 pea 5 <COMPARE>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
42586: d5ee 000c addal %fp@(12),%a2
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
4258a: 4879 0006 0aca pea 60aca <IMFS_ops+0x48>
42590: 486a 0101 pea %a2@(257)
42594: 4eb9 0005 117c jsr 5117c <strncmp>
4259a: 4fef 000c lea %sp@(12),%sp
4259e: 4a80 tstl %d0
425a0: 6600 0134 bnew 426d6 <rtems_tarfs_load+0x1d6>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
425a4: 4878 0063 pea 63 <DBL_MANT_DIG+0x2e>
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425a8: 47f9 0004 9628 lea 49628 <_rtems_octal2ulong>,%a3
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
425ae: 2f0a movel %a2,%sp@-
425b0: 2f06 movel %d6,%sp@-
425b2: 4eb9 0005 1258 jsr 51258 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
425b8: 1e2a 009c moveb %a2@(156),%d7
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425bc: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
425c0: 486a 0064 pea %a2@(100)
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
425c4: 4200 clrb %d0
425c6: 1d40 ffd3 moveb %d0,%fp@(-45)
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425ca: 4e93 jsr %a3@
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
425cc: 4878 000c pea c <OPER1>
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425d0: 2800 movel %d0,%d4
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
425d2: 486a 007c pea %a2@(124)
425d6: 4e93 jsr %a3@
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
425d8: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
425dc: 2840 moveal %d0,%a4
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
425de: 486a 0094 pea %a2@(148)
425e2: 4e93 jsr %a3@
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
425e4: 4fef 0020 lea %sp@(32),%sp
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
425e8: 2640 moveal %d0,%a3
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
425ea: 2e8a movel %a2,%sp@
425ec: 4eb9 0004 966e jsr 4966e <_rtems_tar_header_checksum>
425f2: 588f addql #4,%sp
425f4: b7c0 cmpal %d0,%a3
425f6: 6600 00de bnew 426d6 <rtems_tarfs_load+0x1d6>
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
425fa: 7235 moveq #53,%d1
425fc: 0287 0000 00ff andil #255,%d7
42602: b287 cmpl %d7,%d1
42604: 6656 bnes 4265c <rtems_tarfs_load+0x15c>
strcpy(full_filename, mountpoint);
42606: 2f2e fe68 movel %fp@(-408),%sp@-
4260a: 2f02 movel %d2,%sp@-
4260c: 4eb9 0005 0c58 jsr 50c58 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
42612: 2f02 movel %d2,%sp@-
42614: 4eb9 0005 1160 jsr 51160 <strlen>
4261a: 4fef 000c lea %sp@(12),%sp
4261e: 722f moveq #47,%d1
42620: 41f6 0800 lea %fp@(00000000,%d0:l),%a0
42624: 1028 fe6f moveb %a0@(-401),%d0
42628: 49c0 extbl %d0
4262a: b280 cmpl %d0,%d1
4262c: 6710 beqs 4263e <rtems_tarfs_load+0x13e> <== ALWAYS TAKEN
strcat(full_filename, "/");
4262e: 4879 0005 d959 pea 5d959 <_rodata_start+0x19> <== NOT EXECUTED
42634: 2f02 movel %d2,%sp@- <== NOT EXECUTED
42636: 4eb9 0005 0b38 jsr 50b38 <strcat> <== NOT EXECUTED
4263c: 508f addql #8,%sp <== NOT EXECUTED
strcat(full_filename, filename);
4263e: 2f06 movel %d6,%sp@-
42640: 2f02 movel %d2,%sp@-
42642: 4eb9 0005 0b38 jsr 50b38 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
42648: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
4264c: 2f02 movel %d2,%sp@-
4264e: 4eb9 0004 3720 jsr 43720 <mkdir>
42654: 4fef 0010 lea %sp@(16),%sp
42658: 6000 feee braw 42548 <rtems_tarfs_load+0x48>
* IMFS_create_node was ONLY passed a NULL when we created the
* root node. We added a new IMFS_create_root_node() so this
* path no longer existed. The result was simpler code which
* should not have this path.
*/
else if (linkflag == REGTYPE) {
4265c: 7030 moveq #48,%d0
4265e: b087 cmpl %d7,%d0
42660: 6600 fee6 bnew 42548 <rtems_tarfs_load+0x48>
const char *name;
loc = root_loc;
42664: 4878 0014 pea 14 <OPER2>
42668: 2f0d movel %a5,%sp@-
4266a: 2f05 movel %d5,%sp@-
4266c: 4eb9 0005 0084 jsr 50084 <memcpy>
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
42672: 486e fffc pea %fp@(-4)
42676: 2f05 movel %d5,%sp@-
42678: 2f06 movel %d6,%sp@-
4267a: 4eb9 0004 a244 jsr 4a244 <IMFS_evaluate_for_make>
42680: 4fef 0018 lea %sp@(24),%sp
42684: 4a80 tstl %d0
42686: 6636 bnes 426be <rtems_tarfs_load+0x1be> <== NEVER TAKEN
node = IMFS_create_node(
42688: 42a7 clrl %sp@-
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
4268a: 0284 0000 01ff andil #511,%d4
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
42690: 08c4 000f bset #15,%d4
42694: 2f04 movel %d4,%sp@-
42696: 2f2e fffc movel %fp@(-4),%sp@-
4269a: 4878 0006 pea 6 <EXTENDSFDF>
4269e: 2f05 movel %d5,%sp@-
426a0: 4eb9 0004 9bea jsr 49bea <IMFS_create_node>
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
426a6: 222e 000c movel %fp@(12),%d1
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
426aa: 2040 moveal %d0,%a0
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
426ac: d283 addl %d3,%d1
426ae: 4fef 0014 lea %sp@(20),%sp
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
426b2: 214c 0050 movel %a4,%a0@(80)
426b6: 42a8 004c clrl %a0@(76)
node->info.linearfile.direct = &tar_image[offset];
426ba: 2141 0054 movel %d1,%a0@(84)
}
nblocks = (((file_size) + 511) & ~511) / 512;
426be: 200c movel %a4,%d0
426c0: 0680 0000 01ff addil #511,%d0
offset += 512 * nblocks;
426c6: 0280 ffff fe00 andil #-512,%d0
426cc: d680 addl %d0,%d3
426ce: 6000 fe78 braw 42548 <rtems_tarfs_load+0x48>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
426d2: 78ff moveq #-1,%d4
426d4: 6004 bras 426da <rtems_tarfs_load+0x1da>
426d6: 282e fe6c movel %fp@(-404),%d4
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
426da: 2004 movel %d4,%d0
426dc: 4cee 3cfc fe40 moveml %fp@(-448),%d2-%d7/%a2-%a5
426e2: 4e5e unlk %fp
...
0004c8ec <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4c8ec: 4e56 ffe4 linkw %fp,#-28
4c8f0: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@
4c8f4: 262e 0008 movel %fp@(8),%d3
4c8f8: 282e 000c movel %fp@(12),%d4
4c8fc: 286e 0010 moveal %fp@(16),%a4
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
4c900: 4a8c tstl %a4
4c902: 6700 0104 beqw 4ca08 <rtems_task_mode+0x11c>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
4c906: 2679 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a3
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4c90c: 4a2b 0074 tstb %a3@(116)
4c910: 57c2 seq %d2
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4c912: 246b 00fe moveal %a3@(254),%a2
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4c916: 49c2 extbl %d2
4c918: 0282 0000 0100 andil #256,%d2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4c91e: 4aab 007a tstl %a3@(122)
4c922: 6704 beqs 4c928 <rtems_task_mode+0x3c>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
4c924: 08c2 0009 bset #9,%d2
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4c928: 4a2a 0008 tstb %a2@(8)
4c92c: 57c5 seq %d5
old_mode |= _ISR_Get_level();
4c92e: 4eb9 0004 8d38 jsr 48d38 <_CPU_ISR_Get_level>
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4c934: 49c5 extbl %d5
4c936: 0285 0000 0400 andil #1024,%d5
4c93c: 8085 orl %d5,%d0
old_mode |= _ISR_Get_level();
4c93e: 8082 orl %d2,%d0
4c940: 2880 movel %d0,%a4@
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
4c942: 0804 0008 btst #8,%d4
4c946: 670c beqs 4c954 <rtems_task_mode+0x68>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
4c948: 0803 0008 btst #8,%d3
4c94c: 57c0 seq %d0
4c94e: 4480 negl %d0
4c950: 1740 0074 moveb %d0,%a3@(116)
if ( mask & RTEMS_TIMESLICE_MASK ) {
4c954: 0804 0009 btst #9,%d4
4c958: 671c beqs 4c976 <rtems_task_mode+0x8a>
if ( _Modes_Is_timeslice(mode_set) ) {
4c95a: 0803 0009 btst #9,%d3
4c95e: 6712 beqs 4c972 <rtems_task_mode+0x86>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4c960: 41f9 0005 eb50 lea 5eb50 <_Thread_Ticks_per_timeslice>,%a0
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4c966: 7001 moveq #1,%d0
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4c968: 2750 0076 movel %a0@,%a3@(118)
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4c96c: 2740 007a movel %d0,%a3@(122)
4c970: 6004 bras 4c976 <rtems_task_mode+0x8a>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4c972: 42ab 007a clrl %a3@(122)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
4c976: 7007 moveq #7,%d0
4c978: c084 andl %d4,%d0
4c97a: 6712 beqs 4c98e <rtems_task_mode+0xa2>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
4c97c: 40c0 movew %sr,%d0
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
4c97e: 7207 moveq #7,%d1
4c980: c283 andl %d3,%d1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
4c982: 0280 0000 f8ff andil #63743,%d0
4c988: e189 lsll #8,%d1
4c98a: 8081 orl %d1,%d0
4c98c: 46c0 movew %d0,%sr
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
4c98e: 0804 000a btst #10,%d4
4c992: 6740 beqs 4c9d4 <rtems_task_mode+0xe8>
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4c994: 4281 clrl %d1
4c996: 122a 0008 moveb %a2@(8),%d1
4c99a: 4282 clrl %d2
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
4c99c: 0803 000a btst #10,%d3
4c9a0: 57c0 seq %d0
4c9a2: 4480 negl %d0
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4c9a4: 1400 moveb %d0,%d2
4c9a6: b282 cmpl %d2,%d1
4c9a8: 672a beqs 4c9d4 <rtems_task_mode+0xe8>
asr->is_enabled = is_asr_enabled;
4c9aa: 1540 0008 moveb %d0,%a2@(8)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
4c9ae: 203c 0000 0700 movel #1792,%d0
4c9b4: 40c1 movew %sr,%d1
4c9b6: 8081 orl %d1,%d0
4c9b8: 46c0 movew %d0,%sr
_signals = information->signals_pending;
4c9ba: 202a 0016 movel %a2@(22),%d0
information->signals_pending = information->signals_posted;
4c9be: 256a 0012 0016 movel %a2@(18),%a2@(22)
information->signals_posted = _signals;
4c9c4: 2540 0012 movel %d0,%a2@(18)
_ISR_Enable( _level );
4c9c8: 46c1 movew %d1,%sr
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
4c9ca: 4aaa 0012 tstl %a2@(18)
4c9ce: 56c0 sne %d0
4c9d0: 4480 negl %d0
4c9d2: 6002 bras 4c9d6 <rtems_task_mode+0xea>
4c9d4: 4200 clrb %d0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
4c9d6: 7203 moveq #3,%d1
4c9d8: b2b9 0005 ecdc cmpl 5ecdc <_System_state_Current>,%d1
4c9de: 662c bnes 4ca0c <rtems_task_mode+0x120>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
4c9e0: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
if ( are_signals_pending ||
4c9e6: 4a00 tstb %d0
4c9e8: 660e bnes 4c9f8 <rtems_task_mode+0x10c>
4c9ea: b1f9 0005 effe cmpal 5effe <_Per_CPU_Information+0x10>,%a0
4c9f0: 671a beqs 4ca0c <rtems_task_mode+0x120>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
4c9f2: 4a28 0074 tstb %a0@(116)
4c9f6: 6714 beqs 4ca0c <rtems_task_mode+0x120> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
4c9f8: 7001 moveq #1,%d0
4c9fa: 13c0 0005 f006 moveb %d0,5f006 <_Per_CPU_Information+0x18>
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
4ca00: 4eb9 0004 7c28 jsr 47c28 <_Thread_Dispatch>
4ca06: 6004 bras 4ca0c <rtems_task_mode+0x120>
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
4ca08: 7009 moveq #9,%d0
4ca0a: 6002 bras 4ca0e <rtems_task_mode+0x122>
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
4ca0c: 4280 clrl %d0
}
4ca0e: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4ca14: 4e5e unlk %fp <== NOT EXECUTED
00049500 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
49500: 4e56 fffc linkw %fp,#-4
49504: 2f0a movel %a2,%sp@-
49506: 246e 0010 moveal %fp@(16),%a2
4950a: 2f02 movel %d2,%sp@-
4950c: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
49510: 670c beqs 4951e <rtems_task_set_priority+0x1e>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
49512: 4280 clrl %d0
49514: 1039 0006 085a moveb 6085a <rtems_maximum_priority>,%d0
4951a: b082 cmpl %d2,%d0
4951c: 654e bcss 4956c <rtems_task_set_priority+0x6c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4951e: 4a8a tstl %a2
49520: 674e beqs 49570 <rtems_task_set_priority+0x70>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
49522: 486e fffc pea %fp@(-4)
49526: 2f2e 0008 movel %fp@(8),%sp@-
4952a: 4eb9 0004 b68c jsr 4b68c <_Thread_Get>
switch ( location ) {
49530: 508f addql #8,%sp
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
49532: 2040 moveal %d0,%a0
switch ( location ) {
49534: 4aae fffc tstl %fp@(-4)
49538: 663a bnes 49574 <rtems_task_set_priority+0x74>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
4953a: 24a8 0014 movel %a0@(20),%a2@
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4953e: 4a82 tstl %d2
49540: 6720 beqs 49562 <rtems_task_set_priority+0x62>
the_thread->real_priority = new_priority;
49542: 2142 0018 movel %d2,%a0@(24)
if ( the_thread->resource_count == 0 ||
49546: 4aa8 001c tstl %a0@(28)
4954a: 6706 beqs 49552 <rtems_task_set_priority+0x52>
4954c: b4a8 0014 cmpl %a0@(20),%d2
49550: 6410 bccs 49562 <rtems_task_set_priority+0x62> <== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
49552: 42a7 clrl %sp@-
49554: 2f02 movel %d2,%sp@-
49556: 2f08 movel %a0,%sp@-
49558: 4eb9 0004 b214 jsr 4b214 <_Thread_Change_priority>
4955e: 4fef 000c lea %sp@(12),%sp
}
_Thread_Enable_dispatch();
49562: 4eb9 0004 b664 jsr 4b664 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
49568: 4280 clrl %d0
4956a: 600a bras 49576 <rtems_task_set_priority+0x76>
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
4956c: 7013 moveq #19,%d0
4956e: 6006 bras 49576 <rtems_task_set_priority+0x76>
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
49570: 7009 moveq #9,%d0
49572: 6002 bras 49576 <rtems_task_set_priority+0x76>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
49574: 7004 moveq #4,%d0
}
49576: 242e fff4 movel %fp@(-12),%d2
4957a: 246e fff8 moveal %fp@(-8),%a2
4957e: 4e5e unlk %fp
...
00044ebc <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
44ebc: 7209 moveq #9,%d1
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
44ebe: 4e56 0000 linkw %fp,#0
44ec2: 202e 0008 movel %fp@(8),%d0
int baud_index;
switch (termios_baud) {
44ec6: b280 cmpl %d0,%d1
44ec8: 6700 00c4 beqw 44f8e <rtems_termios_baud_to_index+0xd2>
44ecc: 6d50 blts 44f1e <rtems_termios_baud_to_index+0x62>
44ece: 123c 0004 moveb #4,%d1
44ed2: b280 cmpl %d0,%d1
44ed4: 6700 00a4 beqw 44f7a <rtems_termios_baud_to_index+0xbe>
44ed8: 6d28 blts 44f02 <rtems_termios_baud_to_index+0x46>
44eda: 123c 0001 moveb #1,%d1
44ede: b280 cmpl %d0,%d1
44ee0: 6700 00dc beqw 44fbe <rtems_termios_baud_to_index+0x102>
44ee4: 6d0a blts 44ef0 <rtems_termios_baud_to_index+0x34>
44ee6: 4a80 tstl %d0
44ee8: 6700 0084 beqw 44f6e <rtems_termios_baud_to_index+0xb2>
44eec: 6000 00cc braw 44fba <rtems_termios_baud_to_index+0xfe>
44ef0: 7202 moveq #2,%d1
44ef2: b280 cmpl %d0,%d1
44ef4: 677c beqs 44f72 <rtems_termios_baud_to_index+0xb6>
44ef6: 123c 0003 moveb #3,%d1
44efa: b280 cmpl %d0,%d1
44efc: 6600 00bc bnew 44fba <rtems_termios_baud_to_index+0xfe>
44f00: 6074 bras 44f76 <rtems_termios_baud_to_index+0xba>
44f02: 7206 moveq #6,%d1
44f04: b280 cmpl %d0,%d1
44f06: 677a beqs 44f82 <rtems_termios_baud_to_index+0xc6>
44f08: 6e74 bgts 44f7e <rtems_termios_baud_to_index+0xc2>
44f0a: 123c 0007 moveb #7,%d1
44f0e: b280 cmpl %d0,%d1
44f10: 6774 beqs 44f86 <rtems_termios_baud_to_index+0xca>
44f12: 123c 0008 moveb #8,%d1
44f16: b280 cmpl %d0,%d1
44f18: 6600 00a0 bnew 44fba <rtems_termios_baud_to_index+0xfe>
44f1c: 606c bras 44f8a <rtems_termios_baud_to_index+0xce>
44f1e: 720e moveq #14,%d1
44f20: b280 cmpl %d0,%d1
44f22: 677e beqs 44fa2 <rtems_termios_baud_to_index+0xe6>
44f24: 6d1c blts 44f42 <rtems_termios_baud_to_index+0x86>
44f26: 123c 000b moveb #11,%d1
44f2a: b280 cmpl %d0,%d1
44f2c: 6768 beqs 44f96 <rtems_termios_baud_to_index+0xda>
44f2e: 6e62 bgts 44f92 <rtems_termios_baud_to_index+0xd6>
44f30: 123c 000c moveb #12,%d1
44f34: b280 cmpl %d0,%d1
44f36: 6762 beqs 44f9a <rtems_termios_baud_to_index+0xde>
44f38: 123c 000d moveb #13,%d1
44f3c: b280 cmpl %d0,%d1
44f3e: 667a bnes 44fba <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44f40: 605c bras 44f9e <rtems_termios_baud_to_index+0xe2>
44f42: 0c80 0000 1002 cmpil #4098,%d0
44f48: 6764 beqs 44fae <rtems_termios_baud_to_index+0xf2>
44f4a: 6e10 bgts 44f5c <rtems_termios_baud_to_index+0xa0>
44f4c: 720f moveq #15,%d1
44f4e: b280 cmpl %d0,%d1
44f50: 6754 beqs 44fa6 <rtems_termios_baud_to_index+0xea>
44f52: 0c80 0000 1001 cmpil #4097,%d0
44f58: 6660 bnes 44fba <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44f5a: 604e bras 44faa <rtems_termios_baud_to_index+0xee>
44f5c: 0c80 0000 1003 cmpil #4099,%d0
44f62: 674e beqs 44fb2 <rtems_termios_baud_to_index+0xf6>
44f64: 0c80 0000 1004 cmpil #4100,%d0
44f6a: 664e bnes 44fba <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44f6c: 6048 bras 44fb6 <rtems_termios_baud_to_index+0xfa>
case B0: baud_index = 0; break;
44f6e: 4280 clrl %d0
44f70: 604e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
44f72: 7002 moveq #2,%d0
44f74: 604a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B110: baud_index = 3; break;
44f76: 7003 moveq #3,%d0
44f78: 6046 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B134: baud_index = 4; break;
44f7a: 7004 moveq #4,%d0
44f7c: 6042 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B150: baud_index = 5; break;
44f7e: 7005 moveq #5,%d0
44f80: 603e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B200: baud_index = 6; break;
44f82: 7006 moveq #6,%d0
44f84: 603a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B300: baud_index = 7; break;
44f86: 7007 moveq #7,%d0
44f88: 6036 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B600: baud_index = 8; break;
44f8a: 7008 moveq #8,%d0
44f8c: 6032 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B1200: baud_index = 9; break;
44f8e: 7009 moveq #9,%d0
44f90: 602e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B1800: baud_index = 10; break;
44f92: 700a moveq #10,%d0
44f94: 602a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B2400: baud_index = 11; break;
44f96: 700b moveq #11,%d0
44f98: 6026 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B4800: baud_index = 12; break;
44f9a: 700c moveq #12,%d0
44f9c: 6022 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B9600: baud_index = 13; break;
44f9e: 700d moveq #13,%d0
44fa0: 601e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B19200: baud_index = 14; break;
44fa2: 700e moveq #14,%d0
44fa4: 601a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B38400: baud_index = 15; break;
44fa6: 700f moveq #15,%d0
44fa8: 6016 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B57600: baud_index = 16; break;
44faa: 7010 moveq #16,%d0
44fac: 6012 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B115200: baud_index = 17; break;
44fae: 7011 moveq #17,%d0
44fb0: 600e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B230400: baud_index = 18; break;
44fb2: 7012 moveq #18,%d0
44fb4: 600a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B460800: baud_index = 19; break;
44fb6: 7013 moveq #19,%d0
44fb8: 6006 bras 44fc0 <rtems_termios_baud_to_index+0x104>
default: baud_index = -1; break;
44fba: 70ff moveq #-1,%d0
44fbc: 6002 bras 44fc0 <rtems_termios_baud_to_index+0x104>
{
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
44fbe: 7001 moveq #1,%d0
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
44fc0: 4e5e unlk %fp <== NOT EXECUTED
00043d80 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
43d80: 4e56 fff4 linkw %fp,#-12
43d84: 48d7 1c00 moveml %a2-%a4,%sp@
43d88: 266e 0008 moveal %fp@(8),%a3
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
43d8c: 49f9 0004 59e0 lea 459e0 <rtems_semaphore_obtain>,%a4
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
43d92: 2053 moveal %a3@,%a0
43d94: 2468 0034 moveal %a0@(52),%a2
rtems_status_code sc;
sc = rtems_semaphore_obtain(
43d98: 42a7 clrl %sp@-
43d9a: 42a7 clrl %sp@-
43d9c: 2f39 0005 ea88 movel 5ea88 <rtems_termios_ttyMutex>,%sp@-
43da2: 4e94 jsr %a4@
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
43da4: 4fef 000c lea %sp@(12),%sp
43da8: 4a80 tstl %d0
43daa: 6600 0084 bnew 43e30 <rtems_termios_close+0xb0>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
43dae: 202a 0008 movel %a2@(8),%d0
43db2: 5380 subql #1,%d0
43db4: 2540 0008 movel %d0,%a2@(8)
43db8: 6600 0120 bnew 43eda <rtems_termios_close+0x15a>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
43dbc: 202a 00cc movel %a2@(204),%d0
43dc0: eb88 lsll #5,%d0
43dc2: 0680 0005 e250 addil #385616,%d0
43dc8: 2240 moveal %d0,%a1
43dca: 2051 moveal %a1@,%a0
43dcc: 4a88 tstl %a0
43dce: 6706 beqs 43dd6 <rtems_termios_close+0x56>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
43dd0: 2f0a movel %a2,%sp@-
43dd2: 4e90 jsr %a0@
43dd4: 602a bras 43e00 <rtems_termios_close+0x80>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
43dd6: 42a7 clrl %sp@-
43dd8: 42a7 clrl %sp@-
43dda: 2f2a 0018 movel %a2@(24),%sp@-
43dde: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL) {
43de0: 4fef 000c lea %sp@(12),%sp
43de4: 4a80 tstl %d0
43de6: 6648 bnes 43e30 <rtems_termios_close+0xb0> <== NEVER TAKEN
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
43de8: 4aaa 00b4 tstl %a2@(180)
43dec: 6708 beqs 43df6 <rtems_termios_close+0x76>
43dee: 2f0a movel %a2,%sp@-
43df0: 4eba fb4a jsr %pc@(4393c <drainOutput.part.0>)
43df4: 588f addql #4,%sp
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
43df6: 2f2a 0018 movel %a2@(24),%sp@-
43dfa: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
43e00: 588f addql #4,%sp
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43e02: 7002 moveq #2,%d0
43e04: b0aa 00b4 cmpl %a2@(180),%d0
43e08: 662e bnes 43e38 <rtems_termios_close+0xb8>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
43e0a: 4878 0001 pea 1 <ADD>
43e0e: 49f9 0004 5584 lea 45584 <rtems_event_send>,%a4
43e14: 2f2a 00c4 movel %a2@(196),%sp@-
43e18: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL)
43e1a: 508f addql #8,%sp
43e1c: 4a80 tstl %d0
43e1e: 6610 bnes 43e30 <rtems_termios_close+0xb0> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
43e20: 4878 0001 pea 1 <ADD>
43e24: 2f2a 00c8 movel %a2@(200),%sp@-
43e28: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL)
43e2a: 508f addql #8,%sp
43e2c: 4a80 tstl %d0
43e2e: 6708 beqs 43e38 <rtems_termios_close+0xb8> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
43e30: 2f00 movel %d0,%sp@- <== NOT EXECUTED
43e32: 4eb9 0004 60a4 jsr 460a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (tty->device.lastClose)
43e38: 206a 009c moveal %a2@(156),%a0
43e3c: 4a88 tstl %a0
43e3e: 6710 beqs 43e50 <rtems_termios_close+0xd0>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
43e40: 2f0b movel %a3,%sp@-
43e42: 2f2a 0010 movel %a2@(16),%sp@-
43e46: 2f2a 000c movel %a2@(12),%sp@-
43e4a: 4e90 jsr %a0@
43e4c: 4fef 000c lea %sp@(12),%sp
if (tty->forw == NULL) {
43e50: 2252 moveal %a2@,%a1
43e52: 206a 0004 moveal %a2@(4),%a0
43e56: 4a89 tstl %a1
43e58: 660c bnes 43e66 <rtems_termios_close+0xe6>
rtems_termios_ttyTail = tty->back;
43e5a: 23c8 0005 ea8c movel %a0,5ea8c <rtems_termios_ttyTail>
if ( rtems_termios_ttyTail != NULL ) {
43e60: 6708 beqs 43e6a <rtems_termios_close+0xea> <== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
43e62: 4290 clrl %a0@ <== NOT EXECUTED
43e64: 6004 bras 43e6a <rtems_termios_close+0xea> <== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
43e66: 2348 0004 movel %a0,%a1@(4)
}
if (tty->back == NULL) {
43e6a: 226a 0004 moveal %a2@(4),%a1
43e6e: 2052 moveal %a2@,%a0
43e70: 4a89 tstl %a1
43e72: 660e bnes 43e82 <rtems_termios_close+0x102> <== NEVER TAKEN
rtems_termios_ttyHead = tty->forw;
43e74: 23c8 0005 ea90 movel %a0,5ea90 <rtems_termios_ttyHead>
if ( rtems_termios_ttyHead != NULL ) {
43e7a: 6708 beqs 43e84 <rtems_termios_close+0x104>
rtems_termios_ttyHead->back = NULL;
43e7c: 42a8 0004 clrl %a0@(4)
43e80: 6002 bras 43e84 <rtems_termios_close+0x104>
}
} else {
tty->back->forw = tty->forw;
43e82: 2288 movel %a0,%a1@ <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
43e84: 2f2a 0014 movel %a2@(20),%sp@-
43e88: 47f9 0004 5944 lea 45944 <rtems_semaphore_delete>,%a3
43e8e: 4e93 jsr %a3@
rtems_semaphore_delete (tty->osem);
43e90: 2f2a 0018 movel %a2@(24),%sp@-
43e94: 4e93 jsr %a3@
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
43e96: 2f2a 008c movel %a2@(140),%sp@-
43e9a: 4e93 jsr %a3@
if ((tty->device.pollRead == NULL) ||
43e9c: 4fef 000c lea %sp@(12),%sp
43ea0: 4aaa 00a0 tstl %a2@(160)
43ea4: 6708 beqs 43eae <rtems_termios_close+0x12e>
43ea6: 7002 moveq #2,%d0
43ea8: b0aa 00b4 cmpl %a2@(180),%d0
43eac: 660c bnes 43eba <rtems_termios_close+0x13a>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
43eae: 2f2a 0068 movel %a2@(104),%sp@-
43eb2: 4eb9 0004 5944 jsr 45944 <rtems_semaphore_delete>
43eb8: 588f addql #4,%sp
free (tty->rawInBuf.theBuf);
43eba: 2f2a 0058 movel %a2@(88),%sp@-
43ebe: 47f9 0004 2b68 lea 42b68 <free>,%a3
43ec4: 4e93 jsr %a3@
free (tty->rawOutBuf.theBuf);
43ec6: 2f2a 007c movel %a2@(124),%sp@-
43eca: 4e93 jsr %a3@
free (tty->cbuf);
43ecc: 2f2a 001c movel %a2@(28),%sp@-
43ed0: 4e93 jsr %a3@
free (tty);
43ed2: 2f0a movel %a2,%sp@-
43ed4: 4e93 jsr %a3@
43ed6: 4fef 0010 lea %sp@(16),%sp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
43eda: 2f39 0005 ea88 movel 5ea88 <rtems_termios_ttyMutex>,%sp@-
43ee0: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
43ee6: 4cee 1c00 fff4 moveml %fp@(-12),%a2-%a4
43eec: 4280 clrl %d0
43eee: 4e5e unlk %fp <== NOT EXECUTED
000450e2 <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
450e2: 4e56 0000 linkw %fp,#0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
450e6: 202e 000c movel %fp@(12),%d0
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
450ea: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
450ee: d1a8 0090 addl %d0,%a0@(144)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
450f2: 7002 moveq #2,%d0
450f4: b0a8 00b4 cmpl %a0@(180),%d0
450f8: 661c bnes 45116 <rtems_termios_dequeue_characters+0x34>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
450fa: 4878 0002 pea 2 <DOUBLE_FLOAT>
450fe: 2f28 00c8 movel %a0@(200),%sp@-
45102: 4eb9 0004 5584 jsr 45584 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
45108: 508f addql #8,%sp
4510a: 4a80 tstl %d0
4510c: 672e beqs 4513c <rtems_termios_dequeue_characters+0x5a><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
4510e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
45110: 4eb9 0004 60a4 jsr 460a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
45116: 7005 moveq #5,%d0
45118: b0a8 00cc cmpl %a0@(204),%d0
4511c: 6612 bnes 45130 <rtems_termios_dequeue_characters+0x4e>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
4511e: 2279 0005 e300 moveal 5e300 <rtems_termios_linesw+0xb4>,%a1
45124: 4a89 tstl %a1
45126: 6714 beqs 4513c <rtems_termios_dequeue_characters+0x5a><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
45128: 2f08 movel %a0,%sp@-
4512a: 4e91 jsr %a1@
4512c: 588f addql #4,%sp
4512e: 600c bras 4513c <rtems_termios_dequeue_characters+0x5a>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
45130: 2d48 0008 movel %a0,%fp@(8)
}
45134: 4e5e unlk %fp
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
45136: 4ef9 0004 4ec6 jmp 44ec6 <rtems_termios_refill_transmitter>
}
4513c: 4280 clrl %d0
4513e: 4e5e unlk %fp
...
00044c00 <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
44c00: 4e56 ffcc linkw %fp,#-52
44c04: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
44c08: 246e 0008 moveal %fp@(8),%a2
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
44c0c: 202a 00cc movel %a2@(204),%d0
44c10: eb88 lsll #5,%d0
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
44c12: 266e 000c moveal %fp@(12),%a3
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
44c16: 0680 0005 e25c addil #385628,%d0
44c1c: 2040 moveal %d0,%a0
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
44c1e: 242e 0010 movel %fp@(16),%d2
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
44c22: 4a90 tstl %a0@
44c24: 663c bnes 44c62 <rtems_termios_enqueue_raw_characters+0x62>
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
44c26: 43ea 004a lea %a2@(74),%a1
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
44c2a: 4bf3 2800 lea %a3@(00000000,%d2:l),%a5
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
44c2e: 283c 0000 0700 movel #1792,%d4
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
44c34: 4282 clrl %d2
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44c36: 49ea 0030 lea %a2@(48),%a4
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
44c3a: 2d49 fff4 movel %a1,%fp@(-12)
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
44c3e: 4205 clrb %d5
44c40: 6000 01ee braw 44e30 <rtems_termios_enqueue_raw_characters+0x230>
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
44c44: 202a 00cc movel %a2@(204),%d0
44c48: 5382 subql #1,%d2
44c4a: 2f0a movel %a2,%sp@-
44c4c: 121b moveb %a3@+,%d1
44c4e: eb88 lsll #5,%d0
44c50: 49c1 extbl %d1
44c52: 0680 0005 e25c addil #385628,%d0
44c58: 2240 moveal %d0,%a1
44c5a: 2f01 movel %d1,%sp@-
44c5c: 2051 moveal %a1@,%a0
44c5e: 4e90 jsr %a0@
44c60: 508f addql #8,%sp
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
44c62: 4a82 tstl %d2
44c64: 66de bnes 44c44 <rtems_termios_enqueue_raw_characters+0x44>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
44c66: 4aaa 00e4 tstl %a2@(228)
44c6a: 6600 01dc bnew 44e48 <rtems_termios_enqueue_raw_characters+0x248>
44c6e: 206a 00dc moveal %a2@(220),%a0
44c72: 4a88 tstl %a0
44c74: 6700 01d2 beqw 44e48 <rtems_termios_enqueue_raw_characters+0x248>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44c78: 2f2a 00e0 movel %a2@(224),%sp@-
44c7c: 486a 0030 pea %a2@(48)
44c80: 4e90 jsr %a0@
tty->tty_rcvwakeup = 1;
44c82: 508f addql #8,%sp
44c84: 7001 moveq #1,%d0
44c86: 2540 00e4 movel %d0,%a2@(228)
44c8a: 6000 01be braw 44e4a <rtems_termios_enqueue_raw_characters+0x24a>
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
44c8e: 202a 00b8 movel %a2@(184),%d0
}
return 0;
}
while (len--) {
c = *buf++;
44c92: 1c1b moveb %a3@+,%d6
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
44c94: 0800 0009 btst #9,%d0
44c98: 6740 beqs 44cda <rtems_termios_enqueue_raw_characters+0xda>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
44c9a: 4283 clrl %d3
44c9c: 162a 004a moveb %a2@(74),%d3
44ca0: 4281 clrl %d1
44ca2: 122a 0049 moveb %a2@(73),%d1
44ca6: 1006 moveb %d6,%d0
44ca8: 49c0 extbl %d0
44caa: b680 cmpl %d0,%d3
44cac: 661e bnes 44ccc <rtems_termios_enqueue_raw_characters+0xcc>
if (c == tty->termios.c_cc[VSTART]) {
44cae: b280 cmpl %d0,%d1
44cb0: 660a bnes 44cbc <rtems_termios_enqueue_raw_characters+0xbc><== ALWAYS TAKEN
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
44cb2: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44cb6: 7210 moveq #16,%d1 <== NOT EXECUTED
44cb8: b380 eorl %d1,%d0 <== NOT EXECUTED
44cba: 6008 bras 44cc4 <rtems_termios_enqueue_raw_characters+0xc4><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
44cbc: 202a 00b8 movel %a2@(184),%d0
44cc0: 7e10 moveq #16,%d7
44cc2: 8087 orl %d7,%d0
44cc4: 2540 00b8 movel %d0,%a2@(184)
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
44cc8: 7a01 moveq #1,%d5
44cca: 6012 bras 44cde <rtems_termios_enqueue_raw_characters+0xde>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
44ccc: b280 cmpl %d0,%d1
44cce: 660a bnes 44cda <rtems_termios_enqueue_raw_characters+0xda><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
44cd0: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44cd4: 72ef moveq #-17,%d1 <== NOT EXECUTED
44cd6: c081 andl %d1,%d0 <== NOT EXECUTED
44cd8: 60ea bras 44cc4 <rtems_termios_enqueue_raw_characters+0xc4><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
44cda: 4a05 tstb %d5
44cdc: 674c beqs 44d2a <rtems_termios_enqueue_raw_characters+0x12a><== ALWAYS TAKEN
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
44cde: 202a 00b8 movel %a2@(184),%d0
44ce2: 7e30 moveq #48,%d7
44ce4: 7220 moveq #32,%d1
44ce6: c087 andl %d7,%d0
44ce8: b280 cmpl %d0,%d1
44cea: 6600 0144 bnew 44e30 <rtems_termios_enqueue_raw_characters+0x230>
/* disable interrupts */
rtems_interrupt_disable(level);
44cee: 2004 movel %d4,%d0 <== NOT EXECUTED
44cf0: 40c3 movew %sr,%d3 <== NOT EXECUTED
44cf2: 8083 orl %d3,%d0 <== NOT EXECUTED
44cf4: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
44cf6: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44cfa: 7edf moveq #-33,%d7 <== NOT EXECUTED
44cfc: c087 andl %d7,%d0 <== NOT EXECUTED
44cfe: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
44d02: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED
44d06: 671c beqs 44d24 <rtems_termios_enqueue_raw_characters+0x124><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
44d08: 202a 0084 movel %a2@(132),%d0 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
44d0c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44d10: d0aa 007c addl %a2@(124),%d0 <== NOT EXECUTED
44d14: 2f00 movel %d0,%sp@- <== NOT EXECUTED
44d16: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44d1a: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44d1e: 4e90 jsr %a0@ <== NOT EXECUTED
44d20: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
44d24: 46c3 movew %d3,%sr <== NOT EXECUTED
44d26: 6000 0108 braw 44e30 <rtems_termios_enqueue_raw_characters+0x230><== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
44d2a: 222a 0060 movel %a2@(96),%d1
44d2e: 5281 addql #1,%d1
44d30: 202a 0064 movel %a2@(100),%d0
44d34: 4c40 1003 remul %d0,%d3,%d1
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
44d38: 2004 movel %d4,%d0
44d3a: 40c1 movew %sr,%d1
44d3c: 8081 orl %d1,%d0
44d3e: 46c0 movew %d0,%sr
44d40: 2d41 fffc movel %d1,%fp@(-4)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
44d44: 206a 005c moveal %a2@(92),%a0
44d48: 202a 0064 movel %a2@(100),%d0
44d4c: 9088 subl %a0,%d0
44d4e: 2240 moveal %d0,%a1
44d50: d3c3 addal %d3,%a1
% tty->rawInBuf.Size) > tty->highwater) &&
44d52: 2009 movel %a1,%d0
44d54: 2e2a 0064 movel %a2@(100),%d7
44d58: 4c47 0001 remul %d7,%d1,%d0
44d5c: 2d47 fff8 movel %d7,%fp@(-8)
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
44d60: b2aa 00c0 cmpl %a2@(192),%d1
44d64: 6300 008e blsw 44df4 <rtems_termios_enqueue_raw_characters+0x1f4>
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
44d68: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
44d6c: 0800 0000 btst #0,%d0 <== NOT EXECUTED
44d70: 6600 0082 bnew 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
44d74: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44d78: 7e01 moveq #1,%d7 <== NOT EXECUTED
44d7a: 8087 orl %d7,%d0 <== NOT EXECUTED
44d7c: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
44d80: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44d84: 0280 0000 0402 andil #1026,%d0 <== NOT EXECUTED
44d8a: 0c80 0000 0400 cmpil #1024,%d0 <== NOT EXECUTED
44d90: 6634 bnes 44dc6 <rtems_termios_enqueue_raw_characters+0x1c6><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
44d92: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44d96: 0800 0005 btst #5,%d0 <== NOT EXECUTED
44d9a: 6606 bnes 44da2 <rtems_termios_enqueue_raw_characters+0x1a2><== NOT EXECUTED
44d9c: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED
44da0: 6652 bnes 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
44da2: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44da6: 7202 moveq #2,%d1 <== NOT EXECUTED
44da8: 8081 orl %d1,%d0 <== NOT EXECUTED
44daa: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
44dae: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44db2: 2f2e fff4 movel %fp@(-12),%sp@- <== NOT EXECUTED
44db6: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44dba: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44dbe: 4e90 jsr %a0@ <== NOT EXECUTED
44dc0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44dc4: 602e bras 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
44dc6: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44dca: 0280 0000 0104 andil #260,%d0 <== NOT EXECUTED
44dd0: 0c80 0000 0100 cmpil #256,%d0 <== NOT EXECUTED
44dd6: 661c bnes 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
44dd8: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44ddc: 7e04 moveq #4,%d7 <== NOT EXECUTED
44dde: 8087 orl %d7,%d0 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
44de0: 206a 00ac moveal %a2@(172),%a0 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
44de4: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
44de8: 4a88 tstl %a0 <== NOT EXECUTED
44dea: 6708 beqs 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
44dec: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44df0: 4e90 jsr %a0@ <== NOT EXECUTED
44df2: 588f addql #4,%sp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
44df4: 222e fffc movel %fp@(-4),%d1
44df8: 46c1 movew %d1,%sr
if (newTail == tty->rawInBuf.Head) {
44dfa: 202a 005c movel %a2@(92),%d0
44dfe: b083 cmpl %d3,%d0
44e00: 6604 bnes 44e06 <rtems_termios_enqueue_raw_characters+0x206><== ALWAYS TAKEN
dropped++;
44e02: 5282 addql #1,%d2 <== NOT EXECUTED
44e04: 602a bras 44e30 <rtems_termios_enqueue_raw_characters+0x230><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
44e06: 206a 0058 moveal %a2@(88),%a0
44e0a: 1186 3800 moveb %d6,%a0@(00000000,%d3:l)
tty->rawInBuf.Tail = newTail;
44e0e: 2543 0060 movel %d3,%a2@(96)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
44e12: 4aaa 00e4 tstl %a2@(228)
44e16: 6618 bnes 44e30 <rtems_termios_enqueue_raw_characters+0x230><== NEVER TAKEN
44e18: 206a 00dc moveal %a2@(220),%a0
44e1c: 4a88 tstl %a0
44e1e: 6710 beqs 44e30 <rtems_termios_enqueue_raw_characters+0x230><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44e20: 2f2a 00e0 movel %a2@(224),%sp@- <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
44e24: 7e01 moveq #1,%d7 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44e26: 2f0c movel %a4,%sp@- <== NOT EXECUTED
44e28: 4e90 jsr %a0@ <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
44e2a: 508f addql #8,%sp <== NOT EXECUTED
44e2c: 2547 00e4 movel %d7,%a2@(228) <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
44e30: bbcb cmpal %a3,%a5
44e32: 6600 fe5a bnew 44c8e <rtems_termios_enqueue_raw_characters+0x8e>
}
}
}
}
tty->rawInBufDropped += dropped;
44e36: d5aa 0078 addl %d2,%a2@(120)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
44e3a: 2f2a 0068 movel %a2@(104),%sp@-
44e3e: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return dropped;
44e44: 588f addql #4,%sp
44e46: 6002 bras 44e4a <rtems_termios_enqueue_raw_characters+0x24a>
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
44e48: 4282 clrl %d2
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
44e4a: 2002 movel %d2,%d0
44e4c: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5
44e52: 4e5e unlk %fp <== NOT EXECUTED
00043f1a <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
43f1a: 4e56 ffec linkw %fp,#-20
43f1e: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@
43f22: 266e 0008 moveal %fp@(8),%a3
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
43f26: 2053 moveal %a3@,%a0
43f28: 2468 0034 moveal %a0@(52),%a2
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
43f2c: 286b 0008 moveal %a3@(8),%a4
rtems_status_code sc;
args->ioctl_return = 0;
43f30: 42ab 000c clrl %a3@(12)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
43f34: 42a7 clrl %sp@-
43f36: 42a7 clrl %sp@-
43f38: 2f2a 0018 movel %a2@(24),%sp@-
43f3c: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
43f42: 4fef 000c lea %sp@(12),%sp
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
43f46: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
43f48: 6708 beqs 43f52 <rtems_termios_ioctl+0x38> <== ALWAYS TAKEN
args->ioctl_return = sc;
43f4a: 2740 000c movel %d0,%a3@(12) <== NOT EXECUTED
return sc;
43f4e: 6000 02d4 braw 44224 <rtems_termios_ioctl+0x30a> <== NOT EXECUTED
}
switch (args->command) {
43f52: 202b 0004 movel %a3@(4),%d0
43f56: 7204 moveq #4,%d1
43f58: b280 cmpl %d0,%d1
43f5a: 6700 023a beqw 44196 <rtems_termios_ioctl+0x27c>
43f5e: 6514 bcss 43f74 <rtems_termios_ioctl+0x5a>
43f60: 7602 moveq #2,%d3
43f62: b680 cmpl %d0,%d3
43f64: 6778 beqs 43fde <rtems_termios_ioctl+0xc4>
43f66: 6500 020e bcsw 44176 <rtems_termios_ioctl+0x25c>
43f6a: 123c 0001 moveb #1,%d1
43f6e: b280 cmpl %d0,%d1
43f70: 6630 bnes 43fa2 <rtems_termios_ioctl+0x88> <== NEVER TAKEN
43f72: 6050 bras 43fc4 <rtems_termios_ioctl+0xaa>
43f74: 0c80 4004 667f cmpil #1074030207,%d0
43f7a: 6700 0272 beqw 441ee <rtems_termios_ioctl+0x2d4>
43f7e: 620a bhis 43f8a <rtems_termios_ioctl+0x70>
43f80: 7605 moveq #5,%d3
43f82: b680 cmpl %d0,%d3
43f84: 661c bnes 43fa2 <rtems_termios_ioctl+0x88>
43f86: 6000 01fe braw 44186 <rtems_termios_ioctl+0x26c>
43f8a: 222a 00cc movel %a2@(204),%d1
43f8e: 0c80 4004 741a cmpil #1074033690,%d0
43f94: 6700 0252 beqw 441e8 <rtems_termios_ioctl+0x2ce>
43f98: 0c80 8004 741b cmpil #-2147191781,%d0
43f9e: 6700 0206 beqw 441a6 <rtems_termios_ioctl+0x28c>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
43fa2: 202a 00cc movel %a2@(204),%d0
43fa6: eb88 lsll #5,%d0
43fa8: 0680 0005 e264 addil #385636,%d0
43fae: 2240 moveal %d0,%a1
43fb0: 2051 moveal %a1@,%a0
43fb2: 4a88 tstl %a0
43fb4: 6700 025c beqw 44212 <rtems_termios_ioctl+0x2f8>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
43fb8: 2f0b movel %a3,%sp@-
43fba: 2f0a movel %a2,%sp@-
43fbc: 4e90 jsr %a0@
43fbe: 2400 movel %d0,%d2
43fc0: 6000 01ae braw 44170 <rtems_termios_ioctl+0x256>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
43fc4: 4878 0024 pea 24 <OPER2+0x10>
43fc8: 486a 0030 pea %a2@(48)
43fcc: 2f2b 0008 movel %a3@(8),%sp@-
43fd0: 4eb9 0004 d588 jsr 4d588 <memcpy>
break;
43fd6: 4fef 000c lea %sp@(12),%sp
43fda: 6000 0238 braw 44214 <rtems_termios_ioctl+0x2fa>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
43fde: 4878 0024 pea 24 <OPER2+0x10>
43fe2: 2f2b 0008 movel %a3@(8),%sp@-
43fe6: 486a 0030 pea %a2@(48)
43fea: 4eb9 0004 d588 jsr 4d588 <memcpy>
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
43ff0: 202a 00b8 movel %a2@(184),%d0
43ff4: 4fef 000c lea %sp@(12),%sp
43ff8: 0800 0009 btst #9,%d0
43ffc: 6760 beqs 4405e <rtems_termios_ioctl+0x144>
!(tty->termios.c_iflag & IXON)) {
43ffe: 202a 0030 movel %a2@(48),%d0
44002: 0280 0000 0400 andil #1024,%d0
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
44008: 6654 bnes 4405e <rtems_termios_ioctl+0x144>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
4400a: 202a 00b8 movel %a2@(184),%d0
4400e: 0280 ffff fdef andil #-529,%d0
44014: 2540 00b8 movel %d0,%a2@(184)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
44018: 202a 00b8 movel %a2@(184),%d0
4401c: 0800 0005 btst #5,%d0
44020: 673c beqs 4405e <rtems_termios_ioctl+0x144> <== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
44022: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
44028: 40c3 movew %sr,%d3 <== NOT EXECUTED
4402a: 8083 orl %d3,%d0 <== NOT EXECUTED
4402c: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
4402e: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44032: 72df moveq #-33,%d1 <== NOT EXECUTED
44034: c081 andl %d1,%d0 <== NOT EXECUTED
44036: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4403a: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED
4403e: 671c beqs 4405c <rtems_termios_ioctl+0x142> <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
44040: 202a 0084 movel %a2@(132),%d0 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
44044: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44048: d0aa 007c addl %a2@(124),%d0 <== NOT EXECUTED
4404c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4404e: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44052: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44056: 4e90 jsr %a0@ <== NOT EXECUTED
44058: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
4405c: 46c3 movew %d3,%sr <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
4405e: 202a 00b8 movel %a2@(184),%d0
44062: 0800 000a btst #10,%d0
44066: 6724 beqs 4408c <rtems_termios_ioctl+0x172>
44068: 202a 0030 movel %a2@(48),%d0
4406c: 0280 0000 1000 andil #4096,%d0
44072: 6618 bnes 4408c <rtems_termios_ioctl+0x172> <== NEVER TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
44074: 202a 00b8 movel %a2@(184),%d0
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
44078: 76fd moveq #-3,%d3
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
4407a: 0880 000a bclr #10,%d0
4407e: 2540 00b8 movel %d0,%a2@(184)
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
44082: 202a 00b8 movel %a2@(184),%d0
44086: c083 andl %d3,%d0
44088: 2540 00b8 movel %d0,%a2@(184)
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
4408c: 202a 00b8 movel %a2@(184),%d0
44090: 0800 0008 btst #8,%d0
44094: 6736 beqs 440cc <rtems_termios_ioctl+0x1b2> <== ALWAYS TAKEN
44096: 4aaa 0038 tstl %a2@(56) <== NOT EXECUTED
4409a: 6d30 blts 440cc <rtems_termios_ioctl+0x1b2> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
4409c: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
440a0: 0880 0008 bclr #8,%d0 <== NOT EXECUTED
440a4: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
440a8: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
440ac: 44c0 movew %d0,%ccr <== NOT EXECUTED
440ae: 6610 bnes 440c0 <rtems_termios_ioctl+0x1a6> <== NOT EXECUTED
440b0: 206a 00b0 moveal %a2@(176),%a0 <== NOT EXECUTED
440b4: 4a88 tstl %a0 <== NOT EXECUTED
440b6: 6708 beqs 440c0 <rtems_termios_ioctl+0x1a6> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
440b8: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
440bc: 4e90 jsr %a0@ <== NOT EXECUTED
440be: 588f addql #4,%sp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
440c0: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
440c4: 72fb moveq #-5,%d1 <== NOT EXECUTED
440c6: c081 andl %d1,%d0 <== NOT EXECUTED
440c8: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
440cc: 4aaa 0038 tstl %a2@(56)
440d0: 6c0c bges 440de <rtems_termios_ioctl+0x1c4> <== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
440d2: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
440d6: 08c0 0008 bset #8,%d0 <== NOT EXECUTED
440da: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
440de: 222a 0030 movel %a2@(48),%d1
440e2: 0801 000c btst #12,%d1
440e6: 670c beqs 440f4 <rtems_termios_ioctl+0x1da>
tty->flow_ctrl |= FL_MDXOF;
440e8: 202a 00b8 movel %a2@(184),%d0
440ec: 08c0 000a bset #10,%d0
440f0: 2540 00b8 movel %d0,%a2@(184)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
440f4: 0801 000a btst #10,%d1
440f8: 670c beqs 44106 <rtems_termios_ioctl+0x1ec>
tty->flow_ctrl |= FL_MDXON;
440fa: 202a 00b8 movel %a2@(184),%d0
440fe: 08c0 0009 bset #9,%d0
44102: 2540 00b8 movel %d0,%a2@(184)
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
44106: 7002 moveq #2,%d0
44108: c0aa 003c andl %a2@(60),%d0
4410c: 663a bnes 44148 <rtems_termios_ioctl+0x22e>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
4410e: 4283 clrl %d3
44110: 162a 0046 moveb %a2@(70),%d3
rtems_clock_get_ticks_per_second() / 10;
44114: 4eb9 0004 539c jsr 4539c <rtems_clock_get_ticks_per_second>
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
4411a: 4c03 0800 mulsl %d3,%d0
rtems_clock_get_ticks_per_second() / 10;
4411e: 760a moveq #10,%d3
44120: 4c43 0000 remul %d3,%d0,%d0
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
44124: 2540 0054 movel %d0,%a2@(84)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
44128: 4a2a 0046 tstb %a2@(70)
4412c: 6714 beqs 44142 <rtems_termios_ioctl+0x228>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4412e: 42aa 006c clrl %a2@(108)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
44132: 2540 0070 movel %d0,%a2@(112)
if (tty->termios.c_cc[VMIN])
44136: 4a2a 0047 tstb %a2@(71)
4413a: 6614 bnes 44150 <rtems_termios_ioctl+0x236>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
4413c: 2540 0074 movel %d0,%a2@(116)
44140: 601a bras 4415c <rtems_termios_ioctl+0x242>
} else {
if (tty->termios.c_cc[VMIN]) {
44142: 4a2a 0047 tstb %a2@(71)
44146: 670e beqs 44156 <rtems_termios_ioctl+0x23c> <== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
44148: 42aa 006c clrl %a2@(108)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
4414c: 42aa 0070 clrl %a2@(112)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
44150: 42aa 0074 clrl %a2@(116)
44154: 6006 bras 4415c <rtems_termios_ioctl+0x242>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
44156: 7001 moveq #1,%d0
44158: 2540 006c movel %d0,%a2@(108)
}
}
}
if (tty->device.setAttributes)
4415c: 206a 00a8 moveal %a2@(168),%a0
44160: 4a88 tstl %a0
44162: 6700 00b0 beqw 44214 <rtems_termios_ioctl+0x2fa>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
44166: 486a 0030 pea %a2@(48)
4416a: 2f2a 0010 movel %a2@(16),%sp@-
4416e: 4e90 jsr %a0@
44170: 508f addql #8,%sp
44172: 6000 00a0 braw 44214 <rtems_termios_ioctl+0x2fa>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
44176: 4aaa 00b4 tstl %a2@(180)
4417a: 6700 0098 beqw 44214 <rtems_termios_ioctl+0x2fa>
4417e: 2f0a movel %a2,%sp@-
44180: 4eba f7ba jsr %pc@(4393c <drainOutput.part.0>)
44184: 605e bras 441e4 <rtems_termios_ioctl+0x2ca>
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
44186: 2014 movel %a4@,%d0
44188: 222c 0004 movel %a4@(4),%d1
4418c: 2540 00d4 movel %d0,%a2@(212)
44190: 2541 00d8 movel %d1,%a2@(216)
break;
44194: 607e bras 44214 <rtems_termios_ioctl+0x2fa>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
44196: 2014 movel %a4@,%d0
44198: 222c 0004 movel %a4@(4),%d1
4419c: 2540 00dc movel %d0,%a2@(220)
441a0: 2541 00e0 movel %d1,%a2@(224)
break;
441a4: 606e bras 44214 <rtems_termios_ioctl+0x2fa>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
441a6: 2001 movel %d1,%d0
441a8: eb88 lsll #5,%d0
441aa: 0680 0005 e250 addil #385616,%d0
441b0: 2240 moveal %d0,%a1
441b2: 2051 moveal %a1@,%a0
441b4: 4a88 tstl %a0
441b6: 6708 beqs 441c0 <rtems_termios_ioctl+0x2a6>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
441b8: 2f0a movel %a2,%sp@-
441ba: 4e90 jsr %a0@
441bc: 588f addql #4,%sp
441be: 2400 movel %d0,%d2
}
tty->t_line=*(int*)(args->buffer);
441c0: 206b 0008 moveal %a3@(8),%a0
441c4: 2010 movel %a0@,%d0
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
441c6: 41f9 0005 e24c lea 5e24c <rtems_termios_linesw>,%a0
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
441cc: 2540 00cc movel %d0,%a2@(204)
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
441d0: eb88 lsll #5,%d0
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
tty->t_sc = NULL; /* ensure that no more valid data */
441d2: 42aa 00d0 clrl %a2@(208)
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
441d6: 2070 0800 moveal %a0@(00000000,%d0:l),%a0
441da: 4a88 tstl %a0
441dc: 6736 beqs 44214 <rtems_termios_ioctl+0x2fa>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
441de: 2f0a movel %a2,%sp@-
441e0: 4e90 jsr %a0@
441e2: 2400 movel %d0,%d2
441e4: 588f addql #4,%sp
441e6: 602c bras 44214 <rtems_termios_ioctl+0x2fa>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
441e8: 206b 0008 moveal %a3@(8),%a0
441ec: 6020 bras 4420e <rtems_termios_ioctl+0x2f4>
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
441ee: 202a 0060 movel %a2@(96),%d0 <== NOT EXECUTED
441f2: 222a 005c movel %a2@(92),%d1 <== NOT EXECUTED
441f6: 9081 subl %d1,%d0 <== NOT EXECUTED
if ( rawnc < 0 )
441f8: 6a06 bpls 44200 <rtems_termios_ioctl+0x2e6> <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
441fa: 222a 0064 movel %a2@(100),%d1 <== NOT EXECUTED
441fe: d081 addl %d1,%d0 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
44200: 222a 0020 movel %a2@(32),%d1 <== NOT EXECUTED
44204: 92aa 0024 subl %a2@(36),%d1 <== NOT EXECUTED
44208: d280 addl %d0,%d1 <== NOT EXECUTED
4420a: 206b 0008 moveal %a3@(8),%a0 <== NOT EXECUTED
4420e: 2081 movel %d1,%a0@
}
break;
44210: 6002 bras 44214 <rtems_termios_ioctl+0x2fa>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
44212: 740a moveq #10,%d2 <== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
44214: 2f2a 0018 movel %a2@(24),%sp@-
44218: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
args->ioctl_return = sc;
return sc;
4421e: 588f addql #4,%sp
}
break;
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
44220: 2742 000c movel %d2,%a3@(12)
return sc;
}
44224: 2002 movel %d2,%d0
44226: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
4422c: 4e5e unlk %fp <== NOT EXECUTED
000439a0 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
439a0: 4e56 ffdc linkw %fp,#-36
439a4: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
439a8: 42a7 clrl %sp@-
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
439aa: 282e 0008 movel %fp@(8),%d4
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
439ae: 42a7 clrl %sp@-
439b0: 2f39 0005 ea88 movel 5ea88 <rtems_termios_ttyMutex>,%sp@-
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
439b6: 2a2e 000c movel %fp@(12),%d5
439ba: 2a6e 0010 moveal %fp@(16),%a5
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
439be: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
439c4: 4fef 000c lea %sp@(12),%sp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
439c8: 2400 movel %d0,%d2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
439ca: 6600 038c bnew 43d58 <rtems_termios_open+0x3b8>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
439ce: 2679 0005 ea90 moveal 5ea90 <rtems_termios_ttyHead>,%a3
439d4: 244b moveal %a3,%a2
439d6: 6010 bras 439e8 <rtems_termios_open+0x48>
if ((tty->major == major) && (tty->minor == minor))
439d8: b8aa 000c cmpl %a2@(12),%d4
439dc: 6608 bnes 439e6 <rtems_termios_open+0x46>
439de: baaa 0010 cmpl %a2@(16),%d5
439e2: 6700 02fe beqw 43ce2 <rtems_termios_open+0x342>
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
439e6: 2452 moveal %a2@,%a2
439e8: 4a8a tstl %a2
439ea: 66ec bnes 439d8 <rtems_termios_open+0x38>
439ec: 6000 0376 braw 43d64 <rtems_termios_open+0x3c4>
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
rtems_semaphore_release (rtems_termios_ttyMutex);
439f0: 2f39 0005 ea88 movel 5ea88 <rtems_termios_ttyMutex>,%sp@-
439f6: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
439fc: 588f addql #4,%sp
439fe: 6038 bras 43a38 <rtems_termios_open+0x98>
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
43a00: 41f9 0005 d410 lea 5d410 <rtems_termios_raw_input_size>,%a0
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
43a06: 49f9 0004 2e54 lea 42e54 <malloc>,%a4
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
43a0c: 2550 0064 movel %a0@,%a2@(100)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
43a10: 202a 0064 movel %a2@(100),%d0
43a14: 2f00 movel %d0,%sp@-
43a16: 4e94 jsr %a4@
if (tty->rawInBuf.theBuf == NULL) {
43a18: 588f addql #4,%sp
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
43a1a: 2600 movel %d0,%d3
43a1c: 2540 0058 movel %d0,%a2@(88)
if (tty->rawInBuf.theBuf == NULL) {
43a20: 661c bnes 43a3e <rtems_termios_open+0x9e>
free(tty);
43a22: 2f0a movel %a2,%sp@-
43a24: 4eb9 0004 2b68 jsr 42b68 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
43a2a: 2f39 0005 ea88 movel 5ea88 <rtems_termios_ttyMutex>,%sp@-
43a30: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
43a36: 508f addql #8,%sp
43a38: 741a moveq #26,%d2
43a3a: 6000 031c braw 43d58 <rtems_termios_open+0x3b8>
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
43a3e: 41f9 0005 d414 lea 5d414 <rtems_termios_raw_output_size>,%a0
43a44: 2550 0088 movel %a0@,%a2@(136)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
43a48: 202a 0088 movel %a2@(136),%d0
43a4c: 2f00 movel %d0,%sp@-
43a4e: 4e94 jsr %a4@
if (tty->rawOutBuf.theBuf == NULL) {
43a50: 588f addql #4,%sp
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
43a52: 2c00 movel %d0,%d6
43a54: 2540 007c movel %d0,%a2@(124)
if (tty->rawOutBuf.theBuf == NULL) {
43a58: 6620 bnes 43a7a <rtems_termios_open+0xda> <== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
43a5a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
43a5c: 47f9 0004 2b68 lea 42b68 <free>,%a3 <== NOT EXECUTED
43a62: 4e93 jsr %a3@ <== NOT EXECUTED
free(tty);
43a64: 2f0a movel %a2,%sp@- <== NOT EXECUTED
43a66: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
43a68: 2f39 0005 ea88 movel 5ea88 <rtems_termios_ttyMutex>,%sp@- <== NOT EXECUTED
43a6e: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
43a74: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
43a78: 60be bras 43a38 <rtems_termios_open+0x98> <== NOT EXECUTED
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
43a7a: 2f39 0005 d418 movel 5d418 <rtems_termios_cbufsize>,%sp@-
43a80: 4e94 jsr %a4@
if (tty->cbuf == NULL) {
43a82: 588f addql #4,%sp
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
43a84: 2540 001c movel %d0,%a2@(28)
if (tty->cbuf == NULL) {
43a88: 6624 bnes 43aae <rtems_termios_open+0x10e>
free((void *)(tty->rawOutBuf.theBuf));
43a8a: 2f06 movel %d6,%sp@-
43a8c: 47f9 0004 2b68 lea 42b68 <free>,%a3
43a92: 4e93 jsr %a3@
free((void *)(tty->rawInBuf.theBuf));
43a94: 2f03 movel %d3,%sp@-
43a96: 4e93 jsr %a3@
free(tty);
43a98: 2f0a movel %a2,%sp@-
43a9a: 4e93 jsr %a3@
rtems_semaphore_release (rtems_termios_ttyMutex);
43a9c: 2f39 0005 ea88 movel 5ea88 <rtems_termios_ttyMutex>,%sp@-
43aa2: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
43aa8: 4fef 0010 lea %sp@(16),%sp
43aac: 608a bras 43a38 <rtems_termios_open+0x98>
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
43aae: 42aa 00d4 clrl %a2@(212)
tty->tty_snd.sw_arg = NULL;
43ab2: 42aa 00d8 clrl %a2@(216)
tty->tty_rcv.sw_pfn = NULL;
43ab6: 42aa 00dc clrl %a2@(220)
tty->tty_rcv.sw_arg = NULL;
43aba: 42aa 00e0 clrl %a2@(224)
tty->tty_rcvwakeup = 0;
43abe: 42aa 00e4 clrl %a2@(228)
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
43ac2: 248b movel %a3,%a2@
tty->back = NULL;
43ac4: 42aa 0004 clrl %a2@(4)
if (rtems_termios_ttyHead != NULL)
43ac8: 4a8b tstl %a3
43aca: 6704 beqs 43ad0 <rtems_termios_open+0x130>
rtems_termios_ttyHead->back = tty;
43acc: 274a 0004 movel %a2,%a3@(4)
rtems_termios_ttyHead = tty;
43ad0: 23ca 0005 ea90 movel %a2,5ea90 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
43ad6: 4ab9 0005 ea8c tstl 5ea8c <rtems_termios_ttyTail>
43adc: 6606 bnes 43ae4 <rtems_termios_open+0x144>
rtems_termios_ttyTail = tty;
43ade: 23ca 0005 ea8c movel %a2,5ea8c <rtems_termios_ttyTail>
tty->minor = minor;
43ae4: 2545 0010 movel %d5,%a2@(16)
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43ae8: 47f9 0004 57a4 lea 457a4 <rtems_semaphore_create>,%a3
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
tty->major = major;
43aee: 2544 000c movel %d4,%a2@(12)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43af2: 486a 0014 pea %a2@(20)
rtems_build_name ('T', 'R', 'i', c),
43af6: 1039 0005 d41c moveb 5d41c <c.6381>,%d0
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43afc: 42a7 clrl %sp@-
43afe: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
rtems_build_name ('T', 'R', 'i', c),
43b02: 49c0 extbl %d0
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43b04: 4878 0001 pea 1 <ADD>
43b08: 0080 5452 6900 oril #1414686976,%d0
43b0e: 2f00 movel %d0,%sp@-
43b10: 4e93 jsr %a3@
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
43b12: 4fef 0014 lea %sp@(20),%sp
43b16: 4a80 tstl %d0
43b18: 6600 0228 bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b1c: 486a 0018 pea %a2@(24)
rtems_build_name ('T', 'R', 'o', c),
43b20: 1039 0005 d41c moveb 5d41c <c.6381>,%d0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b26: 42a7 clrl %sp@-
43b28: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
rtems_build_name ('T', 'R', 'o', c),
43b2c: 49c0 extbl %d0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b2e: 4878 0001 pea 1 <ADD>
43b32: 0080 5452 6f00 oril #1414688512,%d0
43b38: 2f00 movel %d0,%sp@-
43b3a: 4e93 jsr %a3@
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
43b3c: 4fef 0014 lea %sp@(20),%sp
43b40: 4a80 tstl %d0
43b42: 6600 01fe bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b46: 486a 008c pea %a2@(140)
rtems_build_name ('T', 'R', 'x', c),
43b4a: 1039 0005 d41c moveb 5d41c <c.6381>,%d0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b50: 42a7 clrl %sp@-
43b52: 4878 0020 pea 20 <OPER2+0xc>
rtems_build_name ('T', 'R', 'x', c),
43b56: 49c0 extbl %d0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b58: 0080 5452 7800 oril #1414690816,%d0
43b5e: 42a7 clrl %sp@-
43b60: 2f00 movel %d0,%sp@-
43b62: 4e93 jsr %a3@
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
43b64: 4fef 0014 lea %sp@(20),%sp
43b68: 4a80 tstl %d0
43b6a: 6600 01d6 bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
43b6e: 42aa 0094 clrl %a2@(148)
/*
* Set callbacks
*/
tty->device = *callbacks;
43b72: 4878 0020 pea 20 <OPER2+0xc>
43b76: 2f2e 0014 movel %fp@(20),%sp@-
43b7a: 486a 0098 pea %a2@(152)
43b7e: 4eb9 0004 d588 jsr 4d588 <memcpy>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43b84: 4fef 000c lea %sp@(12),%sp
43b88: 7002 moveq #2,%d0
43b8a: b0aa 00b4 cmpl %a2@(180),%d0
43b8e: 6662 bnes 43bf2 <rtems_termios_open+0x252>
sc = rtems_task_create (
43b90: 486a 00c8 pea %a2@(200)
43b94: 47f9 0004 5b98 lea 45b98 <rtems_task_create>,%a3
rtems_build_name ('T', 'x', 'T', c),
43b9a: 1039 0005 d41c moveb 5d41c <c.6381>,%d0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
43ba0: 42a7 clrl %sp@-
43ba2: 4878 0500 pea 500 <DBL_MAX_EXP+0xff>
rtems_build_name ('T', 'x', 'T', c),
43ba6: 49c0 extbl %d0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
43ba8: 4878 0400 pea 400 <D_BIAS+0x2>
43bac: 4878 000a pea a <LASTO>
43bb0: 0080 5478 5400 oril #1417171968,%d0
43bb6: 2f00 movel %d0,%sp@-
43bb8: 4e93 jsr %a3@
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
43bba: 4fef 0018 lea %sp@(24),%sp
43bbe: 4a80 tstl %d0
43bc0: 6600 0180 bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
43bc4: 486a 00c4 pea %a2@(196)
rtems_build_name ('R', 'x', 'T', c),
43bc8: 1039 0005 d41c moveb 5d41c <c.6381>,%d0
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
43bce: 42a7 clrl %sp@-
43bd0: 4878 0500 pea 500 <DBL_MAX_EXP+0xff>
rtems_build_name ('R', 'x', 'T', c),
43bd4: 49c0 extbl %d0
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
43bd6: 4878 0400 pea 400 <D_BIAS+0x2>
43bda: 4878 0009 pea 9 <DIVIDE_BY_ZERO+0x1>
43bde: 0080 5278 5400 oril #1383617536,%d0
43be4: 2f00 movel %d0,%sp@-
43be6: 4e93 jsr %a3@
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
43be8: 4fef 0018 lea %sp@(24),%sp
43bec: 4a80 tstl %d0
43bee: 6600 0152 bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
43bf2: 4aaa 00a0 tstl %a2@(160)
43bf6: 6708 beqs 43c00 <rtems_termios_open+0x260>
43bf8: 7202 moveq #2,%d1
43bfa: b2aa 00b4 cmpl %a2@(180),%d1
43bfe: 662c bnes 43c2c <rtems_termios_open+0x28c>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43c00: 486a 0068 pea %a2@(104)
rtems_build_name ('T', 'R', 'r', c),
43c04: 1039 0005 d41c moveb 5d41c <c.6381>,%d0
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43c0a: 42a7 clrl %sp@-
43c0c: 4878 0024 pea 24 <OPER2+0x10>
rtems_build_name ('T', 'R', 'r', c),
43c10: 49c0 extbl %d0
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43c12: 0080 5452 7200 oril #1414689280,%d0
43c18: 42a7 clrl %sp@-
43c1a: 2f00 movel %d0,%sp@-
43c1c: 4eb9 0004 57a4 jsr 457a4 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
43c22: 4fef 0014 lea %sp@(20),%sp
43c26: 4a80 tstl %d0
43c28: 6600 0118 bnew 43d42 <rtems_termios_open+0x3a2>
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
43c2c: 203c 0000 1805 movel #6149,%d0
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
43c32: 223c 0000 08bd movel #2237,%d1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
43c38: 307c 2502 moveaw #9474,%a0
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
43c3c: 2540 0034 movel %d0,%a2@(52)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
43c40: 7003 moveq #3,%d0
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
43c42: 2541 0038 movel %d1,%a2@(56)
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
43c46: 1540 0041 moveb %d0,%a2@(65)
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
43c4a: 42aa 00b8 clrl %a2@(184)
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
43c4e: 707f moveq #127,%d0
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
43c50: 721c moveq #28,%d1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
43c52: 2548 0030 movel %a0,%a2@(48)
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
43c56: 1540 0043 moveb %d0,%a2@(67)
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
43c5a: 7004 moveq #4,%d0
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
43c5c: 1541 0042 moveb %d1,%a2@(66)
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
43c60: 1540 0045 moveb %d0,%a2@(69)
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
43c64: 7011 moveq #17,%d0
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
43c66: 7215 moveq #21,%d1
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
43c68: 1540 0049 moveb %d0,%a2@(73)
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
43c6c: 701a moveq #26,%d0
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
43c6e: 207c 0000 823b moveal #33339,%a0
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
43c74: 1540 004b moveb %d0,%a2@(75)
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
43c78: 700f moveq #15,%d0
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
43c7a: 1541 0044 moveb %d1,%a2@(68)
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
43c7e: 2548 003c movel %a0,%a2@(60)
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
43c82: 1540 004e moveb %d0,%a2@(78)
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
43c86: 7016 moveq #22,%d0
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
43c88: 4201 clrb %d1
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
43c8a: 1540 0050 moveb %d0,%a2@(80)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
43c8e: 202a 0064 movel %a2@(100),%d0
43c92: e288 lsrl #1,%d0
tty->highwater = tty->rawInBuf.Size * 3/4;
43c94: 206a 0064 moveal %a2@(100),%a0
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
43c98: 1541 004c moveb %d1,%a2@(76)
tty->termios.c_cc[VEOL2] = '\000';
43c9c: 1541 0051 moveb %d1,%a2@(81)
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
43ca0: 7213 moveq #19,%d1
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
43ca2: 41f0 8a00 lea %a0@(00000000,%a0:l:2),%a0
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
43ca6: 2540 00bc movel %d0,%a2@(188)
tty->highwater = tty->rawInBuf.Size * 3/4;
43caa: 2008 movel %a0,%d0
43cac: e488 lsrl #2,%d0
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
43cae: 1541 004a moveb %d1,%a2@(74)
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
43cb2: 7212 moveq #18,%d1
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
43cb4: 2540 00c0 movel %d0,%a2@(192)
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
43cb8: 1541 004d moveb %d1,%a2@(77)
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
43cbc: 7217 moveq #23,%d1
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
43cbe: 1039 0005 d41c moveb 5d41c <c.6381>,%d0
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
43cc4: 1541 004f moveb %d1,%a2@(79)
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
43cc8: 49c0 extbl %d0
43cca: 2200 movel %d0,%d1
43ccc: 5281 addql #1,%d1
43cce: 13c1 0005 d41c moveb %d1,5d41c <c.6381>
43cd4: 727a moveq #122,%d1
43cd6: b280 cmpl %d0,%d1
43cd8: 6608 bnes 43ce2 <rtems_termios_open+0x342>
c = 'a';
43cda: 7061 moveq #97,%d0
43cdc: 13c0 0005 d41c moveb %d0,5d41c <c.6381>
}
args->iop->data1 = tty;
43ce2: 2055 moveal %a5@,%a0
if (!tty->refcount++) {
43ce4: 202a 0008 movel %a2@(8),%d0
43ce8: 2200 movel %d0,%d1
43cea: 5281 addql #1,%d1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
43cec: 214a 0034 movel %a2,%a0@(52)
if (!tty->refcount++) {
43cf0: 2541 0008 movel %d1,%a2@(8)
43cf4: 4a80 tstl %d0
43cf6: 6652 bnes 43d4a <rtems_termios_open+0x3aa>
if (tty->device.firstOpen)
43cf8: 206a 0098 moveal %a2@(152),%a0
43cfc: 4a88 tstl %a0
43cfe: 670c beqs 43d0c <rtems_termios_open+0x36c>
(*tty->device.firstOpen)(major, minor, arg);
43d00: 2f0d movel %a5,%sp@-
43d02: 2f05 movel %d5,%sp@-
43d04: 2f04 movel %d4,%sp@-
43d06: 4e90 jsr %a0@
43d08: 4fef 000c lea %sp@(12),%sp
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43d0c: 7002 moveq #2,%d0
43d0e: b0aa 00b4 cmpl %a2@(180),%d0
43d12: 6636 bnes 43d4a <rtems_termios_open+0x3aa>
sc = rtems_task_start(
43d14: 2f0a movel %a2,%sp@-
43d16: 487a 113e pea %pc@(44e56 <rtems_termios_rxdaemon>)
43d1a: 47f9 0004 5e18 lea 45e18 <rtems_task_start>,%a3
43d20: 2f2a 00c4 movel %a2@(196),%sp@-
43d24: 4e93 jsr %a3@
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
43d26: 4fef 000c lea %sp@(12),%sp
43d2a: 4a80 tstl %d0
43d2c: 6614 bnes 43d42 <rtems_termios_open+0x3a2> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
43d2e: 2f0a movel %a2,%sp@-
43d30: 487a 1348 pea %pc@(4507a <rtems_termios_txdaemon>)
43d34: 2f2a 00c8 movel %a2@(200),%sp@-
43d38: 4e93 jsr %a3@
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
43d3a: 4fef 000c lea %sp@(12),%sp
43d3e: 4a80 tstl %d0
43d40: 6708 beqs 43d4a <rtems_termios_open+0x3aa>
rtems_fatal_error_occurred (sc);
43d42: 2f00 movel %d0,%sp@-
43d44: 4eb9 0004 60a4 jsr 460a4 <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
43d4a: 2f39 0005 ea88 movel 5ea88 <rtems_termios_ttyMutex>,%sp@-
43d50: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
43d56: 588f addql #4,%sp
}
43d58: 2002 movel %d2,%d0
43d5a: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
43d60: 4e5e unlk %fp
43d62: 4e75 rts
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
43d64: 4878 00e8 pea e8 <DBL_MANT_DIG+0xb3>
43d68: 4878 0001 pea 1 <ADD>
43d6c: 4eb9 0004 27cc jsr 427cc <calloc>
if (tty == NULL) {
43d72: 508f addql #8,%sp
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
43d74: 2440 moveal %d0,%a2
if (tty == NULL) {
43d76: 4a80 tstl %d0
43d78: 6600 fc86 bnew 43a00 <rtems_termios_open+0x60>
43d7c: 6000 fc72 braw 439f0 <rtems_termios_open+0x50>
00044230 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
44230: 4e56 ffe0 linkw %fp,#-32
44234: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@
44238: 266e 0008 moveal %fp@(8),%a3
4423c: 242e 000c movel %fp@(12),%d2
44240: 246e 0010 moveal %fp@(16),%a2
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
44244: 4aaa 00b4 tstl %a2@(180)
44248: 661c bnes 44266 <rtems_termios_puts+0x36>
(*tty->device.write)(tty->minor, buf, len);
4424a: 2d42 0010 movel %d2,%fp@(16)
4424e: 2d4b 000c movel %a3,%fp@(12)
44252: 2d6a 0010 0008 movel %a2@(16),%fp@(8)
44258: 226a 00a4 moveal %a2@(164),%a1
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
4425c: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
44262: 4e5e unlk %fp
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
44264: 4ed1 jmp %a1@
return;
}
newHead = tty->rawOutBuf.Head;
44266: 2c2a 0080 movel %a2@(128),%d6
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
4426a: 2a3c 0000 0700 movel #1792,%d5
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
44270: 49f9 0004 59e0 lea 459e0 <rtems_semaphore_obtain>,%a4
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
44276: 6000 0096 braw 4430e <rtems_termios_puts+0xde>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
4427a: 202a 0088 movel %a2@(136),%d0
4427e: 5286 addql #1,%d6
44280: 4c40 6004 remul %d0,%d4,%d6
44284: 2c04 movel %d4,%d6
44286: 6022 bras 442aa <rtems_termios_puts+0x7a>
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
44288: 7002 moveq #2,%d0
4428a: 2540 0094 movel %d0,%a2@(148)
rtems_interrupt_enable (level);
4428e: 46c3 movew %d3,%sr
sc = rtems_semaphore_obtain(
44290: 42a7 clrl %sp@-
44292: 42a7 clrl %sp@-
44294: 2f2a 008c movel %a2@(140),%sp@-
44298: 4e94 jsr %a4@
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4429a: 4fef 000c lea %sp@(12),%sp
4429e: 4a80 tstl %d0
442a0: 6708 beqs 442aa <rtems_termios_puts+0x7a> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
442a2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
442a4: 4eb9 0004 60a4 jsr 460a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
442aa: 2005 movel %d5,%d0
442ac: 40c3 movew %sr,%d3
442ae: 8083 orl %d3,%d0
442b0: 46c0 movew %d0,%sr
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
442b2: 202a 0084 movel %a2@(132),%d0
442b6: b084 cmpl %d4,%d0
442b8: 67ce beqs 44288 <rtems_termios_puts+0x58>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
442ba: 202a 0080 movel %a2@(128),%d0
442be: 206a 007c moveal %a2@(124),%a0
442c2: 119b 0800 moveb %a3@+,%a0@(00000000,%d0:l)
tty->rawOutBuf.Head = newHead;
442c6: 2544 0080 movel %d4,%a2@(128)
if (tty->rawOutBufState == rob_idle) {
442ca: 4aaa 0094 tstl %a2@(148)
442ce: 663a bnes 4430a <rtems_termios_puts+0xda>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
442d0: 202a 00b8 movel %a2@(184),%d0
442d4: 0800 0004 btst #4,%d0
442d8: 661e bnes 442f8 <rtems_termios_puts+0xc8> <== NEVER TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
442da: 202a 0084 movel %a2@(132),%d0
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
442de: 4878 0001 pea 1 <ADD>
442e2: d0aa 007c addl %a2@(124),%d0
442e6: 2f00 movel %d0,%sp@-
442e8: 2f2a 0010 movel %a2@(16),%sp@-
442ec: 206a 00a4 moveal %a2@(164),%a0
442f0: 4e90 jsr %a0@
442f2: 4fef 000c lea %sp@(12),%sp
442f6: 600c bras 44304 <rtems_termios_puts+0xd4>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
442f8: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
442fc: 7220 moveq #32,%d1 <== NOT EXECUTED
442fe: 8081 orl %d1,%d0 <== NOT EXECUTED
44300: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
44304: 7001 moveq #1,%d0
44306: 2540 0094 movel %d0,%a2@(148)
}
rtems_interrupt_enable (level);
4430a: 46c3 movew %d3,%sr
len--;
4430c: 5382 subql #1,%d2
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
4430e: 4a82 tstl %d2
44310: 6600 ff68 bnew 4427a <rtems_termios_puts+0x4a>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
44314: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
4431a: 4e5e unlk %fp <== NOT EXECUTED
0004490e <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
4490e: 4e56 ffd4 linkw %fp,#-44
44912: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
44916: 266e 0008 moveal %fp@(8),%a3
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4491a: 2053 moveal %a3@,%a0
uint32_t count = args->count;
4491c: 262b 0010 movel %a3@(16),%d3
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
44920: 2468 0034 moveal %a0@(52),%a2
uint32_t count = args->count;
char *buffer = args->buffer;
44924: 2a6b 000c moveal %a3@(12),%a5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44928: 42a7 clrl %sp@-
4492a: 42a7 clrl %sp@-
4492c: 2f2a 0014 movel %a2@(20),%sp@-
44930: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
44936: 4fef 000c lea %sp@(12),%sp
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4493a: 2800 movel %d0,%d4
if (sc != RTEMS_SUCCESSFUL)
4493c: 6600 029a bnew 44bd8 <rtems_termios_read+0x2ca>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
44940: 202a 00cc movel %a2@(204),%d0
44944: eb88 lsll #5,%d0
44946: 0680 0005 e254 addil #385620,%d0
4494c: 2240 moveal %d0,%a1
4494e: 2051 moveal %a1@,%a0
44950: 4a88 tstl %a0
44952: 671e beqs 44972 <rtems_termios_read+0x64>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
44954: 2f0b movel %a3,%sp@-
44956: 2f0a movel %a2,%sp@-
44958: 4e90 jsr %a0@
4495a: 2800 movel %d0,%d4
tty->tty_rcvwakeup = 0;
4495c: 42aa 00e4 clrl %a2@(228)
rtems_semaphore_release (tty->isem);
44960: 2f2a 0014 movel %a2@(20),%sp@-
44964: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return sc;
4496a: 4fef 000c lea %sp@(12),%sp
4496e: 6000 0268 braw 44bd8 <rtems_termios_read+0x2ca>
}
if (tty->cindex == tty->ccount) {
44972: 202a 0020 movel %a2@(32),%d0
44976: b0aa 0024 cmpl %a2@(36),%d0
4497a: 6600 0234 bnew 44bb0 <rtems_termios_read+0x2a2>
tty->cindex = tty->ccount = 0;
4497e: 42aa 0020 clrl %a2@(32)
tty->read_start_column = tty->column;
44982: 256a 0028 002c movel %a2@(40),%a2@(44)
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
44988: 42aa 0024 clrl %a2@(36)
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
4498c: 4aaa 00a0 tstl %a2@(160)
44990: 6700 00da beqw 44a6c <rtems_termios_read+0x15e>
44994: 4aaa 00b4 tstl %a2@(180)
44998: 6600 00d2 bnew 44a6c <rtems_termios_read+0x15e>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
4499c: 7002 moveq #2,%d0
4499e: c0aa 003c andl %a2@(60),%d0
449a2: 673e beqs 449e2 <rtems_termios_read+0xd4> <== NEVER TAKEN
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
449a4: 49f9 0004 5ec0 lea 45ec0 <rtems_task_wake_after>,%a4
} else {
if (siproc (n, tty))
449aa: 243c 0004 47e2 movel #280546,%d2
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
449b0: 2f2a 0010 movel %a2@(16),%sp@-
449b4: 206a 00a0 moveal %a2@(160),%a0
449b8: 4e90 jsr %a0@
if (n < 0) {
449ba: 588f addql #4,%sp
449bc: 4a80 tstl %d0
449be: 6c0a bges 449ca <rtems_termios_read+0xbc>
rtems_task_wake_after (1);
449c0: 4878 0001 pea 1 <ADD>
449c4: 4e94 jsr %a4@
449c6: 588f addql #4,%sp
449c8: 60e6 bras 449b0 <rtems_termios_read+0xa2>
} else {
if (siproc (n, tty))
449ca: 2f0a movel %a2,%sp@-
449cc: 2042 moveal %d2,%a0
449ce: 0280 0000 00ff andil #255,%d0
449d4: 2f00 movel %d0,%sp@-
449d6: 4e90 jsr %a0@
449d8: 508f addql #8,%sp
449da: 4a80 tstl %d0
449dc: 67d2 beqs 449b0 <rtems_termios_read+0xa2>
449de: 6000 01d0 braw 44bb0 <rtems_termios_read+0x2a2>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
449e2: 49f9 0004 53b4 lea 453b4 <rtems_clock_get_ticks_since_boot>,%a4
449e8: 4e94 jsr %a4@
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
449ea: 2c3c 0004 5ec0 movel #286400,%d6
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
449f0: 2400 movel %d0,%d2
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
449f2: 2a3c 0004 47e2 movel #280546,%d5
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
449f8: 2f2a 0010 movel %a2@(16),%sp@-
449fc: 206a 00a0 moveal %a2@(160),%a0
44a00: 4e90 jsr %a0@
if (n < 0) {
44a02: 588f addql #4,%sp
44a04: 4a80 tstl %d0
44a06: 6c34 bges 44a3c <rtems_termios_read+0x12e>
if (tty->termios.c_cc[VMIN]) {
44a08: 4a2a 0047 tstb %a2@(71)
44a0c: 670e beqs 44a1c <rtems_termios_read+0x10e> <== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
44a0e: 4a2a 0046 tstb %a2@(70)
44a12: 671c beqs 44a30 <rtems_termios_read+0x122> <== NEVER TAKEN
44a14: 4aaa 0020 tstl %a2@(32)
44a18: 6716 beqs 44a30 <rtems_termios_read+0x122>
44a1a: 6008 bras 44a24 <rtems_termios_read+0x116>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
44a1c: 4a2a 0046 tstb %a2@(70) <== NOT EXECUTED
44a20: 6700 018e beqw 44bb0 <rtems_termios_read+0x2a2> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
44a24: 4e94 jsr %a4@
if ((now - then) > tty->vtimeTicks) {
44a26: 9082 subl %d2,%d0
44a28: b0aa 0054 cmpl %a2@(84),%d0
44a2c: 6200 0182 bhiw 44bb0 <rtems_termios_read+0x2a2>
break;
}
}
rtems_task_wake_after (1);
44a30: 4878 0001 pea 1 <ADD>
44a34: 2246 moveal %d6,%a1
44a36: 4e91 jsr %a1@
44a38: 588f addql #4,%sp
44a3a: 60bc bras 449f8 <rtems_termios_read+0xea>
} else {
siproc (n, tty);
44a3c: 2f0a movel %a2,%sp@-
44a3e: 2045 moveal %d5,%a0
44a40: 0280 0000 00ff andil #255,%d0
44a46: 2f00 movel %d0,%sp@-
44a48: 4e90 jsr %a0@
if (tty->ccount >= tty->termios.c_cc[VMIN])
44a4a: 508f addql #8,%sp
44a4c: 4281 clrl %d1
44a4e: 102a 0047 moveb %a2@(71),%d0
44a52: 1200 moveb %d0,%d1
44a54: b2aa 0020 cmpl %a2@(32),%d1
44a58: 6f00 0156 blew 44bb0 <rtems_termios_read+0x2a2>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
44a5c: 4a00 tstb %d0
44a5e: 6798 beqs 449f8 <rtems_termios_read+0xea> <== NEVER TAKEN
44a60: 4a2a 0046 tstb %a2@(70)
44a64: 6792 beqs 449f8 <rtems_termios_read+0xea> <== NEVER TAKEN
then = rtems_clock_get_ticks_since_boot();
44a66: 4e94 jsr %a4@
44a68: 2400 movel %d0,%d2
44a6a: 608c bras 449f8 <rtems_termios_read+0xea>
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
44a6c: 2e0a movel %a2,%d7
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
44a6e: 7401 moveq #1,%d2
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
44a70: 49fa fd70 lea %pc@(447e2 <siproc>),%a4
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
44a74: 0687 0000 0049 addil #73,%d7
/*
* Wait for characters
*/
if ( wait ) {
sc = rtems_semaphore_obtain(
44a7a: 2c3c 0004 59e0 movel #285152,%d6
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
44a80: 2a2a 0074 movel %a2@(116),%d5
44a84: 6000 00e2 braw 44b68 <rtems_termios_read+0x25a>
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
44a88: 2a2a 005c movel %a2@(92),%d5
44a8c: 5285 addql #1,%d5
44a8e: 202a 0064 movel %a2@(100),%d0
c = tty->rawInBuf.theBuf[newHead];
44a92: 206a 0058 moveal %a2@(88),%a0
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
44a96: 4c40 5001 remul %d0,%d1,%d5
c = tty->rawInBuf.theBuf[newHead];
44a9a: 1a30 1800 moveb %a0@(00000000,%d1:l),%d5
tty->rawInBuf.Head = newHead;
44a9e: 2541 005c movel %d1,%a2@(92)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
44aa2: 202a 0060 movel %a2@(96),%d0
44aa6: 226a 0064 moveal %a2@(100),%a1
44aaa: 43f1 0800 lea %a1@(00000000,%d0:l),%a1
44aae: 93c1 subal %d1,%a1
% tty->rawInBuf.Size)
44ab0: 2009 movel %a1,%d0
44ab2: 206a 0064 moveal %a2@(100),%a0
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
44ab6: 1d45 ffff moveb %d5,%fp@(-1)
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
44aba: 2a08 movel %a0,%d5
44abc: 4c45 0001 remul %d5,%d1,%d0
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
44ac0: b2aa 00bc cmpl %a2@(188),%d1
44ac4: 646a bccs 44b30 <rtems_termios_read+0x222> <== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
44ac6: 202a 00b8 movel %a2@(184),%d0
44aca: 72fe moveq #-2,%d1
44acc: c081 andl %d1,%d0
44ace: 2540 00b8 movel %d0,%a2@(184)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
44ad2: 202a 00b8 movel %a2@(184),%d0
44ad6: 0280 0000 0202 andil #514,%d0
44adc: 0c80 0000 0202 cmpil #514,%d0
44ae2: 6626 bnes 44b0a <rtems_termios_read+0x1fc> <== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
44ae4: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED
44ae8: 670a beqs 44af4 <rtems_termios_read+0x1e6> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
44aea: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44aee: 0800 0005 btst #5,%d0 <== NOT EXECUTED
44af2: 6716 beqs 44b0a <rtems_termios_read+0x1fc> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
44af4: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44af8: 2f07 movel %d7,%sp@- <== NOT EXECUTED
44afa: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44afe: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44b02: 4e90 jsr %a0@ <== NOT EXECUTED
44b04: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44b08: 6026 bras 44b30 <rtems_termios_read+0x222> <== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
44b0a: 202a 00b8 movel %a2@(184),%d0
44b0e: 0800 0008 btst #8,%d0
44b12: 671c beqs 44b30 <rtems_termios_read+0x222> <== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
44b14: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44b18: 7afb moveq #-5,%d5 <== NOT EXECUTED
44b1a: c085 andl %d5,%d0 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
44b1c: 206a 00b0 moveal %a2@(176),%a0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
44b20: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
44b24: 4a88 tstl %a0 <== NOT EXECUTED
44b26: 6708 beqs 44b30 <rtems_termios_read+0x222> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
44b28: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44b2c: 4e90 jsr %a0@ <== NOT EXECUTED
44b2e: 588f addql #4,%sp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
44b30: 7002 moveq #2,%d0
44b32: 4285 clrl %d5
44b34: 1a2e ffff moveb %fp@(-1),%d5
44b38: c0aa 003c andl %a2@(60),%d0
44b3c: 670e beqs 44b4c <rtems_termios_read+0x23e> <== NEVER TAKEN
if (siproc (c, tty))
44b3e: 2f0a movel %a2,%sp@-
44b40: 2f05 movel %d5,%sp@-
44b42: 4e94 jsr %a4@
44b44: 508f addql #8,%sp
wait = 0;
44b46: 4a80 tstl %d0
44b48: 57c0 seq %d0
44b4a: 6014 bras 44b60 <rtems_termios_read+0x252>
} else {
siproc (c, tty);
44b4c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
44b4e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
44b50: 4e94 jsr %a4@ <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
44b52: 508f addql #8,%sp <== NOT EXECUTED
44b54: 4280 clrl %d0 <== NOT EXECUTED
44b56: 102a 0047 moveb %a2@(71),%d0 <== NOT EXECUTED
wait = 0;
44b5a: b0aa 0020 cmpl %a2@(32),%d0 <== NOT EXECUTED
44b5e: 5ec0 sgt %d0 <== NOT EXECUTED
44b60: 49c0 extbl %d0
44b62: c480 andl %d0,%d2
}
timeout = tty->rawInBufSemaphoreTimeout;
44b64: 2a2a 0070 movel %a2@(112),%d5
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
44b68: 222a 005c movel %a2@(92),%d1
44b6c: 202a 0060 movel %a2@(96),%d0
44b70: b081 cmpl %d1,%d0
44b72: 6710 beqs 44b84 <rtems_termios_read+0x276>
(tty->ccount < (CBUFSIZE-1))) {
44b74: 2039 0005 d418 movel 5d418 <rtems_termios_cbufsize>,%d0
44b7a: 5380 subql #1,%d0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
44b7c: b0aa 0020 cmpl %a2@(32),%d0
44b80: 6e00 ff06 bgtw 44a88 <rtems_termios_read+0x17a>
}
/*
* Wait for characters
*/
if ( wait ) {
44b84: 4a82 tstl %d2
44b86: 6728 beqs 44bb0 <rtems_termios_read+0x2a2>
sc = rtems_semaphore_obtain(
44b88: 2f05 movel %d5,%sp@-
44b8a: 2f2a 006c movel %a2@(108),%sp@-
44b8e: 2046 moveal %d6,%a0
44b90: 2f2a 0068 movel %a2@(104),%sp@-
44b94: 4e90 jsr %a0@
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
44b96: 4fef 000c lea %sp@(12),%sp
44b9a: 4a80 tstl %d0
44b9c: 67ca beqs 44b68 <rtems_termios_read+0x25a> <== ALWAYS TAKEN
44b9e: 6010 bras 44bb0 <rtems_termios_read+0x2a2> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
44ba0: 206a 001c moveal %a2@(28),%a0
count--;
44ba4: 5383 subql #1,%d3
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
44ba6: 1af0 0800 moveb %a0@(00000000,%d0:l),%a5@+
44baa: 5280 addql #1,%d0
44bac: 2540 0024 movel %d0,%a2@(36)
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
44bb0: 4a83 tstl %d3
44bb2: 670a beqs 44bbe <rtems_termios_read+0x2b0>
44bb4: 202a 0024 movel %a2@(36),%d0
44bb8: b0aa 0020 cmpl %a2@(32),%d0
44bbc: 6de2 blts 44ba0 <rtems_termios_read+0x292>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
44bbe: 202b 0010 movel %a3@(16),%d0
44bc2: 9083 subl %d3,%d0
44bc4: 2740 0018 movel %d0,%a3@(24)
tty->tty_rcvwakeup = 0;
44bc8: 42aa 00e4 clrl %a2@(228)
rtems_semaphore_release (tty->isem);
44bcc: 2f2a 0014 movel %a2@(20),%sp@-
44bd0: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return sc;
44bd6: 588f addql #4,%sp
}
44bd8: 2004 movel %d4,%d0
44bda: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
44be0: 4e5e unlk %fp <== NOT EXECUTED
00044ec6 <rtems_termios_refill_transmitter>:
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
44ec6: 4e56 fff4 linkw %fp,#-12
44eca: 48d7 040c moveml %d2-%d3/%a2,%sp@
44ece: 246e 0008 moveal %fp@(8),%a2
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
44ed2: 202a 00b8 movel %a2@(184),%d0
44ed6: 0280 0000 0403 andil #1027,%d0
44edc: 0c80 0000 0401 cmpil #1025,%d0
44ee2: 663c bnes 44f20 <rtems_termios_refill_transmitter+0x5a><== ALWAYS TAKEN
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
44ee4: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44ee8: 486a 004a pea %a2@(74) <== NOT EXECUTED
44eec: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44ef0: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44ef4: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_interrupt_disable(level);
44ef6: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
44efc: 40c1 movew %sr,%d1 <== NOT EXECUTED
44efe: 8081 orl %d1,%d0 <== NOT EXECUTED
44f00: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->t_dqlen--;
tty->flow_ctrl |= FL_ISNTXOF;
44f02: 7402 moveq #2,%d2 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
44f04: 53aa 0090 subql #1,%a2@(144) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
44f08: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44f0c: 8082 orl %d2,%d0 <== NOT EXECUTED
44f0e: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
rtems_interrupt_enable(level);
44f12: 46c1 movew %d1,%sr <== NOT EXECUTED
44f14: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
nToSend = 1;
44f18: 143c 0001 moveb #1,%d2 <== NOT EXECUTED
44f1c: 6000 0150 braw 4506e <rtems_termios_refill_transmitter+0x1a8><== NOT EXECUTED
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
44f20: 202a 00b8 movel %a2@(184),%d0
44f24: 7203 moveq #3,%d1
44f26: 7402 moveq #2,%d2
44f28: c081 andl %d1,%d0
44f2a: b480 cmpl %d0,%d2
44f2c: 663a bnes 44f68 <rtems_termios_refill_transmitter+0xa2><== ALWAYS TAKEN
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
44f2e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44f32: 486a 0049 pea %a2@(73) <== NOT EXECUTED
44f36: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44f3a: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44f3e: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_interrupt_disable(level);
44f40: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
44f46: 40c1 movew %sr,%d1 <== NOT EXECUTED
44f48: 8081 orl %d1,%d0 <== NOT EXECUTED
44f4a: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->t_dqlen--;
tty->flow_ctrl &= ~FL_ISNTXOF;
44f4c: 74fd moveq #-3,%d2 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
44f4e: 53aa 0090 subql #1,%a2@(144) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
44f52: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44f56: c082 andl %d2,%d0 <== NOT EXECUTED
44f58: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
rtems_interrupt_enable(level);
44f5c: 46c1 movew %d1,%sr <== NOT EXECUTED
nToSend = 1;
44f5e: 7401 moveq #1,%d2 <== NOT EXECUTED
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
44f60: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44f64: 6000 0108 braw 4506e <rtems_termios_refill_transmitter+0x1a8><== NOT EXECUTED
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
44f68: 222a 0080 movel %a2@(128),%d1
44f6c: 202a 0084 movel %a2@(132),%d0
44f70: b081 cmpl %d1,%d0
44f72: 661a bnes 44f8e <rtems_termios_refill_transmitter+0xc8>
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
44f74: 7002 moveq #2,%d0
44f76: b0aa 0094 cmpl %a2@(148),%d0
44f7a: 6600 00f0 bnew 4506c <rtems_termios_refill_transmitter+0x1a6>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
44f7e: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED
44f82: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release> <== NOT EXECUTED
44f88: 588f addql #4,%sp <== NOT EXECUTED
44f8a: 6000 00e0 braw 4506c <rtems_termios_refill_transmitter+0x1a6><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
44f8e: 203c 0000 0700 movel #1792,%d0
44f94: 40c1 movew %sr,%d1
44f96: 8081 orl %d1,%d0
44f98: 46c0 movew %d0,%sr
len = tty->t_dqlen;
44f9a: 206a 0090 moveal %a2@(144),%a0
tty->t_dqlen = 0;
44f9e: 42aa 0090 clrl %a2@(144)
rtems_interrupt_enable(level);
44fa2: 46c1 movew %d1,%sr
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
44fa4: 222a 0084 movel %a2@(132),%d1
44fa8: d288 addl %a0,%d1
44faa: 202a 0088 movel %a2@(136),%d0
44fae: 4c40 1003 remul %d0,%d3,%d1
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
44fb2: 7202 moveq #2,%d1
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
tty->rawOutBuf.Tail = newTail;
44fb4: 2543 0084 movel %d3,%a2@(132)
if (tty->rawOutBufState == rob_wait) {
44fb8: b2aa 0094 cmpl %a2@(148),%d1
44fbc: 660c bnes 44fca <rtems_termios_refill_transmitter+0x104>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
44fbe: 2f2a 008c movel %a2@(140),%sp@-
44fc2: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
44fc8: 588f addql #4,%sp
}
if (newTail == tty->rawOutBuf.Head) {
44fca: 202a 0080 movel %a2@(128),%d0
44fce: b083 cmpl %d3,%d0
44fd0: 661c bnes 44fee <rtems_termios_refill_transmitter+0x128>
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
44fd2: 206a 00d4 moveal %a2@(212),%a0
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
44fd6: 42aa 0094 clrl %a2@(148)
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
44fda: 4a88 tstl %a0
44fdc: 6700 0086 beqw 45064 <rtems_termios_refill_transmitter+0x19e>
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
44fe0: 2f2a 00d8 movel %a2@(216),%sp@- <== NOT EXECUTED
44fe4: 486a 0030 pea %a2@(48) <== NOT EXECUTED
44fe8: 4e90 jsr %a0@ <== NOT EXECUTED
44fea: 508f addql #8,%sp <== NOT EXECUTED
44fec: 6076 bras 45064 <rtems_termios_refill_transmitter+0x19e><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
44fee: 202a 00b8 movel %a2@(184),%d0
44ff2: 0280 0000 0210 andil #528,%d0
44ff8: 0c80 0000 0210 cmpil #528,%d0
44ffe: 6622 bnes 45022 <rtems_termios_refill_transmitter+0x15c><== ALWAYS TAKEN
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
45000: 303c 0700 movew #1792,%d0 <== NOT EXECUTED
45004: 40c1 movew %sr,%d1 <== NOT EXECUTED
45006: 8081 orl %d1,%d0 <== NOT EXECUTED
45008: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
4500a: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
4500e: 7420 moveq #32,%d2 <== NOT EXECUTED
45010: 8082 orl %d2,%d0 <== NOT EXECUTED
45012: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
45016: 7001 moveq #1,%d0 <== NOT EXECUTED
45018: 2540 0094 movel %d0,%a2@(148) <== NOT EXECUTED
rtems_interrupt_enable(level);
4501c: 46c1 movew %d1,%sr <== NOT EXECUTED
nToSend = 0;
4501e: 4202 clrb %d2 <== NOT EXECUTED
45020: 6044 bras 45066 <rtems_termios_refill_transmitter+0x1a0><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
45022: 202a 0080 movel %a2@(128),%d0
45026: b083 cmpl %d3,%d0
45028: 6406 bccs 45030 <rtems_termios_refill_transmitter+0x16a>
nToSend = tty->rawOutBuf.Size - newTail;
4502a: 242a 0088 movel %a2@(136),%d2
4502e: 6004 bras 45034 <rtems_termios_refill_transmitter+0x16e>
else
nToSend = tty->rawOutBuf.Head - newTail;
45030: 242a 0080 movel %a2@(128),%d2
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
45034: 202a 00b8 movel %a2@(184),%d0
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
45038: 9483 subl %d3,%d2
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
4503a: 0280 0000 0600 andil #1536,%d0
45040: 6702 beqs 45044 <rtems_termios_refill_transmitter+0x17e>
nToSend = 1;
45042: 7401 moveq #1,%d2
}
tty->rawOutBufState = rob_busy; /*apm*/
45044: 7201 moveq #1,%d1
45046: 2541 0094 movel %d1,%a2@(148)
(*tty->device.write)(
4504a: 2f02 movel %d2,%sp@-
4504c: 202a 007c movel %a2@(124),%d0
45050: d083 addl %d3,%d0
45052: 2f00 movel %d0,%sp@-
45054: 2f2a 0010 movel %a2@(16),%sp@-
45058: 206a 00a4 moveal %a2@(164),%a0
4505c: 4e90 jsr %a0@
4505e: 4fef 000c lea %sp@(12),%sp
45062: 6002 bras 45066 <rtems_termios_refill_transmitter+0x1a0>
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
45064: 4282 clrl %d2
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
45066: 2543 0084 movel %d3,%a2@(132)
4506a: 6002 bras 4506e <rtems_termios_refill_transmitter+0x1a8>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
4506c: 4282 clrl %d2
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
4506e: 2002 movel %d2,%d0
45070: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
45076: 4e5e unlk %fp <== NOT EXECUTED
00044e56 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
44e56: 4e56 ffe0 linkw %fp,#-32
44e5a: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44e5e: 260e movel %fp,%d3
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44e60: 240e movel %fp,%d2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44e62: 5d83 subql #6,%d3
44e64: 4bf9 0004 541c lea 4541c <rtems_event_receive>,%a5
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
tty->rxTaskId = 0;
rtems_task_delete(RTEMS_SELF);
44e6a: 49f9 0004 5cbc lea 45cbc <rtems_task_delete>,%a4
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44e70: 5382 subql #1,%d2
44e72: 47f9 0004 4c00 lea 44c00 <rtems_termios_enqueue_raw_characters>,%a3
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
44e78: 246e 0008 moveal %fp@(8),%a2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44e7c: 2f03 movel %d3,%sp@-
44e7e: 42a7 clrl %sp@-
44e80: 4878 0002 pea 2 <DOUBLE_FLOAT>
44e84: 4878 0003 pea 3 <DIVIDE>
44e88: 4e95 jsr %a5@
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
44e8a: 4fef 0010 lea %sp@(16),%sp
44e8e: 7001 moveq #1,%d0
44e90: c0ae fffa andl %fp@(-6),%d0
44e94: 670a beqs 44ea0 <rtems_termios_rxdaemon+0x4a> <== ALWAYS TAKEN
tty->rxTaskId = 0;
44e96: 42aa 00c4 clrl %a2@(196) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
44e9a: 42a7 clrl %sp@- <== NOT EXECUTED
44e9c: 4e94 jsr %a4@ <== NOT EXECUTED
44e9e: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
44ea0: 2f2a 0010 movel %a2@(16),%sp@-
44ea4: 206a 00a0 moveal %a2@(160),%a0
44ea8: 4e90 jsr %a0@
if (c != EOF) {
44eaa: 588f addql #4,%sp
44eac: 72ff moveq #-1,%d1
44eae: b280 cmpl %d0,%d1
44eb0: 67ca beqs 44e7c <rtems_termios_rxdaemon+0x26>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44eb2: 4878 0001 pea 1 <ADD>
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
44eb6: 1d40 ffff moveb %d0,%fp@(-1)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44eba: 2f02 movel %d2,%sp@-
44ebc: 2f0a movel %a2,%sp@-
44ebe: 4e93 jsr %a3@
44ec0: 4fef 000c lea %sp@(12),%sp
44ec4: 60b6 bras 44e7c <rtems_termios_rxdaemon+0x26>
0004507a <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
4507a: 4e56 ffe8 linkw %fp,#-24
4507e: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
45082: 240e movel %fp,%d2
45084: 5982 subql #4,%d2
45086: 4bf9 0004 541c lea 4541c <rtems_event_receive>,%a5
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
tty->txTaskId = 0;
rtems_task_delete(RTEMS_SELF);
4508c: 49f9 0004 5cbc lea 45cbc <rtems_task_delete>,%a4
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
45092: 47f9 0004 4ec6 lea 44ec6 <rtems_termios_refill_transmitter>,%a3
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
45098: 246e 0008 moveal %fp@(8),%a2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
4509c: 2f02 movel %d2,%sp@-
4509e: 42a7 clrl %sp@-
450a0: 4878 0002 pea 2 <DOUBLE_FLOAT>
450a4: 4878 0003 pea 3 <DIVIDE>
450a8: 4e95 jsr %a5@
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
450aa: 4fef 0010 lea %sp@(16),%sp
450ae: 7001 moveq #1,%d0
450b0: c0ae fffc andl %fp@(-4),%d0
450b4: 670a beqs 450c0 <rtems_termios_txdaemon+0x46> <== ALWAYS TAKEN
tty->txTaskId = 0;
450b6: 42aa 00c8 clrl %a2@(200) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
450ba: 42a7 clrl %sp@- <== NOT EXECUTED
450bc: 4e94 jsr %a4@ <== NOT EXECUTED
450be: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
450c0: 202a 00cc movel %a2@(204),%d0
450c4: eb88 lsll #5,%d0
450c6: 0680 0005 e260 addil #385632,%d0
450cc: 2240 moveal %d0,%a1
450ce: 2051 moveal %a1@,%a0
450d0: 4a88 tstl %a0
450d2: 6706 beqs 450da <rtems_termios_txdaemon+0x60> <== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
450d4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
450d6: 4e90 jsr %a0@ <== NOT EXECUTED
450d8: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
450da: 2f0a movel %a2,%sp@-
450dc: 4e93 jsr %a3@
}
450de: 588f addql #4,%sp
450e0: 60ba bras 4509c <rtems_termios_txdaemon+0x22>
00044856 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
44856: 4e56 ffe8 linkw %fp,#-24
4485a: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
4485e: 246e 0008 moveal %fp@(8),%a2
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
44862: 2052 moveal %a2@,%a0
44864: 2668 0034 moveal %a0@(52),%a3
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44868: 42a7 clrl %sp@-
4486a: 42a7 clrl %sp@-
4486c: 2f2b 0018 movel %a3@(24),%sp@-
44870: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
44876: 4fef 000c lea %sp@(12),%sp
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4487a: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
4487c: 6600 0084 bnew 44902 <rtems_termios_write+0xac>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
44880: 202b 00cc movel %a3@(204),%d0
44884: eb88 lsll #5,%d0
44886: 0680 0005 e258 addil #385624,%d0
4488c: 2240 moveal %d0,%a1
4488e: 2051 moveal %a1@,%a0
44890: 4a88 tstl %a0
44892: 6718 beqs 448ac <rtems_termios_write+0x56>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
44894: 2f0a movel %a2,%sp@-
44896: 2f0b movel %a3,%sp@-
44898: 4e90 jsr %a0@
rtems_semaphore_release (tty->osem);
4489a: 2f2b 0018 movel %a3@(24),%sp@-
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
4489e: 2400 movel %d0,%d2
rtems_semaphore_release (tty->osem);
448a0: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return sc;
448a6: 4fef 000c lea %sp@(12),%sp
448aa: 6056 bras 44902 <rtems_termios_write+0xac>
}
if (tty->termios.c_oflag & OPOST) {
448ac: 7001 moveq #1,%d0
448ae: c0ab 0034 andl %a3@(52),%d0
448b2: 6728 beqs 448dc <rtems_termios_write+0x86> <== NEVER TAKEN
uint32_t count = args->count;
448b4: 262a 0010 movel %a2@(16),%d3
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
448b8: 4bfa fa64 lea %pc@(4431e <oproc>),%a5
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
448bc: 286a 000c moveal %a2@(12),%a4
while (count--)
448c0: 600e bras 448d0 <rtems_termios_write+0x7a>
oproc (*buffer++, tty);
448c2: 4280 clrl %d0
448c4: 101c moveb %a4@+,%d0
448c6: 5383 subql #1,%d3
448c8: 2f0b movel %a3,%sp@-
448ca: 2f00 movel %d0,%sp@-
448cc: 4e95 jsr %a5@
448ce: 508f addql #8,%sp
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
448d0: 4a83 tstl %d3
448d2: 66ee bnes 448c2 <rtems_termios_write+0x6c>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
448d4: 256a 0010 0018 movel %a2@(16),%a2@(24)
448da: 601a bras 448f6 <rtems_termios_write+0xa0>
} else {
rtems_termios_puts (args->buffer, args->count, tty);
448dc: 2f0b movel %a3,%sp@- <== NOT EXECUTED
448de: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
448e2: 2f2a 000c movel %a2@(12),%sp@- <== NOT EXECUTED
448e6: 4eb9 0004 4230 jsr 44230 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
448ec: 256a 0010 0018 movel %a2@(16),%a2@(24) <== NOT EXECUTED
448f2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
448f6: 2f2b 0018 movel %a3@(24),%sp@-
448fa: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return sc;
44900: 588f addql #4,%sp
}
44902: 2002 movel %d2,%d0
44904: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
4490a: 4e5e unlk %fp <== NOT EXECUTED
00051390 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
51390: 4e56 fffc linkw %fp,#-4
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
51394: 486e fffc pea %fp@(-4)
51398: 2f2e 0008 movel %fp@(8),%sp@-
5139c: 4879 0007 73be pea 773be <_Timer_Information>
513a2: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
513a8: 4fef 000c lea %sp@(12),%sp
513ac: 4aae fffc tstl %fp@(-4)
513b0: 6620 bnes 513d2 <rtems_timer_cancel+0x42>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
513b2: 7204 moveq #4,%d1
513b4: 2040 moveal %d0,%a0
513b6: b2a8 0038 cmpl %a0@(56),%d1
513ba: 670c beqs 513c8 <rtems_timer_cancel+0x38> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
513bc: 4868 0010 pea %a0@(16)
513c0: 4eb9 0005 5a1c jsr 55a1c <_Watchdog_Remove>
513c6: 588f addql #4,%sp
_Thread_Enable_dispatch();
513c8: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
513ce: 4280 clrl %d0
513d0: 6002 bras 513d4 <rtems_timer_cancel+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
513d2: 7004 moveq #4,%d0
}
513d4: 4e5e unlk %fp <== NOT EXECUTED
00045ee4 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
45ee4: 4e56 0000 linkw %fp,#0
45ee8: 2f0a movel %a2,%sp@-
45eea: 246e 000c moveal %fp@(12),%a2
45eee: 2f02 movel %d2,%sp@-
45ef0: 242e 0008 movel %fp@(8),%d2
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
45ef4: 676e beqs 45f64 <rtems_timer_create+0x80> <== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
45ef6: 4a8a tstl %a2
45ef8: 676e beqs 45f68 <rtems_timer_create+0x84> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45efa: 2039 0005 ec1a movel 5ec1a <_Thread_Dispatch_disable_level>,%d0
45f00: 5280 addql #1,%d0
45f02: 23c0 0005 ec1a movel %d0,5ec1a <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45f08: 2039 0005 ec1a movel 5ec1a <_Thread_Dispatch_disable_level>,%d0
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
45f0e: 4879 0005 f45c pea 5f45c <_Timer_Information>
45f14: 4eb9 0004 6d84 jsr 46d84 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
45f1a: 588f addql #4,%sp
45f1c: 2040 moveal %d0,%a0
45f1e: 4a80 tstl %d0
45f20: 660a bnes 45f2c <rtems_timer_create+0x48>
_Thread_Enable_dispatch();
45f22: 4eb9 0004 7df8 jsr 47df8 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
45f28: 7005 moveq #5,%d0
45f2a: 603e bras 45f6a <rtems_timer_create+0x86>
}
the_timer->the_class = TIMER_DORMANT;
45f2c: 7004 moveq #4,%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45f2e: 4281 clrl %d1
45f30: 2140 0038 movel %d0,%a0@(56)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45f34: 2028 0008 movel %a0@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45f38: 2279 0005 f474 moveal 5f474 <_Timer_Information+0x18>,%a1
45f3e: 3200 movew %d0,%d1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
45f40: 42a8 0018 clrl %a0@(24)
the_watchdog->routine = routine;
45f44: 42a8 002c clrl %a0@(44)
the_watchdog->id = id;
45f48: 42a8 0030 clrl %a0@(48)
the_watchdog->user_data = user_data;
45f4c: 42a8 0034 clrl %a0@(52)
45f50: 2388 1c00 movel %a0,%a1@(00000000,%d1:l:4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
45f54: 2142 000c movel %d2,%a0@(12)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
45f58: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
45f5a: 4eb9 0004 7df8 jsr 47df8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
45f60: 4280 clrl %d0
45f62: 6006 bras 45f6a <rtems_timer_create+0x86>
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
45f64: 7003 moveq #3,%d0
45f66: 6002 bras 45f6a <rtems_timer_create+0x86>
if ( !id )
return RTEMS_INVALID_ADDRESS;
45f68: 7009 moveq #9,%d0
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
45f6a: 242e fff8 movel %fp@(-8),%d2
45f6e: 246e fffc moveal %fp@(-4),%a2
45f72: 4e5e unlk %fp
...
0005176c <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
5176c: 4e56 ffe8 linkw %fp,#-24
51770: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
51774: 262e 0008 movel %fp@(8),%d3
51778: 242e 000c movel %fp@(12),%d2
5177c: 282e 0010 movel %fp@(16),%d4
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
51780: 2679 0007 73f8 moveal 773f8 <_Timer_server>,%a3
if ( !timer_server )
51786: 4a8b tstl %a3
51788: 6700 0088 beqw 51812 <rtems_timer_server_fire_after+0xa6>
return RTEMS_INCORRECT_STATE;
if ( !routine )
5178c: 4a84 tstl %d4
5178e: 6700 0086 beqw 51816 <rtems_timer_server_fire_after+0xaa>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
51792: 4a82 tstl %d2
51794: 6700 0084 beqw 5181a <rtems_timer_server_fire_after+0xae>
51798: 486e fffc pea %fp@(-4)
5179c: 2f03 movel %d3,%sp@-
5179e: 4879 0007 73be pea 773be <_Timer_Information>
517a4: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
517aa: 4fef 000c lea %sp@(12),%sp
517ae: 2440 moveal %d0,%a2
517b0: 4aae fffc tstl %fp@(-4)
517b4: 6668 bnes 5181e <rtems_timer_server_fire_after+0xb2><== NEVER TAKEN
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
517b6: 486a 0010 pea %a2@(16)
517ba: 4eb9 0005 5a1c jsr 55a1c <_Watchdog_Remove>
_ISR_Disable( level );
517c0: 203c 0000 0700 movel #1792,%d0
517c6: 40c1 movew %sr,%d1
517c8: 8081 orl %d1,%d0
517ca: 46c0 movew %d0,%sr
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
517cc: 588f addql #4,%sp
517ce: 4aaa 0018 tstl %a2@(24)
517d2: 670a beqs 517de <rtems_timer_server_fire_after+0x72>
_ISR_Enable( level );
517d4: 46c1 movew %d1,%sr
_Thread_Enable_dispatch();
517d6: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
517dc: 6030 bras 5180e <rtems_timer_server_fire_after+0xa2>
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL_ON_TASK;
517de: 7001 moveq #1,%d0
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
517e0: 256e 0014 0034 movel %fp@(20),%a2@(52)
517e6: 2540 0038 movel %d0,%a2@(56)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
517ea: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine;
517ee: 2544 002c movel %d4,%a2@(44)
the_watchdog->id = id;
517f2: 2543 0030 movel %d3,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
517f6: 2542 001c movel %d2,%a2@(28)
_ISR_Enable( level );
517fa: 46c1 movew %d1,%sr
(*timer_server->schedule_operation)( timer_server, the_timer );
517fc: 2f0a movel %a2,%sp@-
517fe: 2f0b movel %a3,%sp@-
51800: 206b 0004 moveal %a3@(4),%a0
51804: 4e90 jsr %a0@
_Thread_Enable_dispatch();
51806: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
5180c: 508f addql #8,%sp
5180e: 4280 clrl %d0
51810: 600e bras 51820 <rtems_timer_server_fire_after+0xb4>
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
51812: 700e moveq #14,%d0
51814: 600a bras 51820 <rtems_timer_server_fire_after+0xb4>
if ( !routine )
return RTEMS_INVALID_ADDRESS;
51816: 7009 moveq #9,%d0
51818: 6006 bras 51820 <rtems_timer_server_fire_after+0xb4>
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
5181a: 700a moveq #10,%d0
5181c: 6002 bras 51820 <rtems_timer_server_fire_after+0xb4>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
5181e: 7004 moveq #4,%d0
}
51820: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3
51826: 4e5e unlk %fp
...
0005182c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
5182c: 4e56 ffe8 linkw %fp,#-24
51830: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
51834: 262e 0008 movel %fp@(8),%d3
51838: 242e 000c movel %fp@(12),%d2
5183c: 282e 0010 movel %fp@(16),%d4
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
51840: 2679 0007 73f8 moveal 773f8 <_Timer_server>,%a3
if ( !timer_server )
51846: 4a8b tstl %a3
51848: 6700 0098 beqw 518e2 <rtems_timer_server_fire_when+0xb6>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
5184c: 4a39 0007 6b4c tstb 76b4c <_TOD_Is_set>
51852: 6700 0092 beqw 518e6 <rtems_timer_server_fire_when+0xba>
return RTEMS_NOT_DEFINED;
if ( !routine )
51856: 4a84 tstl %d4
51858: 6700 0090 beqw 518ea <rtems_timer_server_fire_when+0xbe>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
5185c: 2f02 movel %d2,%sp@-
5185e: 4eb9 0004 ec6c jsr 4ec6c <_TOD_Validate>
51864: 588f addql #4,%sp
51866: 4a00 tstb %d0
51868: 6700 0084 beqw 518ee <rtems_timer_server_fire_when+0xc2>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
5186c: 2f02 movel %d2,%sp@-
5186e: 4eb9 0004 ebd4 jsr 4ebd4 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
51874: 588f addql #4,%sp
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
51876: 2400 movel %d0,%d2
if ( seconds <= _TOD_Seconds_since_epoch() )
51878: b0b9 0007 6bc6 cmpl 76bc6 <_TOD_Now>,%d0
5187e: 636e blss 518ee <rtems_timer_server_fire_when+0xc2>
51880: 486e fffc pea %fp@(-4)
51884: 2f03 movel %d3,%sp@-
51886: 4879 0007 73be pea 773be <_Timer_Information>
5188c: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
51892: 4fef 000c lea %sp@(12),%sp
51896: 2440 moveal %d0,%a2
51898: 4aae fffc tstl %fp@(-4)
5189c: 6654 bnes 518f2 <rtems_timer_server_fire_when+0xc6>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
5189e: 486a 0010 pea %a2@(16)
518a2: 4eb9 0005 5a1c jsr 55a1c <_Watchdog_Remove>
the_watchdog->user_data = user_data;
518a8: 256e 0014 0034 movel %fp@(20),%a2@(52)
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
518ae: 94b9 0007 6bc6 subl 76bc6 <_TOD_Now>,%d2
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
518b4: 7003 moveq #3,%d0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
518b6: 42aa 0018 clrl %a2@(24)
518ba: 2540 0038 movel %d0,%a2@(56)
the_watchdog->routine = routine;
518be: 2544 002c movel %d4,%a2@(44)
the_watchdog->id = id;
518c2: 2543 0030 movel %d3,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
518c6: 2542 001c movel %d2,%a2@(28)
(*timer_server->schedule_operation)( timer_server, the_timer );
518ca: 2f0a movel %a2,%sp@-
518cc: 2f0b movel %a3,%sp@-
518ce: 206b 0004 moveal %a3@(4),%a0
518d2: 4e90 jsr %a0@
_Thread_Enable_dispatch();
518d4: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
518da: 4fef 000c lea %sp@(12),%sp
518de: 4280 clrl %d0
518e0: 6012 bras 518f4 <rtems_timer_server_fire_when+0xc8>
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
518e2: 700e moveq #14,%d0
518e4: 600e bras 518f4 <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
518e6: 700b moveq #11,%d0 <== NOT EXECUTED
518e8: 600a bras 518f4 <rtems_timer_server_fire_when+0xc8><== NOT EXECUTED
if ( !routine )
return RTEMS_INVALID_ADDRESS;
518ea: 7009 moveq #9,%d0
518ec: 6006 bras 518f4 <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
518ee: 7014 moveq #20,%d0
518f0: 6002 bras 518f4 <rtems_timer_server_fire_when+0xc8>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
518f2: 7004 moveq #4,%d0
}
518f4: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3
518fa: 4e5e unlk %fp
...
00042830 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
42830: 4e56 fff0 linkw %fp,#-16
42834: 48d7 041c moveml %d2-%d4/%a2,%sp@
42838: 242e 0008 movel %fp@(8),%d2
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
4283c: 0802 001d btst #29,%d2
42840: 6734 beqs 42876 <rtems_verror+0x46>
if (rtems_panic_in_progress++)
42842: 2039 0005 ea40 movel 5ea40 <rtems_panic_in_progress>,%d0
42848: 2200 movel %d0,%d1
4284a: 5281 addql #1,%d1
4284c: 23c1 0005 ea40 movel %d1,5ea40 <rtems_panic_in_progress>
42852: 4a80 tstl %d0
42854: 6714 beqs 4286a <rtems_verror+0x3a> <== ALWAYS TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
42856: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0<== NOT EXECUTED
4285c: 5280 addql #1,%d0 <== NOT EXECUTED
4285e: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level><== NOT EXECUTED
return _Thread_Dispatch_disable_level;
42864: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0<== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
4286a: 7002 moveq #2,%d0
4286c: b0b9 0005 ea40 cmpl 5ea40 <rtems_panic_in_progress>,%d0
42872: 6d00 0100 bltw 42974 <rtems_verror+0x144>
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
42876: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
status = error_flag & ~RTEMS_ERROR_MASK;
4287c: 2802 movel %d2,%d4
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
4287e: 2f28 0008 movel %a0@(8),%sp@-
status = error_flag & ~RTEMS_ERROR_MASK;
42882: 0284 8fff ffff andil #-1879048193,%d4
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
42888: 4eb9 0004 d0f4 jsr 4d0f4 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
4288e: 588f addql #4,%sp
42890: 0802 001e btst #30,%d2
42894: 670c beqs 428a2 <rtems_verror+0x72>
local_errno = errno;
42896: 4eb9 0004 cd68 jsr 4cd68 <__errno>
4289c: 2040 moveal %d0,%a0
4289e: 2610 movel %a0@,%d3
428a0: 6002 bras 428a4 <rtems_verror+0x74>
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
428a2: 4283 clrl %d3
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
428a4: 2f2e 0010 movel %fp@(16),%sp@-
428a8: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
428ae: 2f2e 000c movel %fp@(12),%sp@-
428b2: 2f28 000c movel %a0@(12),%sp@-
428b6: 4eb9 0005 3dc0 jsr 53dc0 <vfprintf>
if (status)
428bc: 4fef 000c lea %sp@(12),%sp
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
428c0: 2400 movel %d0,%d2
if (status)
428c2: 4a84 tstl %d4
428c4: 6726 beqs 428ec <rtems_verror+0xbc>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
428c6: 2f04 movel %d4,%sp@-
428c8: 4eb9 0004 2818 jsr 42818 <rtems_status_text>
428ce: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
428d4: 2f00 movel %d0,%sp@-
428d6: 4879 0005 bdcf pea 5bdcf <IMFS_ops+0x4f>
428dc: 2f28 000c movel %a0@(12),%sp@-
428e0: 4eb9 0004 d496 jsr 4d496 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
428e6: 4fef 0010 lea %sp@(16),%sp
428ea: d480 addl %d0,%d2
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
428ec: 4a83 tstl %d3
428ee: 6756 beqs 42946 <rtems_verror+0x116>
if ((local_errno > 0) && *strerror(local_errno))
428f0: 6f36 bles 42928 <rtems_verror+0xf8>
428f2: 2f03 movel %d3,%sp@-
428f4: 45f9 0004 e0b8 lea 4e0b8 <strerror>,%a2
428fa: 4e92 jsr %a2@
428fc: 588f addql #4,%sp
428fe: 2040 moveal %d0,%a0
42900: 4a10 tstb %a0@
42902: 6724 beqs 42928 <rtems_verror+0xf8> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
42904: 2f03 movel %d3,%sp@-
42906: 4e92 jsr %a2@
42908: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
4290e: 2f00 movel %d0,%sp@-
42910: 4879 0005 bddd pea 5bddd <IMFS_ops+0x5d>
42916: 2f28 000c movel %a0@(12),%sp@-
4291a: 4eb9 0004 d496 jsr 4d496 <fprintf>
42920: 4fef 0010 lea %sp@(16),%sp
42924: d480 addl %d0,%d2
42926: 601e bras 42946 <rtems_verror+0x116>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
42928: 2f03 movel %d3,%sp@-
4292a: 4879 0005 bdea pea 5bdea <IMFS_ops+0x6a>
42930: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
42936: 2f28 000c movel %a0@(12),%sp@-
4293a: 4eb9 0004 d496 jsr 4d496 <fprintf>
42940: 4fef 000c lea %sp@(12),%sp
42944: d480 addl %d0,%d2
}
chars_written += fprintf(stderr, "\n");
42946: 4879 0005 b9ef pea 5b9ef <rtems_filesystem_table+0x3d7>
4294c: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
42952: 2f28 000c movel %a0@(12),%sp@-
42956: 4eb9 0004 d496 jsr 4d496 <fprintf>
(void) fflush(stderr);
4295c: 2079 0005 d4e8 moveal 5d4e8 <_impure_ptr>,%a0
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
42962: d480 addl %d0,%d2
(void) fflush(stderr);
42964: 2f28 000c movel %a0@(12),%sp@-
42968: 4eb9 0004 d0f4 jsr 4d0f4 <fflush>
return chars_written;
4296e: 4fef 000c lea %sp@(12),%sp
42972: 6002 bras 42976 <rtems_verror+0x146>
if (rtems_panic_in_progress++)
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
42974: 4282 clrl %d2 <== NOT EXECUTED
chars_written += fprintf(stderr, "\n");
(void) fflush(stderr);
return chars_written;
}
42976: 2002 movel %d2,%d0
42978: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4297e: 4e5e unlk %fp <== NOT EXECUTED
00042fe4 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
42fe4: 4e56 ffe4 linkw %fp,#-28
42fe8: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
42fec: 246e 0008 moveal %fp@(8),%a2
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
42ff0: 4283 clrl %d3
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
42ff2: 283c 7fff ffff movel #2147483647,%d4
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
42ff8: 4282 clrl %d2
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
42ffa: 47f9 0004 f484 lea 4f484 <__srget_r>,%a3
43000: 202a 0004 movel %a2@(4),%d0
43004: 5380 subql #1,%d0
43006: 2540 0004 movel %d0,%a2@(4)
4300a: 6c0e bges 4301a <scanInt+0x36> <== ALWAYS TAKEN
4300c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4300e: 2f39 0005 ebd8 movel 5ebd8 <_impure_ptr>,%sp@- <== NOT EXECUTED
43014: 4e93 jsr %a3@ <== NOT EXECUTED
43016: 508f addql #8,%sp <== NOT EXECUTED
43018: 600a bras 43024 <scanInt+0x40> <== NOT EXECUTED
4301a: 2052 moveal %a2@,%a0
4301c: 4280 clrl %d0
4301e: 1010 moveb %a0@,%d0
43020: 5288 addql #1,%a0
43022: 2488 movel %a0,%a2@
if (c == ':')
43024: 723a moveq #58,%d1
43026: b280 cmpl %d0,%d1
43028: 6750 beqs 4307a <scanInt+0x96>
break;
if (sign == 0) {
4302a: 4a83 tstl %d3
4302c: 660e bnes 4303c <scanInt+0x58>
if (c == '-') {
4302e: 7c2d moveq #45,%d6
43030: bc80 cmpl %d0,%d6
43032: 6606 bnes 4303a <scanInt+0x56>
sign = -1;
limit++;
43034: 5284 addql #1,%d4
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
43036: 76ff moveq #-1,%d3
limit++;
continue;
43038: 60c6 bras 43000 <scanInt+0x1c>
}
sign = 1;
4303a: 7601 moveq #1,%d3
}
if (!isdigit(c))
4303c: 2079 0005 ebd4 moveal 5ebd4 <__ctype_ptr__>,%a0
43042: 1230 0801 moveb %a0@(00000001,%d0:l),%d1
43046: 49c1 extbl %d1
43048: 44c1 movew %d1,%ccr
4304a: 6640 bnes 4308c <scanInt+0xa8>
return 0;
d = c - '0';
if ((i > (limit / 10))
4304c: 2204 movel %d4,%d1
4304e: 7c0a moveq #10,%d6
43050: 4c46 1005 remul %d6,%d5,%d1
43054: 4c46 1001 remul %d6,%d1,%d1
43058: b282 cmpl %d2,%d1
4305a: 6530 bcss 4308c <scanInt+0xa8>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
4305c: 0680 ffff ffd0 addil #-48,%d0
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
43062: b282 cmpl %d2,%d1
43064: 6604 bnes 4306a <scanInt+0x86>
43066: ba80 cmpl %d0,%d5
43068: 6522 bcss 4308c <scanInt+0xa8> <== ALWAYS TAKEN
return 0;
i = i * 10 + d;
4306a: 2202 movel %d2,%d1
4306c: e789 lsll #3,%d1
4306e: 2241 moveal %d1,%a1
43070: 41f1 2a00 lea %a1@(00000000,%d2:l:2),%a0
43074: 2400 movel %d0,%d2
43076: d488 addl %a0,%d2
43078: 6086 bras 43000 <scanInt+0x1c>
}
if (sign == 0)
4307a: 4a83 tstl %d3
4307c: 670e beqs 4308c <scanInt+0xa8> <== NEVER TAKEN
return 0;
*val = i * sign;
4307e: 4c02 3800 mulsl %d2,%d3
return 1;
43082: 7001 moveq #1,%d0
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
43084: 206e 000c moveal %fp@(12),%a0
43088: 2083 movel %d3,%a0@
return 1;
4308a: 6002 bras 4308e <scanInt+0xaa>
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
4308c: 4280 clrl %d0
*val = i * sign;
return 1;
}
4308e: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
43094: 4e5e unlk %fp <== NOT EXECUTED
00043126 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
43126: 4e56 ffe4 linkw %fp,#-28
4312a: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
4312e: 42a7 clrl %sp@-
43130: 280e movel %fp,%d4
43132: 0684 0000 0014 addil #20,%d4
43138: 260e movel %fp,%d3
4313a: 0683 0000 0010 addil #16,%d3
43140: 47fa ff56 lea %pc@(43098 <scanString>),%a3
43144: 2f04 movel %d4,%sp@-
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
43146: 246e 000c moveal %fp@(12),%a2
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
4314a: 2f03 movel %d3,%sp@-
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
4314c: 242e 0008 movel %fp@(8),%d2
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
43150: 2f0a movel %a2,%sp@-
43152: 2f02 movel %d2,%sp@-
43154: 4e93 jsr %a3@
43156: 4fef 0014 lea %sp@(20),%sp
4315a: 4a80 tstl %d0
4315c: 6700 00b6 beqw 43214 <scangr+0xee>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
43160: 42a7 clrl %sp@-
43162: 2f04 movel %d4,%sp@-
43164: 2f03 movel %d3,%sp@-
43166: 486a 0004 pea %a2@(4)
4316a: 2f02 movel %d2,%sp@-
4316c: 4e93 jsr %a3@
4316e: 4fef 0014 lea %sp@(20),%sp
43172: 4a80 tstl %d0
43174: 6700 009e beqw 43214 <scangr+0xee>
|| !scanInt(fp, &grgid)
43178: 486e fff8 pea %fp@(-8)
4317c: 2f02 movel %d2,%sp@-
4317e: 4eba fe64 jsr %pc@(42fe4 <scanInt>)
43182: 508f addql #8,%sp
43184: 4a80 tstl %d0
43186: 6700 008c beqw 43214 <scangr+0xee>
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
4318a: 4878 0001 pea 1 <ADD>
4318e: 2f04 movel %d4,%sp@-
43190: 2f03 movel %d3,%sp@-
43192: 486e fffc pea %fp@(-4)
43196: 2f02 movel %d2,%sp@-
43198: 4e93 jsr %a3@
4319a: 4fef 0014 lea %sp@(20),%sp
4319e: 4a80 tstl %d0
431a0: 6772 beqs 43214 <scangr+0xee> <== NEVER TAKEN
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431a2: 222e fffc movel %fp@(-4),%d1
431a6: 7001 moveq #1,%d0
431a8: 2041 moveal %d1,%a0
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
431aa: 356e fffa 0008 movew %fp@(-6),%a2@(8)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431b0: 600a bras 431bc <scangr+0x96>
if(*cp == ',')
431b2: 49c2 extbl %d2
431b4: 762c moveq #44,%d3
431b6: b682 cmpl %d2,%d3
431b8: 6602 bnes 431bc <scangr+0x96>
memcount++;
431ba: 5280 addql #1,%d0
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431bc: 1418 moveb %a0@+,%d2
431be: 66f2 bnes 431b2 <scangr+0x8c>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
431c0: e588 lsll #2,%d0
431c2: 0680 0000 0013 addil #19,%d0
431c8: b0ae 0014 cmpl %fp@(20),%d0
431cc: 6246 bhis 43214 <scangr+0xee> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
431ce: 202e 0010 movel %fp@(16),%d0
431d2: 74f0 moveq #-16,%d2
431d4: 0680 0000 000f addil #15,%d0
431da: c082 andl %d2,%d0
431dc: 2540 000a movel %d0,%a2@(10)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
431e0: 2040 moveal %d0,%a0
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431e2: 7001 moveq #1,%d0
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
431e4: 2081 movel %d1,%a0@
431e6: 206e fffc moveal %fp@(-4),%a0
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431ea: 6018 bras 43204 <scangr+0xde>
if(*cp == ',') {
431ec: 49c1 extbl %d1
431ee: 742c moveq #44,%d2
431f0: b481 cmpl %d1,%d2
431f2: 6610 bnes 43204 <scangr+0xde>
*cp = '\0';
431f4: 4203 clrb %d3
431f6: 1143 ffff moveb %d3,%a0@(-1)
grp->gr_mem[memcount++] = cp + 1;
431fa: 226a 000a moveal %a2@(10),%a1
431fe: 2388 0c00 movel %a0,%a1@(00000000,%d0:l:4)
43202: 5280 addql #1,%d0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
43204: 1218 moveb %a0@+,%d1
43206: 66e4 bnes 431ec <scangr+0xc6>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
43208: 206a 000a moveal %a2@(10),%a0
4320c: 42b0 0c00 clrl %a0@(00000000,%d0:l:4)
return 1;
43210: 7001 moveq #1,%d0
43212: 6002 bras 43216 <scangr+0xf0>
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
43214: 4280 clrl %d0
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
43216: 4cee 0c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a3
4321c: 4e5e unlk %fp <== NOT EXECUTED
00043220 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
43220: 4e56 ffe0 linkw %fp,#-32
43224: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
43228: 42a7 clrl %sp@-
4322a: 280e movel %fp,%d4
4322c: 0684 0000 0014 addil #20,%d4
43232: 260e movel %fp,%d3
43234: 0683 0000 0010 addil #16,%d3
4323a: 47fa fe5c lea %pc@(43098 <scanString>),%a3
4323e: 2f04 movel %d4,%sp@-
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
43240: 246e 000c moveal %fp@(12),%a2
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
43244: 2f03 movel %d3,%sp@-
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
43246: 242e 0008 movel %fp@(8),%d2
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
4324a: 2f0a movel %a2,%sp@-
4324c: 2f02 movel %d2,%sp@-
4324e: 4e93 jsr %a3@
43250: 4fef 0014 lea %sp@(20),%sp
43254: 4a80 tstl %d0
43256: 6700 00a4 beqw 432fc <scanpw+0xdc>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
4325a: 42a7 clrl %sp@-
4325c: 2f04 movel %d4,%sp@-
4325e: 2f03 movel %d3,%sp@-
43260: 486a 0004 pea %a2@(4)
43264: 2f02 movel %d2,%sp@-
43266: 4e93 jsr %a3@
43268: 4fef 0014 lea %sp@(20),%sp
4326c: 4a80 tstl %d0
4326e: 6700 008c beqw 432fc <scanpw+0xdc>
|| !scanInt(fp, &pwuid)
43272: 486e fff8 pea %fp@(-8)
43276: 49fa fd6c lea %pc@(42fe4 <scanInt>),%a4
4327a: 2f02 movel %d2,%sp@-
4327c: 4e94 jsr %a4@
4327e: 508f addql #8,%sp
43280: 4a80 tstl %d0
43282: 6778 beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanInt(fp, &pwgid)
43284: 486e fffc pea %fp@(-4)
43288: 2f02 movel %d2,%sp@-
4328a: 4e94 jsr %a4@
4328c: 508f addql #8,%sp
4328e: 4a80 tstl %d0
43290: 676a beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
43292: 42a7 clrl %sp@-
43294: 2f04 movel %d4,%sp@-
43296: 2f03 movel %d3,%sp@-
43298: 486a 000c pea %a2@(12)
4329c: 2f02 movel %d2,%sp@-
4329e: 4e93 jsr %a3@
432a0: 4fef 0014 lea %sp@(20),%sp
432a4: 4a80 tstl %d0
432a6: 6754 beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
432a8: 42a7 clrl %sp@-
432aa: 2f04 movel %d4,%sp@-
432ac: 2f03 movel %d3,%sp@-
432ae: 486a 0010 pea %a2@(16)
432b2: 2f02 movel %d2,%sp@-
432b4: 4e93 jsr %a3@
432b6: 4fef 0014 lea %sp@(20),%sp
432ba: 4a80 tstl %d0
432bc: 673e beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
432be: 42a7 clrl %sp@-
432c0: 2f04 movel %d4,%sp@-
432c2: 2f03 movel %d3,%sp@-
432c4: 486a 0014 pea %a2@(20)
432c8: 2f02 movel %d2,%sp@-
432ca: 4e93 jsr %a3@
432cc: 4fef 0014 lea %sp@(20),%sp
432d0: 4a80 tstl %d0
432d2: 6728 beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
432d4: 4878 0001 pea 1 <ADD>
432d8: 2f04 movel %d4,%sp@-
432da: 2f03 movel %d3,%sp@-
432dc: 486a 0018 pea %a2@(24)
432e0: 2f02 movel %d2,%sp@-
432e2: 4e93 jsr %a3@
432e4: 4fef 0014 lea %sp@(20),%sp
432e8: 4a80 tstl %d0
432ea: 6710 beqs 432fc <scanpw+0xdc>
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
432ec: 7001 moveq #1,%d0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
432ee: 356e fffa 0008 movew %fp@(-6),%a2@(8)
pwd->pw_gid = pwgid;
432f4: 356e fffe 000a movew %fp@(-2),%a2@(10)
return 1;
432fa: 6002 bras 432fe <scanpw+0xde>
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
432fc: 4280 clrl %d0
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
432fe: 4cee 1c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a4
43304: 4e5e unlk %fp <== NOT EXECUTED
00046018 <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
46018: 7004 moveq #4,%d0
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
4601a: 4e56 0000 linkw %fp,#0
4601e: 222e 0008 movel %fp@(8),%d1
switch ( policy ) {
46022: b081 cmpl %d1,%d0
46024: 650c bcss 46032 <sched_get_priority_max+0x1a>
46026: 103c 0001 moveb #1,%d0
4602a: e3a8 lsll %d1,%d0
4602c: 7217 moveq #23,%d1
4602e: c081 andl %d1,%d0
46030: 6610 bnes 46042 <sched_get_priority_max+0x2a> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
46032: 4eb9 0004 d750 jsr 4d750 <__errno>
46038: 2040 moveal %d0,%a0
4603a: 7016 moveq #22,%d0
4603c: 2080 movel %d0,%a0@
4603e: 70ff moveq #-1,%d0
46040: 600a bras 4604c <sched_get_priority_max+0x34>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
46042: 4280 clrl %d0
46044: 1039 0005 dfea moveb 5dfea <rtems_maximum_priority>,%d0
4604a: 5380 subql #1,%d0
}
4604c: 4e5e unlk %fp <== NOT EXECUTED
00046050 <sched_get_priority_min>:
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
46050: 7004 moveq #4,%d0
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
46052: 4e56 0000 linkw %fp,#0
46056: 222e 0008 movel %fp@(8),%d1
switch ( policy ) {
4605a: b081 cmpl %d1,%d0
4605c: 650c bcss 4606a <sched_get_priority_min+0x1a>
4605e: 103c 0001 moveb #1,%d0
46062: e3a8 lsll %d1,%d0
46064: 7217 moveq #23,%d1
46066: c081 andl %d1,%d0
46068: 6610 bnes 4607a <sched_get_priority_min+0x2a> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
4606a: 4eb9 0004 d750 jsr 4d750 <__errno>
46070: 2040 moveal %d0,%a0
46072: 7016 moveq #22,%d0
46074: 2080 movel %d0,%a0@
46076: 70ff moveq #-1,%d0
46078: 6002 bras 4607c <sched_get_priority_min+0x2c>
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
4607a: 7001 moveq #1,%d0
}
4607c: 4e5e unlk %fp <== NOT EXECUTED
00046080 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
46080: 4e56 0000 linkw %fp,#0
46084: 2f03 movel %d3,%sp@-
46086: 262e 0008 movel %fp@(8),%d3
4608a: 2f02 movel %d2,%sp@-
4608c: 242e 000c movel %fp@(12),%d2
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
46090: 4a83 tstl %d3
46092: 6718 beqs 460ac <sched_rr_get_interval+0x2c> <== NEVER TAKEN
46094: 4eb9 0004 30a4 jsr 430a4 <getpid>
4609a: b083 cmpl %d3,%d0
4609c: 670e beqs 460ac <sched_rr_get_interval+0x2c>
rtems_set_errno_and_return_minus_one( ESRCH );
4609e: 4eb9 0004 d750 jsr 4d750 <__errno>
460a4: 7203 moveq #3,%d1
460a6: 2040 moveal %d0,%a0
460a8: 2081 movel %d1,%a0@
460aa: 6010 bras 460bc <sched_rr_get_interval+0x3c>
if ( !interval )
460ac: 4a82 tstl %d2
460ae: 6610 bnes 460c0 <sched_rr_get_interval+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
460b0: 4eb9 0004 d750 jsr 4d750 <__errno>
460b6: 2040 moveal %d0,%a0
460b8: 7016 moveq #22,%d0
460ba: 2080 movel %d0,%a0@
460bc: 70ff moveq #-1,%d0
460be: 6012 bras 460d2 <sched_rr_get_interval+0x52>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
460c0: 2f02 movel %d2,%sp@-
460c2: 2f39 0005 f940 movel 5f940 <_Thread_Ticks_per_timeslice>,%sp@-
460c8: 4eb9 0004 9434 jsr 49434 <_Timespec_From_ticks>
return 0;
460ce: 508f addql #8,%sp
460d0: 4280 clrl %d0
}
460d2: 242e fff8 movel %fp@(-8),%d2
460d6: 262e fffc movel %fp@(-4),%d3
460da: 4e5e unlk %fp
...
000485f4 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
485f4: 4e56 ffdc linkw %fp,#-36
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
485f8: 2039 0006 38b4 movel 638b4 <_Thread_Dispatch_disable_level>,%d0
485fe: 5280 addql #1,%d0
48600: 48d7 047c moveml %d2-%d6/%a2,%sp@
48604: 23c0 0006 38b4 movel %d0,638b4 <_Thread_Dispatch_disable_level>
4860a: 262e 0008 movel %fp@(8),%d3
4860e: 2a2e 000c movel %fp@(12),%d5
return _Thread_Dispatch_disable_level;
48612: 2039 0006 38b4 movel 638b4 <_Thread_Dispatch_disable_level>,%d0
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
48618: 2c05 movel %d5,%d6
4861a: 0286 0000 0200 andil #512,%d6
48620: 6706 beqs 48628 <sem_open+0x34>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
48622: 282e 0014 movel %fp@(20),%d4
48626: 6002 bras 4862a <sem_open+0x36>
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
48628: 4284 clrl %d4
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
4862a: 45ee fff4 lea %fp@(-12),%a2
4862e: 2f0a movel %a2,%sp@-
48630: 2f03 movel %d3,%sp@-
48632: 4eb9 0004 e208 jsr 4e208 <_POSIX_Semaphore_Name_to_id>
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
48638: 508f addql #8,%sp
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
4863a: 2400 movel %d0,%d2
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
4863c: 671c beqs 4865a <sem_open+0x66>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
4863e: 7002 moveq #2,%d0
48640: b082 cmpl %d2,%d0
48642: 6604 bnes 48648 <sem_open+0x54> <== NEVER TAKEN
48644: 4a86 tstl %d6
48646: 6660 bnes 486a8 <sem_open+0xb4>
_Thread_Enable_dispatch();
48648: 4eb9 0004 b1bc jsr 4b1bc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
4864e: 4eb9 0005 09d0 jsr 509d0 <__errno>
48654: 2040 moveal %d0,%a0
48656: 2082 movel %d2,%a0@
48658: 6078 bras 486d2 <sem_open+0xde>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
4865a: 0285 0000 0a00 andil #2560,%d5
48660: 0c85 0000 0a00 cmpil #2560,%d5
48666: 6614 bnes 4867c <sem_open+0x88>
_Thread_Enable_dispatch();
48668: 4eb9 0004 b1bc jsr 4b1bc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
4866e: 4eb9 0005 09d0 jsr 509d0 <__errno>
48674: 2040 moveal %d0,%a0
48676: 7011 moveq #17,%d0
48678: 2080 movel %d0,%a0@
4867a: 6056 bras 486d2 <sem_open+0xde>
4867c: 486e fffc pea %fp@(-4)
48680: 2f12 movel %a2@,%sp@-
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
_Thread_Enable_dispatch();
48682: 45f9 0004 b1bc lea 4b1bc <_Thread_Enable_dispatch>,%a2
48688: 4879 0006 3ac2 pea 63ac2 <_POSIX_Semaphore_Information>
4868e: 4eb9 0004 a528 jsr 4a528 <_Objects_Get>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
48694: 2040 moveal %d0,%a0
48696: 52a8 0016 addql #1,%a0@(22)
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
4869a: 2d40 fff8 movel %d0,%fp@(-8)
the_semaphore->open_count += 1;
_Thread_Enable_dispatch();
4869e: 4e92 jsr %a2@
_Thread_Enable_dispatch();
486a0: 4e92 jsr %a2@
goto return_id;
486a2: 4fef 000c lea %sp@(12),%sp
486a6: 6022 bras 486ca <sem_open+0xd6>
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
486a8: 486e fff8 pea %fp@(-8)
486ac: 2f04 movel %d4,%sp@-
486ae: 42a7 clrl %sp@-
486b0: 2f03 movel %d3,%sp@-
486b2: 4eb9 0004 e0bc jsr 4e0bc <_POSIX_Semaphore_Create_support>
486b8: 2400 movel %d0,%d2
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
486ba: 4eb9 0004 b1bc jsr 4b1bc <_Thread_Enable_dispatch>
if ( status == -1 )
486c0: 4fef 0010 lea %sp@(16),%sp
486c4: 70ff moveq #-1,%d0
486c6: b082 cmpl %d2,%d0
486c8: 6708 beqs 486d2 <sem_open+0xde>
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
486ca: 202e fff8 movel %fp@(-8),%d0
486ce: 5080 addql #8,%d0
486d0: 6002 bras 486d4 <sem_open+0xe0>
*/
_Thread_Enable_dispatch();
if ( status == -1 )
return SEM_FAILED;
486d2: 70ff moveq #-1,%d0
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
486d4: 4cee 047c ffdc moveml %fp@(-36),%d2-%d6/%a2
486da: 4e5e unlk %fp
...
00045eac <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
45eac: 4e56 fff0 linkw %fp,#-16
45eb0: 222e 0010 movel %fp@(16),%d1
45eb4: 48d7 041c moveml %d2-%d4/%a2,%sp@
45eb8: 242e 0008 movel %fp@(8),%d2
45ebc: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
if ( oact )
45ec0: 4a81 tstl %d1
45ec2: 6722 beqs 45ee6 <sigaction+0x3a>
*oact = _POSIX_signals_Vectors[ sig ];
45ec4: 2602 movel %d2,%d3
45ec6: 2002 movel %d2,%d0
45ec8: 4878 000c pea c <OPER1>
45ecc: e58b lsll #2,%d3
45ece: e988 lsll #4,%d0
45ed0: 9083 subl %d3,%d0
45ed2: 0680 0006 0a64 addil #395876,%d0
45ed8: 2f00 movel %d0,%sp@-
45eda: 2f01 movel %d1,%sp@-
45edc: 4eb9 0004 e268 jsr 4e268 <memcpy>
45ee2: 4fef 000c lea %sp@(12),%sp
if ( !sig )
45ee6: 4a82 tstl %d2
45ee8: 6710 beqs 45efa <sigaction+0x4e>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
45eea: 2002 movel %d2,%d0
45eec: 5380 subql #1,%d0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
45eee: 721f moveq #31,%d1
45ef0: b280 cmpl %d0,%d1
45ef2: 6506 bcss 45efa <sigaction+0x4e>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
45ef4: 7009 moveq #9,%d0
45ef6: b082 cmpl %d2,%d0
45ef8: 6610 bnes 45f0a <sigaction+0x5e>
rtems_set_errno_and_return_minus_one( EINVAL );
45efa: 4eb9 0004 da30 jsr 4da30 <__errno>
45f00: 2040 moveal %d0,%a0
45f02: 7016 moveq #22,%d0
45f04: 2080 movel %d0,%a0@
45f06: 70ff moveq #-1,%d0
45f08: 6062 bras 45f6c <sigaction+0xc0>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
45f0a: 4a8a tstl %a2
45f0c: 675c beqs 45f6a <sigaction+0xbe> <== NEVER TAKEN
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
45f0e: 203c 0000 0700 movel #1792,%d0
45f14: 40c3 movew %sr,%d3
45f16: 8083 orl %d3,%d0
45f18: 46c0 movew %d0,%sr
45f1a: 780c moveq #12,%d4
45f1c: 4c02 4800 mulsl %d2,%d4
if ( act->sa_handler == SIG_DFL ) {
45f20: 4aaa 0008 tstl %a2@(8)
45f24: 6622 bnes 45f48 <sigaction+0x9c>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
45f26: 4878 000c pea c <OPER1>
45f2a: 2004 movel %d4,%d0
45f2c: 0680 0005 dfaa addil #384938,%d0
45f32: 2f00 movel %d0,%sp@-
45f34: 0684 0006 0a64 addil #395876,%d4
45f3a: 2f04 movel %d4,%sp@-
45f3c: 4eb9 0004 e268 jsr 4e268 <memcpy>
45f42: 4fef 000c lea %sp@(12),%sp
45f46: 6020 bras 45f68 <sigaction+0xbc>
} else {
_POSIX_signals_Clear_process_signals( sig );
45f48: 2f02 movel %d2,%sp@-
_POSIX_signals_Vectors[ sig ] = *act;
45f4a: 0684 0006 0a64 addil #395876,%d4
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
45f50: 4eb9 0004 b2a0 jsr 4b2a0 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
45f56: 4878 000c pea c <OPER1>
45f5a: 2f0a movel %a2,%sp@-
45f5c: 2f04 movel %d4,%sp@-
45f5e: 4eb9 0004 e268 jsr 4e268 <memcpy>
45f64: 4fef 0010 lea %sp@(16),%sp
}
_ISR_Enable( level );
45f68: 46c3 movew %d3,%sr
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
45f6a: 4280 clrl %d0
}
45f6c: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
45f72: 4e5e unlk %fp
...
00047bc8 <sigismember>:
int sigismember(
const sigset_t *set,
int signo
)
{
47bc8: 4e56 0000 linkw %fp,#0
47bcc: 206e 0008 moveal %fp@(8),%a0
47bd0: 222e 000c movel %fp@(12),%d1
if ( !set )
47bd4: 4a88 tstl %a0
47bd6: 670c beqs 47be4 <sigismember+0x1c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
47bd8: 4a81 tstl %d1
47bda: 6726 beqs 47c02 <sigismember+0x3a> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
47bdc: 5381 subql #1,%d1
return 0;
if ( !is_valid_signo(signo) )
47bde: 701f moveq #31,%d0
47be0: b081 cmpl %d1,%d0
47be2: 6410 bccs 47bf4 <sigismember+0x2c>
rtems_set_errno_and_return_minus_one( EINVAL );
47be4: 4eb9 0004 f778 jsr 4f778 <__errno>
47bea: 2040 moveal %d0,%a0
47bec: 7016 moveq #22,%d0
47bee: 2080 movel %d0,%a0@
47bf0: 70ff moveq #-1,%d0
47bf2: 6010 bras 47c04 <sigismember+0x3c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
47bf4: 7001 moveq #1,%d0
47bf6: e3a8 lsll %d1,%d0
if ( *set & signo_to_mask(signo) )
47bf8: c090 andl %a0@,%d0
const sigset_t *set,
int signo
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
47bfa: 56c0 sne %d0
47bfc: 49c0 extbl %d0
47bfe: 4480 negl %d0
47c00: 6002 bras 47c04 <sigismember+0x3c>
if ( !signo )
return 0;
47c02: 4280 clrl %d0
if ( *set & signo_to_mask(signo) )
return 1;
return 0;
}
47c04: 4e5e unlk %fp <== NOT EXECUTED
00046328 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
46328: 4e56 ffdc linkw %fp,#-36
4632c: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
46330: 266e 0008 moveal %fp@(8),%a3
46334: 246e 000c moveal %fp@(12),%a2
46338: 242e 0010 movel %fp@(16),%d2
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
4633c: 4a8b tstl %a3
4633e: 6730 beqs 46370 <sigtimedwait+0x48>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
46340: 4a82 tstl %d2
46342: 673c beqs 46380 <sigtimedwait+0x58>
if ( !_Timespec_Is_valid( timeout ) )
46344: 2f02 movel %d2,%sp@-
46346: 4eb9 0004 974c jsr 4974c <_Timespec_Is_valid>
4634c: 588f addql #4,%sp
4634e: 4a00 tstb %d0
46350: 6610 bnes 46362 <sigtimedwait+0x3a>
rtems_set_errno_and_return_minus_one( EINVAL );
46352: 4eb9 0004 dfc8 jsr 4dfc8 <__errno>
46358: 7616 moveq #22,%d3
4635a: 2240 moveal %d0,%a1
4635c: 2283 movel %d3,%a1@
4635e: 6000 014c braw 464ac <sigtimedwait+0x184>
interval = _Timespec_To_ticks( timeout );
46362: 2f02 movel %d2,%sp@-
46364: 4eb9 0004 97bc jsr 497bc <_Timespec_To_ticks>
if ( !interval )
4636a: 588f addql #4,%sp
4636c: 4a80 tstl %d0
4636e: 6612 bnes 46382 <sigtimedwait+0x5a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
46370: 4eb9 0004 dfc8 jsr 4dfc8 <__errno>
46376: 7416 moveq #22,%d2
46378: 2040 moveal %d0,%a0
4637a: 2082 movel %d2,%a0@
4637c: 6000 012e braw 464ac <sigtimedwait+0x184>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
46380: 4280 clrl %d0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
46382: 4a8a tstl %a2
46384: 6604 bnes 4638a <sigtimedwait+0x62>
46386: 45ee fff4 lea %fp@(-12),%a2
the_thread = _Thread_Executing;
4638a: 2079 0006 0dfa moveal 60dfa <_Per_CPU_Information+0xc>,%a0
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
46390: 223c 0000 0700 movel #1792,%d1
the_info = ( info ) ? info : &signal_information;
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
46396: 2868 0102 moveal %a0@(258),%a4
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
4639a: 40c3 movew %sr,%d3
4639c: 8283 orl %d3,%d1
4639e: 46c1 movew %d1,%sr
if ( *set & api->signals_pending ) {
463a0: 2413 movel %a3@,%d2
463a2: 2802 movel %d2,%d4
463a4: 222c 00d4 movel %a4@(212),%d1
463a8: c881 andl %d1,%d4
463aa: 672a beqs 463d6 <sigtimedwait+0xae>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
463ac: 2f01 movel %d1,%sp@-
463ae: 4eb9 0004 62dc jsr 462dc <_POSIX_signals_Get_lowest>
463b4: 2480 movel %d0,%a2@
_POSIX_signals_Clear_signals(
463b6: 4297 clrl %sp@
463b8: 42a7 clrl %sp@-
463ba: 2f0a movel %a2,%sp@-
463bc: 2f00 movel %d0,%sp@-
463be: 2f0c movel %a4,%sp@-
463c0: 4eb9 0004 b97c jsr 4b97c <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
463c6: 46c3 movew %d3,%sr
the_info->si_code = SI_USER;
463c8: 7001 moveq #1,%d0
the_info->si_value.sival_int = 0;
463ca: 42aa 0008 clrl %a2@(8)
return the_info->si_signo;
463ce: 2412 movel %a2@,%d2
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
463d0: 2540 0004 movel %d0,%a2@(4)
463d4: 6034 bras 4640a <sigtimedwait+0xe2>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
463d6: 2239 0006 1028 movel 61028 <_POSIX_signals_Pending>,%d1
463dc: c481 andl %d1,%d2
463de: 6732 beqs 46412 <sigtimedwait+0xea>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
463e0: 2f01 movel %d1,%sp@-
463e2: 4eb9 0004 62dc jsr 462dc <_POSIX_signals_Get_lowest>
463e8: 2400 movel %d0,%d2
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
463ea: 4297 clrl %sp@
463ec: 4878 0001 pea 1 <ADD>
463f0: 2f0a movel %a2,%sp@-
463f2: 2f00 movel %d0,%sp@-
463f4: 2f0c movel %a4,%sp@-
463f6: 4eb9 0004 b97c jsr 4b97c <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
463fc: 46c3 movew %d3,%sr
the_info->si_signo = signo;
the_info->si_code = SI_USER;
463fe: 7201 moveq #1,%d1
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
_ISR_Enable( level );
the_info->si_signo = signo;
46400: 2482 movel %d2,%a2@
the_info->si_code = SI_USER;
46402: 2541 0004 movel %d1,%a2@(4)
the_info->si_value.sival_int = 0;
46406: 42aa 0008 clrl %a2@(8)
return signo;
4640a: 4fef 0014 lea %sp@(20),%sp
4640e: 6000 009e braw 464ae <sigtimedwait+0x186>
}
the_info->si_signo = -1;
46412: 72ff moveq #-1,%d1
46414: 2481 movel %d1,%a2@
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
46416: 2239 0006 0998 movel 60998 <_Thread_Dispatch_disable_level>,%d1
4641c: 5281 addql #1,%d1
4641e: 23c1 0006 0998 movel %d1,60998 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
46424: 2239 0006 0998 movel 60998 <_Thread_Dispatch_disable_level>,%d1
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
4642a: 7204 moveq #4,%d1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
4642c: 43f9 0006 0fc0 lea 60fc0 <_POSIX_signals_Wait_queue>,%a1
the_thread->Wait.return_code = EINTR;
46432: 2141 0034 movel %d1,%a0@(52)
the_thread->Wait.option = *set;
46436: 2153 0030 movel %a3@,%a0@(48)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
4643a: 123c 0001 moveb #1,%d1
the_thread->Wait.return_argument = the_info;
4643e: 214a 0028 movel %a2,%a0@(40)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
46442: 2149 0044 movel %a1,%a0@(68)
46446: 23c1 0006 0ff0 movel %d1,60ff0 <_POSIX_signals_Wait_queue+0x30>
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
4644c: 46c3 movew %d3,%sr
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
4644e: 4879 0004 9520 pea 49520 <_Thread_queue_Timeout>
46454: 2f00 movel %d0,%sp@-
46456: 4879 0006 0fc0 pea 60fc0 <_POSIX_signals_Wait_queue>
4645c: 4eb9 0004 9228 jsr 49228 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
46462: 4eb9 0004 8df0 jsr 48df0 <_Thread_Enable_dispatch>
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
46468: 42a7 clrl %sp@-
4646a: 42a7 clrl %sp@-
4646c: 2f0a movel %a2,%sp@-
4646e: 2f12 movel %a2@,%sp@-
46470: 2f0c movel %a4,%sp@-
46472: 4eb9 0004 b97c jsr 4b97c <_POSIX_signals_Clear_signals>
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
46478: 2079 0006 0dfa moveal 60dfa <_Per_CPU_Information+0xc>,%a0
4647e: 4fef 0020 lea %sp@(32),%sp
46482: 7004 moveq #4,%d0
46484: b0a8 0034 cmpl %a0@(52),%d0
46488: 6610 bnes 4649a <sigtimedwait+0x172>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
4648a: 2412 movel %a2@,%d2
4648c: 2202 movel %d2,%d1
4648e: 5381 subql #1,%d1
46490: 103c 0001 moveb #1,%d0
46494: e3a8 lsll %d1,%d0
46496: c093 andl %a3@,%d0
46498: 6614 bnes 464ae <sigtimedwait+0x186>
errno = _Thread_Executing->Wait.return_code;
4649a: 4eb9 0004 dfc8 jsr 4dfc8 <__errno>
464a0: 2079 0006 0dfa moveal 60dfa <_Per_CPU_Information+0xc>,%a0
464a6: 2240 moveal %d0,%a1
464a8: 22a8 0034 movel %a0@(52),%a1@
return -1;
464ac: 74ff moveq #-1,%d2
}
return the_info->si_signo;
}
464ae: 2002 movel %d2,%d0
464b0: 4cee 1c1c ffdc moveml %fp@(-36),%d2-%d4/%a2-%a4
464b6: 4e5e unlk %fp
...
00047eb8 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
47eb8: 4e56 0000 linkw %fp,#0
47ebc: 2f0a movel %a2,%sp@-
47ebe: 246e 000c moveal %fp@(12),%a2
int status;
status = sigtimedwait( set, NULL, NULL );
47ec2: 42a7 clrl %sp@-
47ec4: 42a7 clrl %sp@-
47ec6: 2f2e 0008 movel %fp@(8),%sp@-
47eca: 4eb9 0004 7d0c jsr 47d0c <sigtimedwait>
if ( status != -1 ) {
47ed0: 4fef 000c lea %sp@(12),%sp
47ed4: 72ff moveq #-1,%d1
47ed6: b280 cmpl %d0,%d1
47ed8: 6708 beqs 47ee2 <sigwait+0x2a>
if ( sig )
47eda: 4a8a tstl %a2
47edc: 6710 beqs 47eee <sigwait+0x36> <== NEVER TAKEN
*sig = status;
47ede: 2480 movel %d0,%a2@
47ee0: 600c bras 47eee <sigwait+0x36>
return 0;
}
return errno;
47ee2: 4eb9 0004 f778 jsr 4f778 <__errno>
47ee8: 2040 moveal %d0,%a0
47eea: 2010 movel %a0@,%d0
47eec: 6002 bras 47ef0 <sigwait+0x38>
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
47eee: 4280 clrl %d0
}
return errno;
}
47ef0: 246e fffc moveal %fp@(-4),%a2
47ef4: 4e5e unlk %fp <== NOT EXECUTED
000447e2 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
447e2: 4e56 0000 linkw %fp,#0
447e6: 2f0a movel %a2,%sp@-
447e8: 246e 000c moveal %fp@(12),%a2
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
447ec: 202a 003c movel %a2@(60),%d0
447f0: 0280 0000 0e78 andil #3704,%d0
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
447f6: 2f02 movel %d2,%sp@-
447f8: 142e 000b moveb %fp@(11),%d2
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
447fc: 4a80 tstl %d0
447fe: 673a beqs 4483a <siproc+0x58> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44800: 42a7 clrl %sp@-
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
}
}
}
44802: 0282 0000 00ff andil #255,%d2
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44808: 42a7 clrl %sp@-
4480a: 2f2a 0018 movel %a2@(24),%sp@-
4480e: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
i = iproc (c, tty);
44814: 2f0a movel %a2,%sp@-
44816: 2f02 movel %d2,%sp@-
44818: 4eba fe60 jsr %pc@(4467a <iproc>)
rtems_semaphore_release (tty->osem);
4481c: 2f2a 0018 movel %a2@(24),%sp@-
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
44820: 2400 movel %d0,%d2
rtems_semaphore_release (tty->osem);
44822: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
44828: 246e fffc moveal %fp@(-4),%a2
4482c: 2002 movel %d2,%d0
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
4482e: 4fef 0018 lea %sp@(24),%sp
}
else {
i = iproc (c, tty);
}
return i;
}
44832: 242e fff8 movel %fp@(-8),%d2
44836: 4e5e unlk %fp
44838: 4e75 rts
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
4483a: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED
}
return i;
}
4483e: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
44842: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
44848: 2d42 0008 movel %d2,%fp@(8) <== NOT EXECUTED
}
return i;
}
4484c: 242e fff8 movel %fp@(-8),%d2 <== NOT EXECUTED
44850: 4e5e unlk %fp <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
44852: 6000 fe26 braw 4467a <iproc> <== NOT EXECUTED
000459f8 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
459f8: 4e56 ffdc linkw %fp,#-36
459fc: 48d7 040c moveml %d2-%d3/%a2,%sp@
45a00: 246e 0008 moveal %fp@(8),%a2
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
45a04: 240e movel %fp,%d2
45a06: 0682 ffff ffec addil #-20,%d2
45a0c: 2f0a movel %a2,%sp@-
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
45a0e: 262e 000c movel %fp@(12),%d3
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
45a12: 4eb9 0005 0fe4 jsr 50fe4 <strlen>
45a18: 7201 moveq #1,%d1
45a1a: 2e81 movel %d1,%sp@
45a1c: 2f02 movel %d2,%sp@-
45a1e: 42a7 clrl %sp@-
45a20: 2f00 movel %d0,%sp@-
45a22: 2f0a movel %a2,%sp@-
45a24: 4eb9 0004 4738 jsr 44738 <rtems_filesystem_evaluate_path>
45a2a: 4fef 0014 lea %sp@(20),%sp
45a2e: 4a80 tstl %d0
45a30: 6638 bnes 45a6a <statvfs+0x72> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
45a32: 4878 0038 pea 38 <DBL_MANT_DIG+0x3>
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
45a36: 246e fffc moveal %fp@(-4),%a2
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
45a3a: 42a7 clrl %sp@-
45a3c: 2f03 movel %d3,%sp@-
45a3e: 4eb9 0004 fde8 jsr 4fde8 <memset>
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
45a44: 206a 0028 moveal %a2@(40),%a0
45a48: 2f03 movel %d3,%sp@-
45a4a: 486a 001c pea %a2@(28)
45a4e: 2068 0044 moveal %a0@(68),%a0
45a52: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
45a54: 2f02 movel %d2,%sp@-
45a56: 2d40 ffe8 movel %d0,%fp@(-24)
45a5a: 4eb9 0004 4804 jsr 44804 <rtems_filesystem_freenode>
return result;
45a60: 202e ffe8 movel %fp@(-24),%d0
45a64: 4fef 0018 lea %sp@(24),%sp
45a68: 6002 bras 45a6c <statvfs+0x74>
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
45a6a: 70ff moveq #-1,%d0 <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
rtems_filesystem_freenode( &loc );
return result;
}
45a6c: 4cee 040c ffdc moveml %fp@(-36),%d2-%d3/%a2
45a72: 4e5e unlk %fp
...
00044810 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
44810: 4e56 0000 linkw %fp,#0
44814: 206e 0008 moveal %fp@(8),%a0
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
44818: 2028 00fa movel %a0@(250),%d0
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
4481c: 2f02 movel %d2,%sp@-
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
4481e: 4a80 tstl %d0
44820: 6728 beqs 4484a <sync_per_thread+0x3a> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
44822: 2279 0006 082a moveal 6082a <_Per_CPU_Information+0xc>,%a1
44828: 2429 00fa movel %a1@(250),%d2
_Thread_Executing->libc_reent = this_reent;
4482c: 2340 00fa movel %d0,%a1@(250)
_fwalk (t->libc_reent, sync_wrapper);
44830: 487a 0020 pea %pc@(44852 <sync_wrapper>)
44834: 2f28 00fa movel %a0@(250),%sp@-
44838: 4eb9 0004 e984 jsr 4e984 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
4483e: 2079 0006 082a moveal 6082a <_Per_CPU_Information+0xc>,%a0
44844: 508f addql #8,%sp
44846: 2142 00fa movel %d2,%a0@(250)
}
}
4484a: 242e fffc movel %fp@(-4),%d2
4484e: 4e5e unlk %fp <== NOT EXECUTED
0004aef4 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
4aef4: 4e56 0000 linkw %fp,#0
4aef8: 202e 000c movel %fp@(12),%d0
4aefc: 2f03 movel %d3,%sp@-
4aefe: 262e 0010 movel %fp@(16),%d3
4af02: 2f02 movel %d2,%sp@-
4af04: 242e 0008 movel %fp@(8),%d2
switch (opt) {
4af08: 4a80 tstl %d0
4af0a: 672c beqs 4af38 <tcsetattr+0x44>
4af0c: 7201 moveq #1,%d1
4af0e: b280 cmpl %d0,%d1
4af10: 6710 beqs 4af22 <tcsetattr+0x2e>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
4af12: 4eb9 0004 e514 jsr 4e514 <__errno>
4af18: 2040 moveal %d0,%a0
4af1a: 20bc 0000 0086 movel #134,%a0@
4af20: 6034 bras 4af56 <tcsetattr+0x62>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
4af22: 42a7 clrl %sp@-
4af24: 4878 0003 pea 3 <DIVIDE>
4af28: 2f02 movel %d2,%sp@-
4af2a: 4eb9 0004 abf4 jsr 4abf4 <ioctl>
4af30: 4fef 000c lea %sp@(12),%sp
4af34: 4a80 tstl %d0
4af36: 6d1e blts 4af56 <tcsetattr+0x62> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4af38: 2d43 0010 movel %d3,%fp@(16)
4af3c: 7002 moveq #2,%d0
4af3e: 2d42 0008 movel %d2,%fp@(8)
}
}
4af42: 242e fff8 movel %fp@(-8),%d2
4af46: 262e fffc movel %fp@(-4),%d3
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4af4a: 2d40 000c movel %d0,%fp@(12)
}
}
4af4e: 4e5e unlk %fp
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4af50: 4ef9 0004 abf4 jmp 4abf4 <ioctl>
}
}
4af56: 242e fff8 movel %fp@(-8),%d2
4af5a: 70ff moveq #-1,%d0
4af5c: 262e fffc movel %fp@(-4),%d3
4af60: 4e5e unlk %fp <== NOT EXECUTED
000454bc <timer_create>:
timer_t *timerid
)
{
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
454bc: 7001 moveq #1,%d0
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
454be: 4e56 0000 linkw %fp,#0
454c2: 2f0b movel %a3,%sp@-
454c4: 266e 0010 moveal %fp@(16),%a3
454c8: 2f0a movel %a2,%sp@-
454ca: 246e 000c moveal %fp@(12),%a2
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
454ce: b0ae 0008 cmpl %fp@(8),%d0
454d2: 6620 bnes 454f4 <timer_create+0x38>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
454d4: 4a8b tstl %a3
454d6: 671c beqs 454f4 <timer_create+0x38>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
454d8: 4a8a tstl %a2
454da: 6726 beqs 45502 <timer_create+0x46>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
454dc: 2012 movel %a2@,%d0
454de: 7201 moveq #1,%d1
454e0: 5380 subql #1,%d0
454e2: b280 cmpl %d0,%d1
454e4: 650e bcss 454f4 <timer_create+0x38> <== NEVER TAKEN
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
454e6: 202a 0004 movel %a2@(4),%d0
454ea: 6708 beqs 454f4 <timer_create+0x38> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
454ec: 5380 subql #1,%d0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
454ee: 721f moveq #31,%d1
454f0: b280 cmpl %d0,%d1
454f2: 640e bccs 45502 <timer_create+0x46> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
454f4: 4eb9 0004 d4b0 jsr 4d4b0 <__errno>
454fa: 7216 moveq #22,%d1
454fc: 2040 moveal %d0,%a0
454fe: 2081 movel %d1,%a0@
45500: 603a bras 4553c <timer_create+0x80>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45502: 2039 0005 f538 movel 5f538 <_Thread_Dispatch_disable_level>,%d0
45508: 5280 addql #1,%d0
4550a: 23c0 0005 f538 movel %d0,5f538 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45510: 2039 0005 f538 movel 5f538 <_Thread_Dispatch_disable_level>,%d0
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
45516: 4879 0005 f780 pea 5f780 <_POSIX_Timer_Information>
4551c: 4eb9 0004 71e8 jsr 471e8 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
45522: 588f addql #4,%sp
45524: 2040 moveal %d0,%a0
45526: 4a80 tstl %d0
45528: 6616 bnes 45540 <timer_create+0x84>
_Thread_Enable_dispatch();
4552a: 4eb9 0004 825c jsr 4825c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
45530: 4eb9 0004 d4b0 jsr 4d4b0 <__errno>
45536: 2040 moveal %d0,%a0
45538: 700b moveq #11,%d0
4553a: 2080 movel %d0,%a0@
4553c: 70ff moveq #-1,%d0
4553e: 606a bras 455aa <timer_create+0xee>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
45540: 7002 moveq #2,%d0
45542: 1140 003c moveb %d0,%a0@(60)
ptimer->thread_id = _Thread_Executing->Object.id;
45546: 2279 0005 f99a moveal 5f99a <_Per_CPU_Information+0xc>,%a1
4554c: 2169 0008 0038 movel %a1@(8),%a0@(56)
if ( evp != NULL ) {
45552: 4a8a tstl %a2
45554: 6710 beqs 45566 <timer_create+0xaa>
ptimer->inf.sigev_notify = evp->sigev_notify;
45556: 2152 003e movel %a2@,%a0@(62)
ptimer->inf.sigev_signo = evp->sigev_signo;
4555a: 216a 0004 0042 movel %a2@(4),%a0@(66)
ptimer->inf.sigev_value = evp->sigev_value;
45560: 216a 0008 0046 movel %a2@(8),%a0@(70)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45566: 2028 0008 movel %a0@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4556a: 4281 clrl %d1
4556c: 2279 0005 f798 moveal 5f798 <_POSIX_Timer_Information+0x18>,%a1
45572: 3200 movew %d0,%d1
}
ptimer->overrun = 0;
45574: 42a8 0066 clrl %a0@(102)
ptimer->timer_data.it_value.tv_sec = 0;
45578: 42a8 005a clrl %a0@(90)
ptimer->timer_data.it_value.tv_nsec = 0;
4557c: 42a8 005e clrl %a0@(94)
ptimer->timer_data.it_interval.tv_sec = 0;
45580: 42a8 0052 clrl %a0@(82)
ptimer->timer_data.it_interval.tv_nsec = 0;
45584: 42a8 0056 clrl %a0@(86)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
45588: 42a8 0018 clrl %a0@(24)
the_watchdog->routine = routine;
4558c: 42a8 002c clrl %a0@(44)
the_watchdog->id = id;
45590: 42a8 0030 clrl %a0@(48)
the_watchdog->user_data = user_data;
45594: 42a8 0034 clrl %a0@(52)
45598: 2388 1c00 movel %a0,%a1@(00000000,%d1:l:4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
4559c: 42a8 000c clrl %a0@(12)
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
455a0: 2680 movel %d0,%a3@
_Thread_Enable_dispatch();
455a2: 4eb9 0004 825c jsr 4825c <_Thread_Enable_dispatch>
return 0;
455a8: 4280 clrl %d0
}
455aa: 246e fff8 moveal %fp@(-8),%a2
455ae: 266e fffc moveal %fp@(-4),%a3
455b2: 4e5e unlk %fp
...
000456b2 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
456b2: 4e56 ffe8 linkw %fp,#-24
456b6: 48d7 041c moveml %d2-%d4/%a2,%sp@
456ba: 262e 0008 movel %fp@(8),%d3
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
456be: 4ab9 0006 0968 tstl 60968 <_POSIX_signals_Ualarm_timer+0x1c>
456c4: 6620 bnes 456e6 <ualarm+0x34>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
456c6: 42b9 0006 0954 clrl 60954 <_POSIX_signals_Ualarm_timer+0x8>
the_watchdog->routine = routine;
456cc: 203c 0004 5670 movel #284272,%d0
the_watchdog->id = id;
456d2: 42b9 0006 096c clrl 6096c <_POSIX_signals_Ualarm_timer+0x20>
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
456d8: 23c0 0006 0968 movel %d0,60968 <_POSIX_signals_Ualarm_timer+0x1c>
the_watchdog->id = id;
the_watchdog->user_data = user_data;
456de: 42b9 0006 0970 clrl 60970 <_POSIX_signals_Ualarm_timer+0x24>
456e4: 6056 bras 4573c <ualarm+0x8a>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
456e6: 4879 0006 094c pea 6094c <_POSIX_signals_Ualarm_timer>
456ec: 4eb9 0004 8ef0 jsr 48ef0 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
456f2: 588f addql #4,%sp
456f4: 7201 moveq #1,%d1
456f6: 5580 subql #2,%d0
456f8: b280 cmpl %d0,%d1
456fa: 6540 bcss 4573c <ualarm+0x8a> <== NEVER TAKEN
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
456fc: 2039 0006 0960 movel 60960 <_POSIX_signals_Ualarm_timer+0x14>,%d0
45702: d0b9 0006 0958 addl 60958 <_POSIX_signals_Ualarm_timer+0xc>,%d0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
45708: 486e fff8 pea %fp@(-8)
4570c: 90b9 0006 0964 subl 60964 <_POSIX_signals_Ualarm_timer+0x18>,%d0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
45712: 283c 000f 4240 movel #1000000,%d4
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
45718: 2f00 movel %d0,%sp@-
4571a: 4eb9 0004 8a04 jsr 48a04 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
45720: 202e fff8 movel %fp@(-8),%d0
45724: 4c04 0800 mulsl %d4,%d0
remaining += tp.tv_nsec / 1000;
45728: 283c 0000 03e8 movel #1000,%d4
4572e: 508f addql #8,%sp
45730: 242e fffc movel %fp@(-4),%d2
45734: 4c44 2802 remsl %d4,%d2,%d2
45738: d480 addl %d0,%d2
4573a: 6002 bras 4573e <ualarm+0x8c>
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
4573c: 4282 clrl %d2
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
4573e: 4a83 tstl %d3
45740: 674e beqs 45790 <ualarm+0xde>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
45742: 283c 0000 03e8 movel #1000,%d4
ticks = _Timespec_To_ticks( &tp );
45748: 45f9 0004 8a88 lea 48a88 <_Timespec_To_ticks>,%a2
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
4574e: 223c 000f 4240 movel #1000000,%d1
45754: 4c41 3000 remul %d1,%d0,%d3
45758: 4c41 3003 remul %d1,%d3,%d3
4575c: 2d43 fff8 movel %d3,%fp@(-8)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
45760: 4c00 4800 mulsl %d0,%d4
ticks = _Timespec_To_ticks( &tp );
45764: 260e movel %fp,%d3
45766: 5183 subql #8,%d3
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
45768: 2d44 fffc movel %d4,%fp@(-4)
ticks = _Timespec_To_ticks( &tp );
4576c: 2f03 movel %d3,%sp@-
4576e: 4e92 jsr %a2@
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
45770: 2f03 movel %d3,%sp@-
45772: 4e92 jsr %a2@
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
45774: 4879 0006 094c pea 6094c <_POSIX_signals_Ualarm_timer>
4577a: 4879 0006 01f0 pea 601f0 <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
45780: 23c0 0006 0958 movel %d0,60958 <_POSIX_signals_Ualarm_timer+0xc>
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
45786: 4eb9 0004 8dcc jsr 48dcc <_Watchdog_Insert>
4578c: 4fef 0010 lea %sp@(16),%sp
}
return remaining;
}
45790: 2002 movel %d2,%d0
45792: 4cee 041c ffe8 moveml %fp@(-24),%d2-%d4/%a2
45798: 4e5e unlk %fp <== NOT EXECUTED
000484ac <unmount>:
*/
int unmount(
const char *path
)
{
484ac: 4e56 ffe0 linkw %fp,#-32
484b0: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
484b4: 246e 0008 moveal %fp@(8),%a2
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
484b8: 7401 moveq #1,%d2
484ba: 2f0a movel %a2,%sp@-
484bc: 4eb9 0005 a2f0 jsr 5a2f0 <strlen>
484c2: 2e82 movel %d2,%sp@
484c4: 240e movel %fp,%d2
484c6: 0682 ffff ffec addil #-20,%d2
484cc: 2f02 movel %d2,%sp@-
484ce: 42a7 clrl %sp@-
484d0: 2f00 movel %d0,%sp@-
484d2: 2f0a movel %a2,%sp@-
484d4: 4eb9 0004 52f0 jsr 452f0 <rtems_filesystem_evaluate_path>
484da: 4fef 0014 lea %sp@(20),%sp
484de: 4a80 tstl %d0
484e0: 6600 00e8 bnew 485ca <unmount+0x11e>
return -1;
mt_entry = loc.mt_entry;
484e4: 246e fffc moveal %fp@(-4),%a2
484e8: 47f9 0004 54bc lea 454bc <rtems_filesystem_freenode>,%a3
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
484ee: 202e ffec movel %fp@(-20),%d0
484f2: b0aa 001c cmpl %a2@(28),%d0
484f6: 6716 beqs 4850e <unmount+0x62>
rtems_filesystem_freenode( &loc );
484f8: 2f02 movel %d2,%sp@-
484fa: 4e93 jsr %a3@
rtems_set_errno_and_return_minus_one( EACCES );
484fc: 4eb9 0005 8b98 jsr 58b98 <__errno>
48502: 588f addql #4,%sp
48504: 720d moveq #13,%d1
48506: 2040 moveal %d0,%a0
48508: 2081 movel %d1,%a0@
4850a: 6000 00be braw 485ca <unmount+0x11e>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
4850e: 2f02 movel %d2,%sp@-
48510: 4e93 jsr %a3@
* that made the current node thread based instead
* of system based? I thought it was but it doesn't
* look like it in this version.
*/
if ( rtems_filesystem_current.mt_entry == mt_entry )
48512: 2079 0006 9c40 moveal 69c40 <rtems_current_user_env>,%a0
48518: 588f addql #4,%sp
4851a: b5e8 0014 cmpal %a0@(20),%a2
4851e: 6724 beqs 48544 <unmount+0x98>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
48520: 2f2a 002c movel %a2@(44),%sp@-
48524: 487a ff6e pea %pc@(48494 <is_fs_below_mount_point>)
48528: 4eb9 0004 5cb4 jsr 45cb4 <rtems_filesystem_mount_iterate>
4852e: 508f addql #8,%sp
48530: 4a00 tstb %d0
48532: 6610 bnes 48544 <unmount+0x98>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
48534: 2f0a movel %a2,%sp@-
48536: 4eb9 0004 5808 jsr 45808 <rtems_libio_is_open_files_in_fs>
4853c: 588f addql #4,%sp
4853e: 7201 moveq #1,%d1
48540: b280 cmpl %d0,%d1
48542: 660e bnes 48552 <unmount+0xa6>
rtems_set_errno_and_return_minus_one( EBUSY );
48544: 4eb9 0005 8b98 jsr 58b98 <__errno>
4854a: 2040 moveal %d0,%a0
4854c: 7010 moveq #16,%d0
4854e: 2080 movel %d0,%a0@
48550: 6078 bras 485ca <unmount+0x11e>
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
48552: 206a 0014 moveal %a2@(20),%a0
48556: 2f0a movel %a2,%sp@-
48558: 2068 0028 moveal %a0@(40),%a0
4855c: 4e90 jsr %a0@
4855e: 588f addql #4,%sp
48560: 4a80 tstl %d0
48562: 6666 bnes 485ca <unmount+0x11e> <== NEVER TAKEN
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
48564: 206a 0028 moveal %a2@(40),%a0
48568: 2f0a movel %a2,%sp@-
4856a: 2068 002c moveal %a0@(44),%a0
4856e: 4e90 jsr %a0@
48570: 588f addql #4,%sp
48572: 4a80 tstl %d0
48574: 671a beqs 48590 <unmount+0xe4> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
48576: 206a 0014 moveal %a2@(20),%a0 <== NOT EXECUTED
4857a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4857c: 2068 0020 moveal %a0@(32),%a0 <== NOT EXECUTED
48580: 4e90 jsr %a0@ <== NOT EXECUTED
48582: 588f addql #4,%sp <== NOT EXECUTED
48584: 4a80 tstl %d0 <== NOT EXECUTED
48586: 6742 beqs 485ca <unmount+0x11e> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
48588: 42a7 clrl %sp@- <== NOT EXECUTED
4858a: 4eb9 0004 9694 jsr 49694 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
48590: 42a7 clrl %sp@-
48592: 42a7 clrl %sp@-
48594: 2f39 0006 b390 movel 6b390 <rtems_libio_semaphore>,%sp@-
4859a: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
485a0: 2f0a movel %a2,%sp@-
485a2: 4eb9 0004 9a3c jsr 49a3c <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
485a8: 2f39 0006 b390 movel 6b390 <rtems_libio_semaphore>,%sp@-
485ae: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
/*
* Free the memory node that was allocated in mount
* Free the memory associated with the extracted mount table entry.
*/
rtems_filesystem_freenode( fs_mount_loc );
485b4: 486a 0008 pea %a2@(8)
485b8: 4e93 jsr %a3@
free( mt_entry );
485ba: 2f0a movel %a2,%sp@-
485bc: 4eb9 0004 54d0 jsr 454d0 <free>
return 0;
485c2: 4fef 001c lea %sp@(28),%sp
485c6: 4280 clrl %d0
485c8: 6002 bras 485cc <unmount+0x120>
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
rtems_fatal_error_occurred( 0 );
return -1;
485ca: 70ff moveq #-1,%d0
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
485cc: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3
485d2: 4e5e unlk %fp
...
0005aba8 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
5aba8: 4e56 fff4 linkw %fp,#-12
5abac: 202e 0008 movel %fp@(8),%d0
5abb0: 222e 000c movel %fp@(12),%d1
5abb4: 206e 0010 moveal %fp@(16),%a0
5abb8: 48d7 040c moveml %d2-%d3/%a2,%sp@
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
5abbc: b0b9 0005 d2e2 cmpl 5d2e2 <rtems_libio_number_iops>,%d0
5abc2: 6434 bccs 5abf8 <write+0x50>
iop = rtems_libio_iop( fd );
5abc4: 2400 movel %d0,%d2
5abc6: ed88 lsll #6,%d0
5abc8: e78a lsll #3,%d2
5abca: 2479 0005 ea44 moveal 5ea44 <rtems_libio_iops>,%a2
5abd0: 9082 subl %d2,%d0
5abd2: d5c0 addal %d0,%a2
rtems_libio_check_is_open( iop );
5abd4: 202a 0014 movel %a2@(20),%d0
5abd8: 0800 0008 btst #8,%d0
5abdc: 671a beqs 5abf8 <write+0x50>
rtems_libio_check_buffer( buffer );
5abde: 4a81 tstl %d1
5abe0: 660e bnes 5abf0 <write+0x48> <== ALWAYS TAKEN
5abe2: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED
5abe8: 7216 moveq #22,%d1 <== NOT EXECUTED
5abea: 2040 moveal %d0,%a0 <== NOT EXECUTED
5abec: 2081 movel %d1,%a0@ <== NOT EXECUTED
5abee: 6014 bras 5ac04 <write+0x5c> <== NOT EXECUTED
rtems_libio_check_count( count );
5abf0: 4a88 tstl %a0
5abf2: 6742 beqs 5ac36 <write+0x8e>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
5abf4: 44c0 movew %d0,%ccr
5abf6: 6710 beqs 5ac08 <write+0x60>
5abf8: 4eb9 0004 cd68 jsr 4cd68 <__errno>
5abfe: 2040 moveal %d0,%a0
5ac00: 7009 moveq #9,%d0
5ac02: 2080 movel %d0,%a0@
5ac04: 70ff moveq #-1,%d0
5ac06: 6030 bras 5ac38 <write+0x90>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
5ac08: 226a 0020 moveal %a2@(32),%a1
5ac0c: 2f08 movel %a0,%sp@-
5ac0e: 2f01 movel %d1,%sp@-
5ac10: 2f0a movel %a2,%sp@-
5ac12: 2069 000c moveal %a1@(12),%a0
5ac16: 4e90 jsr %a0@
if ( rc > 0 )
5ac18: 4fef 000c lea %sp@(12),%sp
5ac1c: 4a80 tstl %d0
5ac1e: 6f18 bles 5ac38 <write+0x90>
iop->offset += rc;
5ac20: 2600 movel %d0,%d3
5ac22: 5bc2 smi %d2
5ac24: 49c2 extbl %d2
5ac26: d7aa 0010 addl %d3,%a2@(16)
5ac2a: 222a 000c movel %a2@(12),%d1
5ac2e: d382 addxl %d2,%d1
5ac30: 2541 000c movel %d1,%a2@(12)
5ac34: 6002 bras 5ac38 <write+0x90>
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
5ac36: 4280 clrl %d0
if ( rc > 0 )
iop->offset += rc;
return rc;
}
5ac38: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
5ac3e: 4e5e unlk %fp
...
0004614c <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
4614c: 4e56 ffe4 linkw %fp,#-28
46150: 202e 0008 movel %fp@(8),%d0
46154: 48d7 0cdc moveml %d2-%d4/%d6-%d7/%a2-%a3,%sp@
46158: 246e 000c moveal %fp@(12),%a2
4615c: 262e 0010 movel %fp@(16),%d3
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
46160: b0b9 0005 dae2 cmpl 5dae2 <rtems_libio_number_iops>,%d0
46166: 641e bccs 46186 <writev+0x3a>
iop = rtems_libio_iop( fd );
46168: 2200 movel %d0,%d1
4616a: ed88 lsll #6,%d0
4616c: e789 lsll #3,%d1
4616e: 2679 0005 f244 moveal 5f244 <rtems_libio_iops>,%a3
46174: 9081 subl %d1,%d0
46176: d7c0 addal %d0,%a3
rtems_libio_check_is_open( iop );
46178: 202b 0014 movel %a3@(20),%d0
4617c: 0800 0008 btst #8,%d0
46180: 6704 beqs 46186 <writev+0x3a>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
46182: 44c0 movew %d0,%ccr
46184: 6710 beqs 46196 <writev+0x4a> <== ALWAYS TAKEN
46186: 4eb9 0004 d7d8 jsr 4d7d8 <__errno>
4618c: 7209 moveq #9,%d1
4618e: 2040 moveal %d0,%a0
46190: 2081 movel %d1,%a0@
46192: 6000 0098 braw 4622c <writev+0xe0>
/*
* Argument validation on IO vector
*/
if ( !iov )
46196: 4a8a tstl %a2
46198: 672a beqs 461c4 <writev+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
4619a: 4a83 tstl %d3
4619c: 6f26 bles 461c4 <writev+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
4619e: 0c83 0000 0400 cmpil #1024,%d3
461a4: 6e1e bgts 461c4 <writev+0x78> <== NEVER TAKEN
461a6: 204a moveal %a2,%a0
461a8: 93c9 subal %a1,%a1
461aa: 4281 clrl %d1
461ac: 7001 moveq #1,%d0
461ae: 6002 bras 461b2 <writev+0x66>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
461b0: 2202 movel %d2,%d1
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
461b2: 4a90 tstl %a0@
461b4: 670e beqs 461c4 <writev+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
461b6: 2428 0004 movel %a0@(4),%d2
all_zeros = false;
461ba: 57c4 seq %d4
/* check for wrap */
old = total;
total += iov[v].iov_len;
461bc: d481 addl %d1,%d2
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
461be: c084 andl %d4,%d0
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
461c0: b282 cmpl %d2,%d1
461c2: 6f0e bles 461d2 <writev+0x86>
rtems_set_errno_and_return_minus_one( EINVAL );
461c4: 4eb9 0004 d7d8 jsr 4d7d8 <__errno>
461ca: 2040 moveal %d0,%a0
461cc: 7016 moveq #22,%d0
461ce: 2080 movel %d0,%a0@
461d0: 605a bras 4622c <writev+0xe0>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
461d2: 5289 addql #1,%a1
461d4: 5088 addql #8,%a0
461d6: b689 cmpl %a1,%d3
461d8: 66d6 bnes 461b0 <writev+0x64>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
461da: 4a00 tstb %d0
461dc: 664a bnes 46228 <writev+0xdc> <== NEVER TAKEN
461de: 4284 clrl %d4
461e0: 4282 clrl %d2
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
461e2: 202a 0004 movel %a2@(4),%d0
461e6: 6736 beqs 4621e <writev+0xd2> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
461e8: 206b 0020 moveal %a3@(32),%a0
461ec: 2f00 movel %d0,%sp@-
461ee: 2f12 movel %a2@,%sp@-
461f0: 2f0b movel %a3,%sp@-
461f2: 2068 000c moveal %a0@(12),%a0
461f6: 4e90 jsr %a0@
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
461f8: 4fef 000c lea %sp@(12),%sp
461fc: 4a80 tstl %d0
461fe: 6d2c blts 4622c <writev+0xe0> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
46200: 6716 beqs 46218 <writev+0xcc> <== NEVER TAKEN
iop->offset += bytes;
total += bytes;
46202: d480 addl %d0,%d2
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
46204: 2e00 movel %d0,%d7
46206: 5bc6 smi %d6
46208: 49c6 extbl %d6
4620a: dfab 0010 addl %d7,%a3@(16)
4620e: 222b 000c movel %a3@(12),%d1
46212: d386 addxl %d6,%d1
46214: 2741 000c movel %d1,%a3@(12)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
46218: b0aa 0004 cmpl %a2@(4),%d0
4621c: 6610 bnes 4622e <writev+0xe2> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
4621e: 5284 addql #1,%d4
46220: 508a addql #8,%a2
46222: b684 cmpl %d4,%d3
46224: 66bc bnes 461e2 <writev+0x96> <== NEVER TAKEN
46226: 6006 bras 4622e <writev+0xe2>
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
46228: 4282 clrl %d2
4622a: 6002 bras 4622e <writev+0xe2>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
4622c: 74ff moveq #-1,%d2
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
4622e: 2002 movel %d2,%d0
46230: 4cee 0cdc ffe4 moveml %fp@(-28),%d2-%d4/%d6-%d7/%a2-%a3
46236: 4e5e unlk %fp
...