00048ebc <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 ) {
48ebc: 7206 moveq #6,%d1
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
48ebe: 4e56 0000 linkw %fp,#0 48ec2: 206e 0008 moveal %fp@(8),%a0 48ec6: 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 ) {
48ec8: 2450 moveal %a0@,%a2
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
48eca: 2268 0010 moveal %a0@(16),%a1
switch( node->type ) {
48ece: 202a 0048 movel %a2@(72),%d0 48ed2: 5380 subql #1,%d0
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
48ed4: 2269 0034 moveal %a1@(52),%a1
switch( node->type ) {
48ed8: b280 cmpl %d0,%d1
48eda: 6546 bcss 48f22 <IMFS_Set_handlers+0x66> <== NEVER TAKEN
48edc: 303b 0a08 movew %pc@(48ee6 <IMFS_Set_handlers+0x2a>,%d0:l:2),%d0 48ee0: 48c0 extl %d0 48ee2: 4efb 0802 jmp %pc@(48ee6 <IMFS_Set_handlers+0x2a>,%d0:l)
48ee6: 000e .short 0x000e <== NOT EXECUTED 48ee8: 0016 .short 0x0016 <== NOT EXECUTED 48eea: 0022 .short 0x0022 <== NOT EXECUTED 48eec: 0022 .short 0x0022 <== NOT EXECUTED 48eee: 002e .short 0x002e <== NOT EXECUTED 48ef0: 002e .short 0x002e <== NOT EXECUTED 48ef2: 0036 .short 0x0036 <== NOT EXECUTED
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
48ef4: 2169 000c 0008 movel %a1@(12),%a0@(8)
break;
48efa: 6026 bras 48f22 <IMFS_Set_handlers+0x66>
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
48efc: 203c 0005 c378 movel #377720,%d0 48f02: 2140 0008 movel %d0,%a0@(8)
break;
48f06: 601a bras 48f22 <IMFS_Set_handlers+0x66>
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
48f08: 223c 0005 c3e8 movel #377832,%d1 48f0e: 2141 0008 movel %d1,%a0@(8)
break;
48f12: 600e bras 48f22 <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;
48f14: 2169 0008 0008 movel %a1@(8),%a0@(8)
break;
48f1a: 6006 bras 48f22 <IMFS_Set_handlers+0x66>
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
48f1c: 2169 0010 0008 movel %a1@(16),%a0@(8)
break;
}
return 0;
}
48f22: 245f moveal %sp@+,%a2 48f24: 4280 clrl %d0
48f26: 4e5e unlk %fp <== NOT EXECUTED
00048c88 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
48c88: 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;
48c8c: 206e 0008 moveal %fp@(8),%a0
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
48c90: 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;
48c94: 2450 moveal %a0@,%a2
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
48c96: 4284 clrl %d4
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
48c98: 362e 000e movew %fp@(14),%d3 48c9c: 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();
48ca0: 4eb9 0004 9aa0 jsr 49aa0 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
48ca6: 4281 clrl %d1 48ca8: 3800 movew %d0,%d4 48caa: 322a 0038 movew %a2@(56),%d1 48cae: b284 cmpl %d4,%d1
48cb0: 6714 beqs 48cc6 <IMFS_chown+0x3e>
48cb2: 4a40 tstw %d0
48cb4: 6710 beqs 48cc6 <IMFS_chown+0x3e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
48cb6: 4eb9 0004 cad0 jsr 4cad0 <__errno> 48cbc: 2040 moveal %d0,%a0 48cbe: 7001 moveq #1,%d0 48cc0: 2080 movel %d0,%a0@ 48cc2: 70ff moveq #-1,%d0 48cc4: 601e bras 48ce4 <IMFS_chown+0x5c>
#endif
jnode->st_uid = owner;
48cc6: 3543 0038 movew %d3,%a2@(56)
jnode->st_gid = group;
48cca: 3542 003a movew %d2,%a2@(58)
IMFS_update_ctime( jnode );
48cce: 42a7 clrl %sp@- 48cd0: 486e fff8 pea %fp@(-8) 48cd4: 4eb9 0004 2a74 jsr 42a74 <gettimeofday> 48cda: 256e fff8 0044 movel %fp@(-8),%a2@(68)
return 0;
48ce0: 508f addql #8,%sp 48ce2: 4280 clrl %d0
}
48ce4: 4cee 041c ffe8 moveml %fp@(-24),%d2-%d4/%a2 48cea: 4e5e unlk %fp
...
00048d6e <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
48d6e: 4e56 ffec linkw %fp,#-20 48d72: 206e 0008 moveal %fp@(8),%a0 48d76: 48d7 3c04 moveml %d2/%a2-%a5,%sp@ 48d7a: 242e 000c movel %fp@(12),%d2 48d7e: 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 )
48d82: 4a88 tstl %a0 48d84: 6700 00ee beqw 48e74 <IMFS_create_node+0x106>
return NULL;
parent = parent_loc->node_access;
48d88: 2850 moveal %a0@,%a4
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
48d8a: 7007 moveq #7,%d0
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
48d8c: 2068 0010 moveal %a0@(16),%a0 48d90: 2668 0034 moveal %a0@(52),%a3
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
48d94: b082 cmpl %d2,%d0
48d96: 660e bnes 48da6 <IMFS_create_node+0x38>
48d98: 223c 0005 c308 movel #377608,%d1 48d9e: b2ab 0010 cmpl %a3@(16),%d1 48da2: 6700 00d0 beqw 48e74 <IMFS_create_node+0x106>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
48da6: 2079 0005 d244 moveal 5d244 <rtems_current_user_env>,%a0 48dac: 2028 002c movel %a0@(44),%d0 48db0: 4680 notl %d0 48db2: c0ae 0014 andl %fp@(20),%d0 48db6: 2f00 movel %d0,%sp@- 48db8: 2f2e 0010 movel %fp@(16),%sp@- 48dbc: 2f02 movel %d2,%sp@- 48dbe: 4eb9 0004 8cf0 jsr 48cf0 <IMFS_allocate_node>
if ( !node )
48dc4: 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 );
48dc8: 2a40 moveal %d0,%a5
if ( !node )
48dca: 4a80 tstl %d0 48dcc: 6700 00a8 beqw 48e76 <IMFS_create_node+0x108>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
48dd0: 7001 moveq #1,%d0 48dd2: b082 cmpl %d2,%d0
48dd4: 6616 bnes 48dec <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 );
48dd6: 41ed 0050 lea %a5@(80),%a0 48dda: 2b48 004c movel %a0,%a5@(76)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
48dde: 41ed 004c lea %a5@(76),%a0
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
48de2: 42ad 0050 clrl %a5@(80)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
48de6: 2b48 0054 movel %a0,%a5@(84) 48dea: 6066 bras 48e52 <IMFS_create_node+0xe4>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
48dec: 7003 moveq #3,%d0 48dee: b082 cmpl %d2,%d0
48df0: 6706 beqs 48df8 <IMFS_create_node+0x8a>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
48df2: 7204 moveq #4,%d1 48df4: b282 cmpl %d2,%d1
48df6: 6606 bnes 48dfe <IMFS_create_node+0x90>
node->info.sym_link.name = info->sym_link.name;
48df8: 2b52 004c movel %a2@,%a5@(76) 48dfc: 6054 bras 48e52 <IMFS_create_node+0xe4>
} else if ( type == IMFS_DEVICE ) {
48dfe: 7002 moveq #2,%d0 48e00: b082 cmpl %d2,%d0
48e02: 660c bnes 48e10 <IMFS_create_node+0xa2>
node->info.device.major = info->device.major;
48e04: 2b52 004c movel %a2@,%a5@(76)
node->info.device.minor = info->device.minor;
48e08: 2b6a 0004 0050 movel %a2@(4),%a5@(80) 48e0e: 6042 bras 48e52 <IMFS_create_node+0xe4>
} else if ( type == IMFS_LINEAR_FILE ) {
48e10: 7206 moveq #6,%d1 48e12: b282 cmpl %d2,%d1
48e14: 6612 bnes 48e28 <IMFS_create_node+0xba>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
48e16: 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;
48e1a: 4280 clrl %d0 48e1c: 4281 clrl %d1 48e1e: 2b40 004c movel %d0,%a5@(76) 48e22: 2b41 0050 movel %d1,%a5@(80) 48e26: 602a bras 48e52 <IMFS_create_node+0xe4>
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
48e28: 7205 moveq #5,%d1 48e2a: b282 cmpl %d2,%d1
48e2c: 661a bnes 48e48 <IMFS_create_node+0xda>
node->info.file.size = 0;
node->info.file.indirect = 0;
48e2e: 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;
48e32: 4280 clrl %d0 48e34: 4281 clrl %d1
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
48e36: 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;
48e3a: 2b40 004c movel %d0,%a5@(76) 48e3e: 2b41 0050 movel %d1,%a5@(80)
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
48e42: 42ad 005c clrl %a5@(92) 48e46: 600a bras 48e52 <IMFS_create_node+0xe4>
} else if ( type == IMFS_FIFO ) {
48e48: 7207 moveq #7,%d1 48e4a: b282 cmpl %d2,%d1
48e4c: 6604 bnes 48e52 <IMFS_create_node+0xe4> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
48e4e: 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;
48e52: 202b 0004 movel %a3@(4),%d0 48e56: 5280 addql #1,%d0
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
48e58: 2b4c 0008 movel %a4,%a5@(8)
node->st_ino = ++fs_info->ino_count;
48e5c: 2740 0004 movel %d0,%a3@(4) 48e60: 2b40 0034 movel %d0,%a5@(52) 48e64: 2f0d movel %a5,%sp@- 48e66: 486c 004c pea %a4@(76) 48e6a: 4eb9 0004 6208 jsr 46208 <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
48e70: 508f addql #8,%sp 48e72: 6002 bras 48e76 <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;
48e74: 9bcd subal %a5,%a5
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
48e76: 200d movel %a5,%d0 48e78: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
48e7e: 4e5e unlk %fp <== NOT EXECUTED
00048fe4 <IMFS_eval_path>:
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
48fe4: 70f8 moveq #-8,%d0
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
48fe6: 4e56 ff9c linkw %fp,#-100 48fea: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 48fee: 282e 0010 movel %fp@(16),%d4
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
48ff2: c084 andl %d4,%d0
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
48ff4: 2a6e 0008 moveal %fp@(8),%a5 48ff8: 286e 000c moveal %fp@(12),%a4 48ffc: 246e 0014 moveal %fp@(20),%a2
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
49000: 670e beqs 49010 <IMFS_eval_path+0x2c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
49002: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 49008: 7c05 moveq #5,%d6 <== NOT EXECUTED 4900a: 2040 moveal %d0,%a0 <== NOT EXECUTED 4900c: 2086 movel %d6,%a0@ <== NOT EXECUTED 4900e: 603e bras 4904e <IMFS_eval_path+0x6a> <== 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 );
49010: 2a0e movel %fp,%d5
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
49012: 4282 clrl %d2
* 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 );
49014: 0685 ffff ffc7 addil #-57,%d5
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
4901a: 2e3c 0004 959c movel #300444,%d7
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
49020: 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 );
49022: 486e fffc pea %fp@(-4) 49026: 2f05 movel %d5,%sp@- 49028: 2f0c movel %a4,%sp@- 4902a: 4875 2800 pea %a5@(00000000,%d2:l) 4902e: 4eb9 0004 9608 jsr 49608 <IMFS_get_token>
pathnamelen -= len;
49034: 2c2e fffc movel %fp@(-4),%d6
* 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 );
49038: 2600 movel %d0,%d3
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
4903a: 4fef 0010 lea %sp@(16),%sp 4903e: 4a92 tstl %a2@
49040: 6612 bnes 49054 <IMFS_eval_path+0x70> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
49042: 4eb9 0004 cad0 jsr 4cad0 <__errno> 49048: 7a02 moveq #2,%d5 4904a: 2040 moveal %d0,%a0 4904c: 2085 movel %d5,%a0@ 4904e: 76ff moveq #-1,%d3 49050: 6000 017c braw 491ce <IMFS_eval_path+0x1ea>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
49054: 4a80 tstl %d0
49056: 671c beqs 49074 <IMFS_eval_path+0x90>
if ( node->type == IMFS_DIRECTORY )
49058: 7001 moveq #1,%d0 4905a: b0ab 0048 cmpl %a3@(72),%d0
4905e: 6614 bnes 49074 <IMFS_eval_path+0x90>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
49060: 4878 0001 pea 1 <ADD> 49064: 2f0a movel %a2,%sp@- 49066: 4eb9 0004 8f2a jsr 48f2a <IMFS_evaluate_permission> 4906c: 508f addql #8,%sp 4906e: 4a80 tstl %d0 49070: 6700 014a beqw 491bc <IMFS_eval_path+0x1d8>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
49074: 2652 moveal %a2@,%a3
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
49076: 99c6 subal %d6,%a4
i += len;
49078: d486 addl %d6,%d2
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
4907a: 7003 moveq #3,%d0 4907c: b083 cmpl %d3,%d0
4907e: 6742 beqs 490c2 <IMFS_eval_path+0xde>
49080: 7204 moveq #4,%d1 49082: b283 cmpl %d3,%d1 49084: 6700 00aa beqw 49130 <IMFS_eval_path+0x14c> 49088: 103c 0002 moveb #2,%d0 4908c: b083 cmpl %d3,%d0 4908e: 6600 00b0 bnew 49140 <IMFS_eval_path+0x15c>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
49092: 2079 0005 d244 moveal 5d244 <rtems_current_user_env>,%a0 49098: b7e8 0018 cmpal %a0@(24),%a3
4909c: 6784 beqs 49022 <IMFS_eval_path+0x3e>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
4909e: 206a 0010 moveal %a2@(16),%a0
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
490a2: b7e8 001c cmpal %a0@(28),%a3
490a6: 6614 bnes 490bc <IMFS_eval_path+0xd8>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
490a8: 4878 0014 pea 14 <OPER2> 490ac: 260e movel %fp,%d3 490ae: 4868 0008 pea %a0@(8) 490b2: 0683 ffff ffe8 addil #-24,%d3 490b8: 6000 00b2 braw 4916c <IMFS_eval_path+0x188>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
490bc: 266b 0008 moveal %a3@(8),%a3 490c0: 6062 bras 49124 <IMFS_eval_path+0x140>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
490c2: 202b 0048 movel %a3@(72),%d0 490c6: 7203 moveq #3,%d1 490c8: b280 cmpl %d0,%d1
490ca: 6610 bnes 490dc <IMFS_eval_path+0xf8>
IMFS_evaluate_hard_link( pathloc, 0 );
490cc: 42a7 clrl %sp@- 490ce: 2f0a movel %a2,%sp@- 490d0: 4eb9 0004 8f9e jsr 48f9e <IMFS_evaluate_hard_link>
node = pathloc->node_access;
490d6: 2652 moveal %a2@,%a3 490d8: 508f addql #8,%sp 490da: 601c bras 490f8 <IMFS_eval_path+0x114>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
490dc: 7204 moveq #4,%d1 490de: b280 cmpl %d0,%d1
490e0: 6616 bnes 490f8 <IMFS_eval_path+0x114>
result = IMFS_evaluate_sym_link( pathloc, 0 );
490e2: 42a7 clrl %sp@- 490e4: 2f0a movel %a2,%sp@- 490e6: 4eb9 0004 91da jsr 491da <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
490ec: 2652 moveal %a2@,%a3
if ( result == -1 )
490ee: 508f addql #8,%sp 490f0: 72ff moveq #-1,%d1 490f2: b280 cmpl %d0,%d1 490f4: 6700 00d6 beqw 491cc <IMFS_eval_path+0x1e8>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
490f8: 7001 moveq #1,%d0 490fa: b0ab 0048 cmpl %a3@(72),%d0
490fe: 6710 beqs 49110 <IMFS_eval_path+0x12c>
rtems_set_errno_and_return_minus_one( ENOTDIR );
49100: 4eb9 0004 cad0 jsr 4cad0 <__errno> 49106: 7814 moveq #20,%d4 49108: 2040 moveal %d0,%a0 4910a: 2084 movel %d4,%a0@ 4910c: 6000 ff40 braw 4904e <IMFS_eval_path+0x6a>
/*
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
49110: 206b 0058 moveal %a3@(88),%a0 49114: 4a88 tstl %a0
49116: 6644 bnes 4915c <IMFS_eval_path+0x178>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
49118: 2f05 movel %d5,%sp@- 4911a: 2047 moveal %d7,%a0 4911c: 2f0b movel %a3,%sp@- 4911e: 4e90 jsr %a0@
if ( !node )
49120: 508f addql #8,%sp
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
49122: 2640 moveal %d0,%a3
if ( !node )
49124: 4a8b tstl %a3 49126: 6700 ff1a beqw 49042 <IMFS_eval_path+0x5e>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
4912a: 248b movel %a3,%a2@ 4912c: 6000 fef4 braw 49022 <IMFS_eval_path+0x3e>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
49130: 4eb9 0004 cad0 jsr 4cad0 <__errno> 49136: 765b moveq #91,%d3 49138: 2040 moveal %d0,%a0 4913a: 2083 movel %d3,%a0@ 4913c: 6000 ff10 braw 4904e <IMFS_eval_path+0x6a>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
49140: 4a83 tstl %d3
49142: 6708 beqs 4914c <IMFS_eval_path+0x168>
49144: 7004 moveq #4,%d0 49146: b083 cmpl %d3,%d0 49148: 6600 fed8 bnew 49022 <IMFS_eval_path+0x3e>
* 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 ) {
4914c: 7201 moveq #1,%d1 4914e: b2ab 0048 cmpl %a3@(72),%d1
49152: 664e bnes 491a2 <IMFS_eval_path+0x1be>
if ( node->info.directory.mt_fs != NULL ) {
49154: 206b 0058 moveal %a3@(88),%a0 49158: 4a88 tstl %a0
4915a: 6746 beqs 491a2 <IMFS_eval_path+0x1be>
newloc = node->info.directory.mt_fs->mt_fs_root;
4915c: 4878 0014 pea 14 <OPER2> 49160: 260e movel %fp,%d3 49162: 0683 ffff ffe8 addil #-24,%d3 49168: 4868 001c pea %a0@(28) 4916c: 2f03 movel %d3,%sp@- 4916e: 47f9 0004 d37c lea 4d37c <memcpy>,%a3 49174: 4e93 jsr %a3@
*pathloc = newloc;
49176: 4878 0014 pea 14 <OPER2> 4917a: 2f03 movel %d3,%sp@- 4917c: 2f0a movel %a2,%sp@- 4917e: 4e93 jsr %a3@
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
49180: 226a 000c moveal %a2@(12),%a1 49184: 2f0a movel %a2,%sp@- 49186: 206e fffc moveal %fp@(-4),%a0 4918a: 9488 subl %a0,%d2 4918c: 2f04 movel %d4,%sp@- 4918e: 4874 8800 pea %a4@(00000000,%a0:l) 49192: 4875 2800 pea %a5@(00000000,%d2:l) 49196: 2051 moveal %a1@,%a0 49198: 4e90 jsr %a0@ 4919a: 4fef 0028 lea %sp@(40),%sp 4919e: 2600 movel %d0,%d3 491a0: 602c bras 491ce <IMFS_eval_path+0x1ea>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
491a2: 2f0a movel %a2,%sp@- 491a4: 4eb9 0004 8ebc jsr 48ebc <IMFS_Set_handlers> 491aa: 2600 movel %d0,%d3
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
491ac: 2e84 movel %d4,%sp@ 491ae: 2f0a movel %a2,%sp@- 491b0: 4eb9 0004 8f2a jsr 48f2a <IMFS_evaluate_permission> 491b6: 508f addql #8,%sp 491b8: 4a80 tstl %d0
491ba: 6612 bnes 491ce <IMFS_eval_path+0x1ea>
rtems_set_errno_and_return_minus_one( EACCES );
491bc: 4eb9 0004 cad0 jsr 4cad0 <__errno> 491c2: 740d moveq #13,%d2 491c4: 2040 moveal %d0,%a0 491c6: 2082 movel %d2,%a0@ 491c8: 6000 fe84 braw 4904e <IMFS_eval_path+0x6a>
491cc: 2600 movel %d0,%d3 <== NOT EXECUTED
return result;
}
491ce: 2003 movel %d3,%d0 491d0: 4cee 3cfc ff9c moveml %fp@(-100),%d2-%d7/%a2-%a5
491d6: 4e5e unlk %fp <== NOT EXECUTED
000492ee <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 */
)
{
492ee: 4e56 ff9c linkw %fp,#-100 492f2: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 492f6: 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 );
492fa: 2c0e movel %fp,%d6
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
492fc: 4282 clrl %d2
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
492fe: 0686 ffff ffc7 addil #-57,%d6
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
49304: 2a3c 0004 9256 movel #299606,%d5
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
4930a: 286e 0008 moveal %fp@(8),%a4
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
4930e: 2652 moveal %a2@,%a3
/*
* Get the path length.
*/
pathlen = strlen( path );
49310: 2f0c movel %a4,%sp@-
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
49312: 2a6e 0010 moveal %fp@(16),%a5
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
49316: 4eb9 0004 df28 jsr 4df28 <strlen> 4931c: 588f addql #4,%sp 4931e: 2800 movel %d0,%d4
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
49320: 486e fffc pea %fp@(-4) 49324: 2f06 movel %d6,%sp@- 49326: 2f04 movel %d4,%sp@- 49328: 4874 2800 pea %a4@(00000000,%d2:l) 4932c: 4eb9 0004 9608 jsr 49608 <IMFS_get_token>
pathlen -= len;
49332: 2e2e fffc movel %fp@(-4),%d7
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
49336: 2600 movel %d0,%d3
pathlen -= len;
49338: 9887 subl %d7,%d4
i += len;
if ( !pathloc->node_access )
4933a: 4fef 0010 lea %sp@(16),%sp 4933e: 4a92 tstl %a2@ 49340: 6700 0154 beqw 49496 <IMFS_evaluate_for_make+0x1a8>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
49344: 4a80 tstl %d0
49346: 671c beqs 49364 <IMFS_evaluate_for_make+0x76>
if ( node->type == IMFS_DIRECTORY )
49348: 7001 moveq #1,%d0 4934a: b0ab 0048 cmpl %a3@(72),%d0
4934e: 6614 bnes 49364 <IMFS_evaluate_for_make+0x76>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
49350: 4878 0001 pea 1 <ADD> 49354: 2f0a movel %a2,%sp@- 49356: 4eb9 0004 8f2a jsr 48f2a <IMFS_evaluate_permission> 4935c: 508f addql #8,%sp 4935e: 4a80 tstl %d0 49360: 6700 017c beqw 494de <IMFS_evaluate_for_make+0x1f0>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
49364: 2652 moveal %a2@,%a3
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
49366: d487 addl %d7,%d2
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
49368: 7002 moveq #2,%d0 4936a: b083 cmpl %d3,%d0
4936c: 671a beqs 49388 <IMFS_evaluate_for_make+0x9a> 4936e: 6508 bcss 49378 <IMFS_evaluate_for_make+0x8a>
49370: 4a83 tstl %d3 49372: 6700 00e4 beqw 49458 <IMFS_evaluate_for_make+0x16a> 49376: 60a8 bras 49320 <IMFS_evaluate_for_make+0x32> 49378: 7203 moveq #3,%d1 4937a: b283 cmpl %d3,%d1
4937c: 6740 beqs 493be <IMFS_evaluate_for_make+0xd0>
4937e: 7004 moveq #4,%d0 49380: b083 cmpl %d3,%d0
49382: 669c bnes 49320 <IMFS_evaluate_for_make+0x32> <== NEVER TAKEN
49384: 6000 00e2 braw 49468 <IMFS_evaluate_for_make+0x17a>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
49388: 2079 0005 d244 moveal 5d244 <rtems_current_user_env>,%a0 4938e: b7e8 0018 cmpal %a0@(24),%a3
49392: 678c beqs 49320 <IMFS_evaluate_for_make+0x32> <== NEVER TAKEN
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
49394: 206a 0010 moveal %a2@(16),%a0 49398: b7e8 001c cmpal %a0@(28),%a3
4939c: 6612 bnes 493b0 <IMFS_evaluate_for_make+0xc2>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
4939e: 4878 0014 pea 14 <OPER2> 493a2: 260e movel %fp,%d3 493a4: 4868 0008 pea %a0@(8) 493a8: 0683 ffff ffe8 addil #-24,%d3 493ae: 605c bras 4940c <IMFS_evaluate_for_make+0x11e>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
493b0: 266b 0008 moveal %a3@(8),%a3 493b4: 4a8b tstl %a3 493b6: 6600 009a bnew 49452 <IMFS_evaluate_for_make+0x164> 493ba: 6000 00da braw 49496 <IMFS_evaluate_for_make+0x1a8>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
493be: 202b 0048 movel %a3@(72),%d0 493c2: 7203 moveq #3,%d1 493c4: b280 cmpl %d0,%d1
493c6: 6706 beqs 493ce <IMFS_evaluate_for_make+0xe0>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
493c8: 7204 moveq #4,%d1 493ca: b280 cmpl %d0,%d1
493cc: 6614 bnes 493e2 <IMFS_evaluate_for_make+0xf4>
result = IMFS_evaluate_link( pathloc, 0 );
493ce: 42a7 clrl %sp@- 493d0: 2045 moveal %d5,%a0 493d2: 2f0a movel %a2,%sp@- 493d4: 4e90 jsr %a0@
if ( result == -1 )
493d6: 508f addql #8,%sp
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
493d8: 2600 movel %d0,%d3
if ( result == -1 )
493da: 70ff moveq #-1,%d0 493dc: b083 cmpl %d3,%d0 493de: 6700 010c beqw 494ec <IMFS_evaluate_for_make+0x1fe>
return -1;
}
node = pathloc->node_access;
493e2: 2052 moveal %a2@,%a0
if ( !node )
493e4: 4a88 tstl %a0 493e6: 6700 00d6 beqw 494be <IMFS_evaluate_for_make+0x1d0>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
493ea: 7001 moveq #1,%d0 493ec: b0a8 0048 cmpl %a0@(72),%d0 493f0: 6600 00cc bnew 494be <IMFS_evaluate_for_make+0x1d0>
/*
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
493f4: 2268 0058 moveal %a0@(88),%a1 493f8: 4a89 tstl %a1
493fa: 6744 beqs 49440 <IMFS_evaluate_for_make+0x152>
newloc = node->info.directory.mt_fs->mt_fs_root;
493fc: 4878 0014 pea 14 <OPER2> 49400: 260e movel %fp,%d3 49402: 0683 ffff ffe8 addil #-24,%d3 49408: 4869 001c pea %a1@(28) 4940c: 2f03 movel %d3,%sp@- 4940e: 47f9 0004 d37c lea 4d37c <memcpy>,%a3 49414: 4e93 jsr %a3@
*pathloc = newloc;
49416: 4878 0014 pea 14 <OPER2> 4941a: 2f03 movel %d3,%sp@- 4941c: 2f0a movel %a2,%sp@- 4941e: 4e93 jsr %a3@
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
49420: 206a 000c moveal %a2@(12),%a0 49424: 94ae fffc subl %fp@(-4),%d2 49428: 2f0d movel %a5,%sp@- 4942a: 2f0a movel %a2,%sp@- 4942c: 4874 2800 pea %a4@(00000000,%d2:l) 49430: 2068 0004 moveal %a0@(4),%a0 49434: 4e90 jsr %a0@ 49436: 4fef 0024 lea %sp@(36),%sp 4943a: 2600 movel %d0,%d3 4943c: 6000 00ae braw 494ec <IMFS_evaluate_for_make+0x1fe>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
49440: 2f06 movel %d6,%sp@- 49442: 2f08 movel %a0,%sp@- 49444: 4eb9 0004 959c jsr 4959c <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
4944a: 508f addql #8,%sp
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
4944c: 2640 moveal %d0,%a3
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
4944e: 4a80 tstl %d0
49450: 6724 beqs 49476 <IMFS_evaluate_for_make+0x188>
done = true;
else
pathloc->node_access = node;
49452: 248b movel %a3,%a2@ 49454: 6000 feca braw 49320 <IMFS_evaluate_for_make+0x32>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
49458: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4945e: 7c11 moveq #17,%d6 49460: 2040 moveal %d0,%a0 49462: 2086 movel %d6,%a0@ 49464: 6000 0084 braw 494ea <IMFS_evaluate_for_make+0x1fc>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
49468: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4946e: 7a5b moveq #91,%d5 49470: 2040 moveal %d0,%a0 49472: 2085 movel %d5,%a0@ 49474: 6074 bras 494ea <IMFS_evaluate_for_make+0x1fc>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
49476: 2002 movel %d2,%d0 49478: 90ae fffc subl %fp@(-4),%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 ] ) )
4947c: 47f9 0004 3728 lea 43728 <rtems_filesystem_is_separator>,%a3
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
49482: d08c addl %a4,%d0
* pathloc is returned with a pointer to the parent of the new node.
* name is returned with a pointer to the first character in the
* new node name. The parent node is verified to be a directory.
*/
int IMFS_evaluate_for_make(
49484: d9c2 addal %d2,%a4
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
49486: 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++) {
49488: 601a bras 494a4 <IMFS_evaluate_for_make+0x1b6>
if ( !IMFS_is_separator( path[ i ] ) )
4948a: 49c0 extbl %d0 4948c: 2f00 movel %d0,%sp@- 4948e: 4e93 jsr %a3@ 49490: 588f addql #4,%sp 49492: 4a80 tstl %d0
49494: 660e bnes 494a4 <IMFS_evaluate_for_make+0x1b6>
rtems_set_errno_and_return_minus_one( ENOENT );
49496: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4949c: 7802 moveq #2,%d4 4949e: 2040 moveal %d0,%a0 494a0: 2084 movel %d4,%a0@ 494a2: 6046 bras 494ea <IMFS_evaluate_for_make+0x1fc>
/*
* 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++) {
494a4: 101c moveb %a4@+,%d0
494a6: 66e2 bnes 4948a <IMFS_evaluate_for_make+0x19c>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
494a8: 2f0a movel %a2,%sp@- 494aa: 4eb9 0004 8ebc jsr 48ebc <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
494b0: 2052 moveal %a2@,%a0
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
494b2: 2600 movel %d0,%d3
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
494b4: 588f addql #4,%sp 494b6: 7001 moveq #1,%d0 494b8: b0a8 0048 cmpl %a0@(72),%d0
494bc: 670e beqs 494cc <IMFS_evaluate_for_make+0x1de> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
494be: 4eb9 0004 cad0 jsr 4cad0 <__errno> 494c4: 7614 moveq #20,%d3 494c6: 2040 moveal %d0,%a0 494c8: 2083 movel %d3,%a0@ 494ca: 601e bras 494ea <IMFS_evaluate_for_make+0x1fc>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
494cc: 4878 0003 pea 3 <DIVIDE> 494d0: 2f0a movel %a2,%sp@- 494d2: 4eb9 0004 8f2a jsr 48f2a <IMFS_evaluate_permission> 494d8: 508f addql #8,%sp 494da: 4a80 tstl %d0
494dc: 660e bnes 494ec <IMFS_evaluate_for_make+0x1fe>
rtems_set_errno_and_return_minus_one( EACCES );
494de: 4eb9 0004 cad0 jsr 4cad0 <__errno> 494e4: 740d moveq #13,%d2 494e6: 2040 moveal %d0,%a0 494e8: 2082 movel %d2,%a0@ 494ea: 76ff moveq #-1,%d3
return result;
}
494ec: 2003 movel %d3,%d0 494ee: 4cee 3cfc ff9c moveml %fp@(-100),%d2-%d7/%a2-%a5
494f4: 4e5e unlk %fp <== NOT EXECUTED
00048f2a <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 ) )
48f2a: 70f8 moveq #-8,%d0
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
48f2c: 4e56 fff4 linkw %fp,#-12 48f30: 48d7 040c moveml %d2-%d3/%a2,%sp@ 48f34: 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 ) )
48f38: c082 andl %d2,%d0
48f3a: 6710 beqs 48f4c <IMFS_evaluate_permission+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
48f3c: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 48f42: 2040 moveal %d0,%a0 <== NOT EXECUTED 48f44: 7001 moveq #1,%d0 <== NOT EXECUTED 48f46: 2080 movel %d0,%a0@ <== NOT EXECUTED 48f48: 70ff moveq #-1,%d0 <== NOT EXECUTED 48f4a: 6048 bras 48f94 <IMFS_evaluate_permission+0x6a> <== NOT EXECUTED
jnode = node->node_access;
48f4c: 206e 0008 moveal %fp@(8),%a0 48f50: 2450 moveal %a0@,%a2
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
48f52: 4eb9 0004 9aa0 jsr 49aa0 <geteuid> 48f58: 3600 movew %d0,%d3
st_gid = getegid();
48f5a: 4eb9 0004 9a8c jsr 49a8c <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
48f60: 4281 clrl %d1 48f62: 0283 0000 ffff andil #65535,%d3 48f68: 322a 0038 movew %a2@(56),%d1 48f6c: b283 cmpl %d3,%d1
48f6e: 6604 bnes 48f74 <IMFS_evaluate_permission+0x4a>
flags_to_test <<= 6;
48f70: ed8a lsll #6,%d2 48f72: 6012 bras 48f86 <IMFS_evaluate_permission+0x5c>
else if ( st_gid == jnode->st_gid )
48f74: 4281 clrl %d1 48f76: 0280 0000 ffff andil #65535,%d0 48f7c: 322a 003a movew %a2@(58),%d1 48f80: b280 cmpl %d0,%d1
48f82: 6602 bnes 48f86 <IMFS_evaluate_permission+0x5c> <== NEVER TAKEN
flags_to_test <<= 3;
48f84: 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 )
48f86: 2002 movel %d2,%d0 48f88: c0aa 002e andl %a2@(46),%d0
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
48f8c: b480 cmpl %d0,%d2 48f8e: 57c0 seq %d0 48f90: 49c0 extbl %d0 48f92: 4480 negl %d0
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
48f94: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
48f9a: 4e5e unlk %fp <== NOT EXECUTED
0004c240 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4c240: 4e56 fff8 linkw %fp,#-8
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
4c244: 206e 0008 moveal %fp@(8),%a0
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4c248: 2f0a movel %a2,%sp@-
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
4c24a: 2450 moveal %a0@,%a2
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4c24c: 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 ) )
4c24e: 4282 clrl %d2
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
4c250: 4eb9 0004 9aa0 jsr 49aa0 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4c256: 4281 clrl %d1 4c258: 3400 movew %d0,%d2 4c25a: 322a 0038 movew %a2@(56),%d1 4c25e: b282 cmpl %d2,%d1
4c260: 6714 beqs 4c276 <IMFS_fchmod+0x36>
4c262: 4a40 tstw %d0
4c264: 6710 beqs 4c276 <IMFS_fchmod+0x36> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
4c266: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4c26c: 2040 moveal %d0,%a0 4c26e: 7001 moveq #1,%d0 4c270: 2080 movel %d0,%a0@ 4c272: 70ff moveq #-1,%d0 4c274: 6030 bras 4c2a6 <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);
4c276: 202a 002e movel %a2@(46),%d0
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4c27a: 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);
4c27e: 0280 ffff f000 andil #-4096,%d0
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4c284: 0281 0000 0fff andil #4095,%d1 4c28a: 8280 orl %d0,%d1 4c28c: 2541 002e movel %d1,%a2@(46)
IMFS_update_ctime( jnode );
4c290: 42a7 clrl %sp@- 4c292: 486e fff8 pea %fp@(-8) 4c296: 4eb9 0004 2a74 jsr 42a74 <gettimeofday> 4c29c: 256e fff8 0044 movel %fp@(-8),%a2@(68)
return 0;
4c2a2: 508f addql #8,%sp 4c2a4: 4280 clrl %d0
}
4c2a6: 242e fff0 movel %fp@(-16),%d2 4c2aa: 246e fff4 moveal %fp@(-12),%a2 4c2ae: 4e5e unlk %fp
...
000430cc <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
430cc: 4e56 0000 linkw %fp,#0 430d0: 206e 0008 moveal %fp@(8),%a0 430d4: 2f03 movel %d3,%sp@- 430d6: 2f02 movel %d2,%sp@-
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
430d8: 2f08 movel %a0,%sp@- 430da: 2f2e 0014 movel %fp@(20),%sp@- 430de: 2f2e 0010 movel %fp@(16),%sp@- 430e2: 2f2e 000c movel %fp@(12),%sp@- 430e6: 2068 0018 moveal %a0@(24),%a0 430ea: 2f28 004c movel %a0@(76),%sp@- 430ee: 4eb9 0004 bcaa jsr 4bcaa <pipe_lseek>
IMFS_FIFO_RETURN(err);
430f4: 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);
430f8: 2600 movel %d0,%d3 430fa: 2400 movel %d0,%d2 430fc: 5bc1 smi %d1 430fe: 49c1 extbl %d1
IMFS_FIFO_RETURN(err);
43100: 4a81 tstl %d1
43102: 6a10 bpls 43114 <IMFS_fifo_lseek+0x48> <== NEVER TAKEN
43104: 4eb9 0004 ea4c jsr 4ea4c <__errno> 4310a: 4483 negl %d3 4310c: 2040 moveal %d0,%a0 4310e: 72ff moveq #-1,%d1 43110: 74ff moveq #-1,%d2 43112: 2083 movel %d3,%a0@
}
43114: 2001 movel %d1,%d0 43116: 2202 movel %d2,%d1 43118: 242e fff8 movel %fp@(-8),%d2 4311c: 262e fffc movel %fp@(-4),%d3
43120: 4e5e unlk %fp <== NOT EXECUTED
00043190 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
43190: 4e56 fff8 linkw %fp,#-8 43194: 206e 0008 moveal %fp@(8),%a0 43198: 2f0a movel %a2,%sp@-
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
4319a: 2468 0018 moveal %a0@(24),%a2
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4319e: 2f02 movel %d2,%sp@-
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
431a0: 2f08 movel %a0,%sp@- 431a2: 2f2e 0010 movel %fp@(16),%sp@- 431a6: 2f2e 000c movel %fp@(12),%sp@- 431aa: 2f2a 004c movel %a2@(76),%sp@- 431ae: 4eb9 0004 bab8 jsr 4bab8 <pipe_write>
if (err > 0) {
431b4: 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);
431b8: 2400 movel %d0,%d2
if (err > 0) {
431ba: 6f1e bles 431da <IMFS_fifo_write+0x4a>
IMFS_mtime_ctime_update(jnode);
431bc: 42a7 clrl %sp@- 431be: 486e fff8 pea %fp@(-8) 431c2: 4eb9 0004 42cc jsr 442cc <gettimeofday> 431c8: 202e fff8 movel %fp@(-8),%d0 431cc: 508f addql #8,%sp 431ce: 2540 0040 movel %d0,%a2@(64) 431d2: 2540 0044 movel %d0,%a2@(68) 431d6: 2002 movel %d2,%d0 431d8: 6016 bras 431f0 <IMFS_fifo_write+0x60>
}
IMFS_FIFO_RETURN(err);
431da: 4a80 tstl %d0
431dc: 6710 beqs 431ee <IMFS_fifo_write+0x5e> <== NEVER TAKEN
431de: 4eb9 0004 ea4c jsr 4ea4c <__errno> 431e4: 4482 negl %d2 431e6: 2040 moveal %d0,%a0 431e8: 70ff moveq #-1,%d0 431ea: 2082 movel %d2,%a0@ 431ec: 6002 bras 431f0 <IMFS_fifo_write+0x60>
431ee: 4280 clrl %d0 <== NOT EXECUTED
}
431f0: 242e fff0 movel %fp@(-16),%d2 431f4: 246e fff4 moveal %fp@(-12),%a2
431f8: 4e5e unlk %fp <== NOT EXECUTED
0004959c <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
4959c: 4e56 fff0 linkw %fp,#-16 495a0: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
495a4: 4879 0005 c370 pea 5c370 <dotname> 495aa: 49f9 0004 d9d0 lea 4d9d0 <strcmp>,%a4
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
495b0: 242e 000c movel %fp@(12),%d2
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
495b4: 2f02 movel %d2,%sp@-
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
495b6: 246e 0008 moveal %fp@(8),%a2
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
495ba: 4e94 jsr %a4@ 495bc: 508f addql #8,%sp 495be: 4a80 tstl %d0
495c0: 673a beqs 495fc <IMFS_find_match_in_dir+0x60> <== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
495c2: 4879 0005 c372 pea 5c372 <dotdotname> 495c8: 2f02 movel %d2,%sp@- 495ca: 4e94 jsr %a4@ 495cc: 508f addql #8,%sp 495ce: 4a80 tstl %d0
495d0: 6606 bnes 495d8 <IMFS_find_match_in_dir+0x3c> <== ALWAYS TAKEN
return directory->Parent;
495d2: 246a 0008 moveal %a2@(8),%a2 <== NOT EXECUTED 495d6: 6024 bras 495fc <IMFS_find_match_in_dir+0x60> <== NOT EXECUTED
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
495d8: 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));
495dc: 45ea 0050 lea %a2@(80),%a2
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
495e0: 6010 bras 495f2 <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 ) )
495e2: 486b 000c pea %a3@(12) 495e6: 2f02 movel %d2,%sp@- 495e8: 4e94 jsr %a4@ 495ea: 508f addql #8,%sp 495ec: 4a80 tstl %d0
495ee: 670a beqs 495fa <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 ) {
495f0: 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 );
495f2: b5cb cmpal %a3,%a2
495f4: 66ec bnes 495e2 <IMFS_find_match_in_dir+0x46>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
495f6: 95ca subal %a2,%a2 495f8: 6002 bras 495fc <IMFS_find_match_in_dir+0x60>
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
495fa: 244b moveal %a3,%a2
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
495fc: 200a movel %a2,%d0 495fe: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
49604: 4e5e unlk %fp <== NOT EXECUTED
000494f8 <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
)
{
494f8: 4e56 ffd8 linkw %fp,#-40 494fc: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 49500: 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;
49504: 240e movel %fp,%d2 49506: 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 );
4950c: 49f9 0004 8ebc lea 48ebc <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;
49512: 246b 001c moveal %a3@(28),%a2
loc = temp_mt_entry->mt_fs_root;
49516: 4878 0014 pea 14 <OPER2> 4951a: 486b 001c pea %a3@(28) 4951e: 2f02 movel %d2,%sp@- 49520: 4eb9 0004 d37c jsr 4d37c <memcpy>
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
49526: 4fef 000c lea %sp@(12),%sp 4952a: 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 );
4952e: 47f9 0004 2370 lea 42370 <IMFS_unlink>,%a3
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
49534: 262a 0008 movel %a2@(8),%d3
loc.node_access = (void *)jnode;
49538: 2d4a ffec movel %a2,%fp@(-20)
IMFS_Set_handlers( &loc );
4953c: 2f02 movel %d2,%sp@- 4953e: 4e94 jsr %a4@
if ( jnode->type != IMFS_DIRECTORY ) {
49540: 588f addql #4,%sp 49542: 7001 moveq #1,%d0 49544: b0aa 0048 cmpl %a2@(72),%d0
49548: 660e bnes 49558 <IMFS_fsunmount+0x60>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4954a: 200a movel %a2,%d0 4954c: 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 ) ) {
49552: b0aa 004c cmpl %a2@(76),%d0
49556: 660e bnes 49566 <IMFS_fsunmount+0x6e>
result = IMFS_unlink( NULL, &loc );
49558: 2f02 movel %d2,%sp@- 4955a: 42a7 clrl %sp@- 4955c: 4e93 jsr %a3@
if (result != 0)
4955e: 508f addql #8,%sp 49560: 4a80 tstl %d0
49562: 6626 bnes 4958a <IMFS_fsunmount+0x92> <== NEVER TAKEN
return -1;
jnode = next;
49564: 2443 moveal %d3,%a2
}
if ( jnode != NULL ) {
49566: 4a8a tstl %a2
49568: 6724 beqs 4958e <IMFS_fsunmount+0x96>
if ( jnode->type == IMFS_DIRECTORY ) {
4956a: 7001 moveq #1,%d0 4956c: b0aa 0048 cmpl %a2@(72),%d0
49570: 66c2 bnes 49534 <IMFS_fsunmount+0x3c> <== NEVER TAKEN
49572: 220a movel %a2,%d1 49574: 0681 0000 0050 addil #80,%d1
}
}
} while (jnode != NULL);
return 0;
}
4957a: 202a 004c movel %a2@(76),%d0
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
4957e: b280 cmpl %d0,%d1
49580: 67b2 beqs 49534 <IMFS_fsunmount+0x3c>
jnode = jnode_get_first_child( jnode );
49582: 2440 moveal %d0,%a2
}
}
} while (jnode != NULL);
49584: 4a80 tstl %d0
49586: 66ac bnes 49534 <IMFS_fsunmount+0x3c> <== ALWAYS TAKEN
49588: 6004 bras 4958e <IMFS_fsunmount+0x96> <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
4958a: 70ff moveq #-1,%d0 <== NOT EXECUTED 4958c: 6002 bras 49590 <IMFS_fsunmount+0x98> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
4958e: 4280 clrl %d0
}
49590: 4cee 1c0c ffd8 moveml %fp@(-40),%d2-%d3/%a2-%a4 49596: 4e5e unlk %fp
...
00049608 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
49608: 4e56 ffe4 linkw %fp,#-28 4960c: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@ 49610: 246e 0010 moveal %fp@(16),%a2
register int i = 0;
49614: 4283 clrl %d3
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
49616: 284a moveal %a2,%a4
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
49618: 4bf9 0004 3728 lea 43728 <rtems_filesystem_is_separator>,%a5
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
4961e: 266e 0008 moveal %fp@(8),%a3
const char *path,
int pathlen,
char *token,
int *token_len
)
{
49622: 282e 000c movel %fp@(12),%d4
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
49626: 141b moveb %a3@+,%d2
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
49628: 600c bras 49636 <IMFS_get_token+0x2e>
token[i] = c;
if ( i == IMFS_NAME_MAX )
4962a: 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;
4962c: 18c2 moveb %d2,%a4@+
if ( i == IMFS_NAME_MAX )
4962e: b083 cmpl %d3,%d0
49630: 6772 beqs 496a4 <IMFS_get_token+0x9c>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
49632: 5283 addql #1,%d3 49634: 141b moveb %a3@+,%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) ) {
49636: 1002 moveb %d2,%d0 49638: 49c0 extbl %d0 4963a: 2f00 movel %d0,%sp@- 4963c: 4e95 jsr %a5@ 4963e: 588f addql #4,%sp 49640: 4a80 tstl %d0
49642: 6604 bnes 49648 <IMFS_get_token+0x40>
49644: b883 cmpl %d3,%d4
49646: 6ee2 bgts 4962a <IMFS_get_token+0x22>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
49648: 4a83 tstl %d3
4964a: 660a bnes 49656 <IMFS_get_token+0x4e>
token[i] = c;
4964c: 1482 moveb %d2,%a2@
if ( (token[i] != '\0') && pathlen ) {
4964e: 6714 beqs 49664 <IMFS_get_token+0x5c>
49650: 4a84 tstl %d4
49652: 6614 bnes 49668 <IMFS_get_token+0x60>
49654: 600e bras 49664 <IMFS_get_token+0x5c>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
49656: 4a32 38ff tstb %a2@(ffffffff,%d3:l)
4965a: 6712 beqs 4966e <IMFS_get_token+0x66> <== NEVER TAKEN
token[i] = '\0';
4965c: 4200 clrb %d0 4965e: 1580 3800 moveb %d0,%a2@(00000000,%d3:l) 49662: 600a bras 4966e <IMFS_get_token+0x66>
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
49664: 4282 clrl %d2 49666: 6008 bras 49670 <IMFS_get_token+0x68>
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
49668: 7401 moveq #1,%d2
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
4966a: 7601 moveq #1,%d3 4966c: 6002 bras 49670 <IMFS_get_token+0x68>
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
4966e: 7403 moveq #3,%d2
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
49670: 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 ) {
49674: 7003 moveq #3,%d0
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
49676: 2083 movel %d3,%a0@
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
49678: b082 cmpl %d2,%d0
4967a: 6632 bnes 496ae <IMFS_get_token+0xa6>
if ( strcmp( token, "..") == 0 )
4967c: 4879 0005 c375 pea 5c375 <dotdotname+0x3> 49682: 47f9 0004 d9d0 lea 4d9d0 <strcmp>,%a3 49688: 2f0a movel %a2,%sp@- 4968a: 4e93 jsr %a3@ 4968c: 508f addql #8,%sp 4968e: 4a80 tstl %d0
49690: 6716 beqs 496a8 <IMFS_get_token+0xa0>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
49692: 4879 0005 c376 pea 5c376 <dotdotname+0x4> 49698: 2f0a movel %a2,%sp@- 4969a: 4e93 jsr %a3@ 4969c: 508f addql #8,%sp 4969e: 4a80 tstl %d0
496a0: 670a beqs 496ac <IMFS_get_token+0xa4>
496a2: 600a bras 496ae <IMFS_get_token+0xa6>
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
return IMFS_INVALID_TOKEN;
496a4: 7404 moveq #4,%d2 496a6: 6006 bras 496ae <IMFS_get_token+0xa6>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
496a8: 7402 moveq #2,%d2 496aa: 6002 bras 496ae <IMFS_get_token+0xa6>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
496ac: 7401 moveq #1,%d2
}
return type;
}
496ae: 2002 movel %d2,%d0 496b0: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5 496b6: 4e5e unlk %fp
...
00041fb8 <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,
41fb8: 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) {
41fbc: 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
)
{
41fbe: 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,
41fc2: 2039 0005 cff8 movel 5cff8 <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
)
{
41fc8: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 41fcc: 246e 0008 moveal %fp@(8),%a2 41fd0: 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) {
41fd4: b081 cmpl %d1,%d0
41fd6: 6710 beqs 41fe8 <IMFS_initialize_support+0x30>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
41fd8: 6d08 blts 41fe2 <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) {
41fda: 5388 subql #1,%a0 41fdc: d281 addl %d1,%d1 41fde: 4a88 tstl %a0
41fe0: 66f2 bnes 41fd4 <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);
41fe2: 203c 0000 0080 movel #128,%d0
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
41fe8: 23c0 0005 e074 movel %d0,5e074 <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();
41fee: 4eb9 0004 8e82 jsr 48e82 <IMFS_create_root_node>
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table;
41ff4: 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();
41ffa: 2640 moveal %d0,%a3 41ffc: 2540 001c movel %d0,%a2@(28)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
42000: 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;
42004: 4878 0030 pea 30 <OPER2+0x1c> 42008: 4879 0005 c340 pea 5c340 <IMFS_LIMITS_AND_OPTIONS> 4200e: 486a 0038 pea %a2@(56) 42012: 4eb9 0004 d37c jsr 4d37c <memcpy>
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
42018: 4878 0014 pea 14 <OPER2> 4201c: 4878 0001 pea 1 <ADD> 42020: 4eb9 0004 2654 jsr 42654 <calloc>
if ( !fs_info ) {
42026: 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 ) );
4202a: 2040 moveal %d0,%a0
if ( !fs_info ) {
4202c: 4a80 tstl %d0
4202e: 661a bnes 4204a <IMFS_initialize_support+0x92>
free(temp_mt_entry->mt_fs_root.node_access);
42030: 2f0b movel %a3,%sp@- 42032: 4eb9 0004 29ec jsr 429ec <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
42038: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4203e: 588f addql #4,%sp 42040: 2040 moveal %d0,%a0 42042: 700c moveq #12,%d0 42044: 2080 movel %d0,%a0@ 42046: 70ff moveq #-1,%d0 42048: 6030 bras 4207a <IMFS_initialize_support+0xc2>
} temp_mt_entry->fs_info = fs_info;
4204a: 2540 0034 movel %d0,%a2@(52)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
4204e: 2039 0005 e078 movel 5e078 <imfs_instance.5975>,%d0 42054: 2080 movel %d0,%a0@ 42056: 5280 addql #1,%d0 42058: 23c0 0005 e078 movel %d0,5e078 <imfs_instance.5975>
fs_info->ino_count = 1;
4205e: 7001 moveq #1,%d0
fs_info->memfile_handlers = memfile_handlers;
42060: 216e 0010 0008 movel %fp@(16),%a0@(8)
fs_info->directory_handlers = directory_handlers; fs_info->fifo_handlers = fifo_handlers;
42066: 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;
4206c: 2140 0004 movel %d0,%a0@(4)
fs_info->memfile_handlers = memfile_handlers; fs_info->directory_handlers = directory_handlers;
42070: 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;
42074: 2740 0034 movel %d0,%a3@(52)
return 0;
42078: 4200 clrb %d0
}
4207a: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
42080: 4e5e unlk %fp <== NOT EXECUTED
0004b92c <IMFS_memfile_extend>:
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
4b92c: 4280 clrl %d0
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
4b92e: 4e56 ffdc linkw %fp,#-36 4b932: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
4b936: 2c39 0005 e074 movel 5e074 <imfs_memfile_bytes_per_block>,%d6 4b93c: 2a06 movel %d6,%d5 4b93e: e48d lsrl #2,%d5 4b940: 2805 movel %d5,%d4 4b942: 5284 addql #1,%d4 4b944: 4c05 4800 mulsl %d5,%d4
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
4b948: 242e 000c movel %fp@(12),%d2 4b94c: 262e 0010 movel %fp@(16),%d3 4b950: 246e 0008 moveal %fp@(8),%a2
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
4b954: 5284 addql #1,%d4 4b956: 4c05 4800 mulsl %d5,%d4 4b95a: 5384 subql #1,%d4 4b95c: 4c06 4800 mulsl %d6,%d4 4b960: 2204 movel %d4,%d1 4b962: 2802 movel %d2,%d4 4b964: 2a03 movel %d3,%d5 4b966: 9a81 subl %d1,%d5 4b968: 9980 subxl %d0,%d4
4b96a: 6d0e blts 4b97a <IMFS_memfile_extend+0x4e>
rtems_set_errno_and_return_minus_one( EINVAL );
4b96c: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4b972: 7216 moveq #22,%d1 4b974: 2040 moveal %d0,%a0 4b976: 2081 movel %d1,%a0@ 4b978: 6078 bras 4b9f2 <IMFS_memfile_extend+0xc6>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
4b97a: 282a 004c movel %a2@(76),%d4 4b97e: 2a2a 0050 movel %a2@(80),%d5 4b982: 2002 movel %d2,%d0 4b984: 2203 movel %d3,%d1 4b986: 9285 subl %d5,%d1 4b988: 9184 subxl %d4,%d0
4b98a: 6f78 bles 4ba04 <IMFS_memfile_extend+0xd8>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
4b98c: 47f9 0005 9398 lea 59398 <__divdi3>,%a3 4b992: 2e06 movel %d6,%d7 4b994: 5bc6 smi %d6 4b996: 49c6 extbl %d6 4b998: 2f07 movel %d7,%sp@- 4b99a: 2f06 movel %d6,%sp@- 4b99c: 2f03 movel %d3,%sp@- 4b99e: 2f02 movel %d2,%sp@- 4b9a0: 4e93 jsr %a3@ 4b9a2: 4fef 0010 lea %sp@(16),%sp 4b9a6: 2841 moveal %d1,%a4
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4b9a8: 2f07 movel %d7,%sp@- 4b9aa: 2f06 movel %d6,%sp@- 4b9ac: 2f05 movel %d5,%sp@- 4b9ae: 2f04 movel %d4,%sp@- 4b9b0: 4e93 jsr %a3@ 4b9b2: 4fef 0010 lea %sp@(16),%sp
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
4b9b6: 47f9 0004 b788 lea 4b788 <IMFS_memfile_addblock>,%a3
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4b9bc: 2c01 movel %d1,%d6
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4b9be: 2801 movel %d1,%d4 4b9c0: 6036 bras 4b9f8 <IMFS_memfile_extend+0xcc>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
4b9c2: 2f04 movel %d4,%sp@- 4b9c4: 2f0a movel %a2,%sp@- 4b9c6: 4e93 jsr %a3@ 4b9c8: 508f addql #8,%sp 4b9ca: 4a80 tstl %d0
4b9cc: 6728 beqs 4b9f6 <IMFS_memfile_extend+0xca>
4b9ce: 600c bras 4b9dc <IMFS_memfile_extend+0xb0>
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
4b9d0: 2f04 movel %d4,%sp@-
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
4b9d2: 5384 subql #1,%d4
IMFS_memfile_remove_block( the_jnode, block );
4b9d4: 2f0a movel %a2,%sp@- 4b9d6: 4e93 jsr %a3@
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
4b9d8: 508f addql #8,%sp 4b9da: 6006 bras 4b9e2 <IMFS_memfile_extend+0xb6>
IMFS_memfile_remove_block( the_jnode, block );
4b9dc: 47f9 0004 b904 lea 4b904 <IMFS_memfile_remove_block>,%a3
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
4b9e2: bc84 cmpl %d4,%d6
4b9e4: 63ea blss 4b9d0 <IMFS_memfile_extend+0xa4> <== NEVER TAKEN
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
4b9e6: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4b9ec: 2040 moveal %d0,%a0 4b9ee: 701c moveq #28,%d0 4b9f0: 2080 movel %d0,%a0@ 4b9f2: 70ff moveq #-1,%d0 4b9f4: 6010 bras 4ba06 <IMFS_memfile_extend+0xda>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4b9f6: 5284 addql #1,%d4 4b9f8: b9c4 cmpal %d4,%a4
4b9fa: 64c6 bccs 4b9c2 <IMFS_memfile_extend+0x96>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
4b9fc: 2542 004c movel %d2,%a2@(76) 4ba00: 2543 0050 movel %d3,%a2@(80)
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
return 0;
4ba04: 4280 clrl %d0
/* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; }
4ba06: 4cee 1cfc ffdc moveml %fp@(-36),%d2-%d7/%a2-%a4
4ba0c: 4e5e unlk %fp <== NOT EXECUTED
0004b480 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4b480: 4e56 fff0 linkw %fp,#-16
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
4b484: 2039 0005 e074 movel 5e074 <imfs_memfile_bytes_per_block>,%d0 4b48a: e488 lsrl #2,%d0 4b48c: 2200 movel %d0,%d1 4b48e: 5381 subql #1,%d1
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4b490: 48d7 041c moveml %d2-%d4/%a2,%sp@ 4b494: 246e 0008 moveal %fp@(8),%a2 4b498: 242e 000c movel %fp@(12),%d2 4b49c: 206e 0010 moveal %fp@(16),%a0
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
4b4a0: b282 cmpl %d2,%d1
4b4a2: 6536 bcss 4b4da <IMFS_memfile_get_block_pointer+0x5a>
p = info->indirect;
4b4a4: 226a 0054 moveal %a2@(84),%a1
if ( malloc_it ) {
4b4a8: 4a88 tstl %a0
4b4aa: 6720 beqs 4b4cc <IMFS_memfile_get_block_pointer+0x4c>
if ( !p ) {
4b4ac: 4a89 tstl %a1
4b4ae: 6610 bnes 4b4c0 <IMFS_memfile_get_block_pointer+0x40>
p = memfile_alloc_block();
4b4b0: 4eb9 0004 b45c jsr 4b45c <memfile_alloc_block>
if ( !p )
4b4b6: 4a80 tstl %d0 4b4b8: 6700 00f8 beqw 4b5b2 <IMFS_memfile_get_block_pointer+0x132>
return 0;
info->indirect = p;
4b4bc: 2540 0054 movel %d0,%a2@(84)
}
return &info->indirect[ my_block ];
4b4c0: 206a 0054 moveal %a2@(84),%a0 4b4c4: e58a lsll #2,%d2 4b4c6: d1c2 addal %d2,%a0 4b4c8: 6000 00ea braw 4b5b4 <IMFS_memfile_get_block_pointer+0x134>
}
if ( !p )
4b4cc: 4a89 tstl %a1 4b4ce: 6700 00e2 beqw 4b5b2 <IMFS_memfile_get_block_pointer+0x132>
return 0;
return &info->indirect[ my_block ];
4b4d2: 41f1 2c00 lea %a1@(00000000,%d2:l:4),%a0 4b4d6: 6000 00dc braw 4b5b4 <IMFS_memfile_get_block_pointer+0x134>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
4b4da: 2200 movel %d0,%d1 4b4dc: 5281 addql #1,%d1 4b4de: 4c00 1800 mulsl %d0,%d1 4b4e2: 2241 moveal %d1,%a1 4b4e4: 5389 subql #1,%a1 4b4e6: b3c2 cmpal %d2,%a1
4b4e8: 653e bcss 4b528 <IMFS_memfile_get_block_pointer+0xa8>
my_block -= FIRST_DOUBLY_INDIRECT;
4b4ea: 9480 subl %d0,%d2
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4b4ec: 4c40 2003 remul %d0,%d3,%d2 4b4f0: 4c40 2002 remul %d0,%d2,%d2
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
4b4f4: 202a 0058 movel %a2@(88),%d0
if ( malloc_it ) {
4b4f8: 4a88 tstl %a0
4b4fa: 671c beqs 4b518 <IMFS_memfile_get_block_pointer+0x98>
if ( !p ) {
4b4fc: 4a80 tstl %d0
4b4fe: 6610 bnes 4b510 <IMFS_memfile_get_block_pointer+0x90>
p = memfile_alloc_block();
4b500: 4eb9 0004 b45c jsr 4b45c <memfile_alloc_block>
if ( !p )
4b506: 4a80 tstl %d0 4b508: 6700 00a8 beqw 4b5b2 <IMFS_memfile_get_block_pointer+0x132>
return 0;
info->doubly_indirect = p;
4b50c: 2540 0058 movel %d0,%a2@(88)
}
p1 = (block_p *)p[ doubly ];
4b510: 2040 moveal %d0,%a0 4b512: 45f0 2c00 lea %a0@(00000000,%d2:l:4),%a2 4b516: 6066 bras 4b57e <IMFS_memfile_get_block_pointer+0xfe>
}
return (block_p *)&p1[ singly ];
}
if ( !p )
4b518: 4a80 tstl %d0 4b51a: 6700 0096 beqw 4b5b2 <IMFS_memfile_get_block_pointer+0x132>
return 0;
p = (block_p *)p[ doubly ];
4b51e: 2240 moveal %d0,%a1 4b520: 2071 2c00 moveal %a1@(00000000,%d2:l:4),%a0 4b524: 6000 0082 braw 4b5a8 <IMFS_memfile_get_block_pointer+0x128>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
4b528: 2601 movel %d1,%d3 4b52a: 5283 addql #1,%d3 4b52c: 4c00 3800 mulsl %d0,%d3 4b530: 5383 subql #1,%d3 4b532: b682 cmpl %d2,%d3
4b534: 657c bcss 4b5b2 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
4b536: 9481 subl %d1,%d2
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4b538: 4c40 2003 remul %d0,%d3,%d2 4b53c: 4c40 2002 remul %d0,%d2,%d2
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
4b540: 4c40 2004 remul %d0,%d4,%d2 4b544: 4c40 2002 remul %d0,%d2,%d2
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
4b548: 202a 005c movel %a2@(92),%d0
if ( malloc_it ) {
4b54c: 4a88 tstl %a0
4b54e: 6746 beqs 4b596 <IMFS_memfile_get_block_pointer+0x116>
if ( !p ) {
4b550: 4a80 tstl %d0
4b552: 660e bnes 4b562 <IMFS_memfile_get_block_pointer+0xe2>
p = memfile_alloc_block();
4b554: 4eb9 0004 b45c jsr 4b45c <memfile_alloc_block>
if ( !p )
4b55a: 4a80 tstl %d0
4b55c: 6754 beqs 4b5b2 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->triply_indirect = p;
4b55e: 2540 005c movel %d0,%a2@(92)
}
p1 = (block_p *) p[ triply ];
4b562: 2040 moveal %d0,%a0 4b564: 45f0 2c00 lea %a0@(00000000,%d2:l:4),%a2 4b568: 2012 movel %a2@,%d0
if ( !p1 ) {
4b56a: 660c bnes 4b578 <IMFS_memfile_get_block_pointer+0xf8>
p1 = memfile_alloc_block();
4b56c: 4eb9 0004 b45c jsr 4b45c <memfile_alloc_block>
if ( !p1 )
4b572: 4a80 tstl %d0
4b574: 673c beqs 4b5b2 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
4b576: 2480 movel %d0,%a2@
}
p2 = (block_p *)p1[ doubly ];
4b578: 2240 moveal %d0,%a1 4b57a: 45f1 4c00 lea %a1@(00000000,%d4:l:4),%a2 4b57e: 2012 movel %a2@,%d0
if ( !p2 ) {
4b580: 660c bnes 4b58e <IMFS_memfile_get_block_pointer+0x10e>
p2 = memfile_alloc_block();
4b582: 4eb9 0004 b45c jsr 4b45c <memfile_alloc_block>
if ( !p2 )
4b588: 4a80 tstl %d0
4b58a: 6726 beqs 4b5b2 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
4b58c: 2480 movel %d0,%a2@
}
return (block_p *)&p2[ singly ];
4b58e: 2240 moveal %d0,%a1 4b590: 41f1 3c00 lea %a1@(00000000,%d3:l:4),%a0 4b594: 601e bras 4b5b4 <IMFS_memfile_get_block_pointer+0x134>
}
if ( !p )
4b596: 4a80 tstl %d0
4b598: 6718 beqs 4b5b2 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
4b59a: 2240 moveal %d0,%a1 4b59c: 2071 2c00 moveal %a1@(00000000,%d2:l:4),%a0
if ( !p1 )
4b5a0: 4a88 tstl %a0
4b5a2: 670e beqs 4b5b2 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
4b5a4: 2070 4c00 moveal %a0@(00000000,%d4:l:4),%a0
if ( !p2 )
4b5a8: 4a88 tstl %a0
4b5aa: 6706 beqs 4b5b2 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
4b5ac: 41f0 3c00 lea %a0@(00000000,%d3:l:4),%a0 4b5b0: 6002 bras 4b5b4 <IMFS_memfile_get_block_pointer+0x134>
if ( !p1 )
return 0;
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
4b5b2: 91c8 subal %a0,%a0 <== NOT EXECUTED
/*
* This means the requested block number is out of range.
*/
return 0;
}
4b5b4: 2008 movel %a0,%d0 4b5b6: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4b5bc: 4e5e unlk %fp <== NOT EXECUTED
0004b5c0 <IMFS_memfile_read>:
* 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) {
4b5c0: 7006 moveq #6,%d0
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4b5c2: 4e56 ffc8 linkw %fp,#-56 4b5c6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4b5ca: 246e 0008 moveal %fp@(8),%a2 4b5ce: 2e2e 0014 movel %fp@(20),%d7 4b5d2: 2c2e 0018 movel %fp@(24),%d6 4b5d6: 242e 000c movel %fp@(12),%d2 4b5da: 262e 0010 movel %fp@(16),%d3
* 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) {
4b5de: b0aa 0048 cmpl %a2@(72),%d0
4b5e2: 6656 bnes 4b63a <IMFS_memfile_read+0x7a>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
4b5e4: 2246 moveal %d6,%a1 4b5e6: 91c8 subal %a0,%a0 4b5e8: 282a 004c movel %a2@(76),%d4 4b5ec: 2a2a 0050 movel %a2@(80),%d5
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
4b5f0: 266a 0054 moveal %a2@(84),%a3
if (my_length > (the_jnode->info.linearfile.size - start))
4b5f4: 2d44 fff0 movel %d4,%fp@(-16) 4b5f8: 2d45 fff4 movel %d5,%fp@(-12) 4b5fc: 9a83 subl %d3,%d5 4b5fe: 9982 subxl %d2,%d4 4b600: 2008 movel %a0,%d0 4b602: 2209 movel %a1,%d1 4b604: 9285 subl %d5,%d1 4b606: 9184 subxl %d4,%d0
4b608: 6f06 bles 4b610 <IMFS_memfile_read+0x50> <== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
4b60a: 2c2e fff4 movel %fp@(-12),%d6 4b60e: 9c83 subl %d3,%d6
memcpy(dest, &file_ptr[start], my_length);
4b610: 2f06 movel %d6,%sp@- 4b612: 4873 3800 pea %a3@(00000000,%d3:l)
IMFS_update_atime( the_jnode );
return my_length;
4b616: 2406 movel %d6,%d2
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);
4b618: 2f07 movel %d7,%sp@- 4b61a: 4eb9 0004 d37c jsr 4d37c <memcpy>
IMFS_update_atime( the_jnode );
4b620: 42a7 clrl %sp@- 4b622: 486e fff8 pea %fp@(-8) 4b626: 4eb9 0004 2a74 jsr 42a74 <gettimeofday> 4b62c: 256e fff8 003c movel %fp@(-8),%a2@(60)
return my_length;
4b632: 4fef 0014 lea %sp@(20),%sp 4b636: 6000 011e braw 4b756 <IMFS_memfile_read+0x196>
/*
* 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;
4b63a: 2043 moveal %d3,%a0 4b63c: 43f0 6800 lea %a0@(00000000,%d6:l),%a1
if ( last_byte > the_jnode->info.file.size )
4b640: 97cb subal %a3,%a3 4b642: 2849 moveal %a1,%a4 4b644: 202a 004c movel %a2@(76),%d0 4b648: 222a 0050 movel %a2@(80),%d1 4b64c: 280b movel %a3,%d4 4b64e: 2a0c movel %a4,%d5 4b650: 9a81 subl %d1,%d5 4b652: 9980 subxl %d0,%d4
4b654: 6f04 bles 4b65a <IMFS_memfile_read+0x9a>
my_length = the_jnode->info.file.size - start;
4b656: 2c01 movel %d1,%d6 4b658: 9c83 subl %d3,%d6
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4b65a: 2879 0005 e074 moveal 5e074 <imfs_memfile_bytes_per_block>,%a4 4b660: 2a0c movel %a4,%d5 4b662: 5bc4 smi %d4 4b664: 49c4 extbl %d4 4b666: 2f05 movel %d5,%sp@- 4b668: 2f04 movel %d4,%sp@- 4b66a: 2f03 movel %d3,%sp@- 4b66c: 2f02 movel %d2,%sp@- 4b66e: 4eb9 0005 974c jsr 5974c <__moddi3> 4b674: 4fef 0010 lea %sp@(16),%sp 4b678: 2641 moveal %d1,%a3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4b67a: 2f05 movel %d5,%sp@- 4b67c: 2f04 movel %d4,%sp@- 4b67e: 2f03 movel %d3,%sp@- 4b680: 2f02 movel %d2,%sp@- 4b682: 4eb9 0005 9398 jsr 59398 <__divdi3> 4b688: 4fef 0010 lea %sp@(16),%sp 4b68c: 2801 movel %d1,%d4
if ( start_offset ) {
4b68e: 4a8b tstl %a3
4b690: 673c beqs 4b6ce <IMFS_memfile_read+0x10e>
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 );
4b692: 42a7 clrl %sp@- 4b694: 2f01 movel %d1,%sp@- 4b696: 2f0a movel %a2,%sp@- 4b698: 4eb9 0004 b480 jsr 4b480 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4b69e: 4fef 000c lea %sp@(12),%sp 4b6a2: 4a80 tstl %d0 4b6a4: 6700 00ae beqw 4b754 <IMFS_memfile_read+0x194>
* 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;
4b6a8: 99cb subal %a3,%a4 4b6aa: 2406 movel %d6,%d2 4b6ac: b9c6 cmpal %d6,%a4
4b6ae: 6402 bccs 4b6b2 <IMFS_memfile_read+0xf2>
4b6b0: 240c movel %a4,%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 );
4b6b2: 2f02 movel %d2,%sp@- 4b6b4: 2040 moveal %d0,%a0 4b6b6: d7d0 addal %a0@,%a3
dest += to_copy;
block++;
4b6b8: 5284 addql #1,%d4
my_length -= to_copy;
4b6ba: 9c82 subl %d2,%d6
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 );
4b6bc: 2f0b movel %a3,%sp@- 4b6be: 2f07 movel %d7,%sp@-
dest += to_copy;
4b6c0: de82 addl %d2,%d7
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 );
4b6c2: 4eb9 0004 d37c jsr 4d37c <memcpy>
dest += to_copy;
block++;
my_length -= to_copy;
4b6c8: 4fef 000c lea %sp@(12),%sp 4b6cc: 6002 bras 4b6d0 <IMFS_memfile_read+0x110>
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
4b6ce: 4282 clrl %d2
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4b6d0: 2679 0005 e074 moveal 5e074 <imfs_memfile_bytes_per_block>,%a3
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b6d6: 4bf9 0004 b480 lea 4b480 <IMFS_memfile_get_block_pointer>,%a5
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b6dc: 49f9 0004 d37c lea 4d37c <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 ) {
4b6e2: 6026 bras 4b70a <IMFS_memfile_read+0x14a>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b6e4: 42a7 clrl %sp@- 4b6e6: 2f04 movel %d4,%sp@- 4b6e8: 2f0a movel %a2,%sp@- 4b6ea: 4e95 jsr %a5@
if ( !block_ptr )
4b6ec: 4fef 000c lea %sp@(12),%sp 4b6f0: 4a80 tstl %d0
4b6f2: 6762 beqs 4b756 <IMFS_memfile_read+0x196> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b6f4: 2040 moveal %d0,%a0
dest += to_copy;
block++;
4b6f6: 5284 addql #1,%d4
my_length -= to_copy;
4b6f8: 9c8b subl %a3,%d6
copied += to_copy;
4b6fa: d48b addl %a3,%d2
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 );
4b6fc: 2f0b movel %a3,%sp@- 4b6fe: 2f10 movel %a0@,%sp@- 4b700: 2f07 movel %d7,%sp@-
dest += to_copy;
4b702: de8b addl %a3,%d7
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 );
4b704: 4e94 jsr %a4@
dest += to_copy;
block++;
my_length -= to_copy;
copied += to_copy;
4b706: 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 ) {
4b70a: bcb9 0005 e074 cmpl 5e074 <imfs_memfile_bytes_per_block>,%d6
4b710: 64d2 bccs 4b6e4 <IMFS_memfile_read+0x124>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
4b712: 4a86 tstl %d6
4b714: 6728 beqs 4b73e <IMFS_memfile_read+0x17e>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b716: 42a7 clrl %sp@- 4b718: 2f04 movel %d4,%sp@- 4b71a: 2f0a movel %a2,%sp@- 4b71c: 4eb9 0004 b480 jsr 4b480 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4b722: 4fef 000c lea %sp@(12),%sp 4b726: 4a80 tstl %d0
4b728: 672c beqs 4b756 <IMFS_memfile_read+0x196> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4b72a: 2040 moveal %d0,%a0
copied += my_length;
4b72c: d486 addl %d6,%d2
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 );
4b72e: 2f06 movel %d6,%sp@- 4b730: 2f10 movel %a0@,%sp@- 4b732: 2f07 movel %d7,%sp@- 4b734: 4eb9 0004 d37c jsr 4d37c <memcpy>
copied += my_length;
4b73a: 4fef 000c lea %sp@(12),%sp
}
IMFS_update_atime( the_jnode );
4b73e: 42a7 clrl %sp@- 4b740: 486e fff8 pea %fp@(-8) 4b744: 4eb9 0004 2a74 jsr 42a74 <gettimeofday> 4b74a: 256e fff8 003c movel %fp@(-8),%a2@(60)
return copied;
4b750: 508f addql #8,%sp 4b752: 6002 bras 4b756 <IMFS_memfile_read+0x196>
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;
4b754: 4282 clrl %d2 <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
4b756: 2002 movel %d2,%d0 4b758: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4b75e: 4e5e unlk %fp <== NOT EXECUTED
0004b824 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4b824: 4e56 ffe4 linkw %fp,#-28 4b828: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%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;
4b82c: 2439 0005 e074 movel 5e074 <imfs_memfile_bytes_per_block>,%d2 4b832: e48a lsrl #2,%d2
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4b834: 246e 0008 moveal %fp@(8),%a2
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4b838: 4aaa 0054 tstl %a2@(84)
4b83c: 670e beqs 4b84c <IMFS_memfile_remove+0x28>
memfile_free_blocks_in_table( &info->indirect, to_free );
4b83e: 2f02 movel %d2,%sp@- 4b840: 486a 0054 pea %a2@(84) 4b844: 4eb9 0004 b7de jsr 4b7de <memfile_free_blocks_in_table> 4b84a: 508f addql #8,%sp
}
if ( info->doubly_indirect ) {
4b84c: 4aaa 0058 tstl %a2@(88)
4b850: 673e beqs 4b890 <IMFS_memfile_remove+0x6c>
4b852: 4283 clrl %d3
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
4b854: 47f9 0004 b7de lea 4b7de <memfile_free_blocks_in_table>,%a3 4b85a: 601a bras 4b876 <IMFS_memfile_remove+0x52>
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] ) {
4b85c: 2003 movel %d3,%d0 4b85e: 206a 0058 moveal %a2@(88),%a0 4b862: e588 lsll #2,%d0 4b864: 4ab0 0800 tstl %a0@(00000000,%d0:l)
4b868: 670a beqs 4b874 <IMFS_memfile_remove+0x50> <== NEVER TAKEN
memfile_free_blocks_in_table(
4b86a: 2f02 movel %d2,%sp@- 4b86c: 4870 0800 pea %a0@(00000000,%d0:l) 4b870: 4e93 jsr %a3@ 4b872: 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++ ) {
4b874: 5283 addql #1,%d3 4b876: 2039 0005 e074 movel 5e074 <imfs_memfile_bytes_per_block>,%d0 4b87c: e488 lsrl #2,%d0 4b87e: b083 cmpl %d3,%d0
4b880: 62da bhis 4b85c <IMFS_memfile_remove+0x38>
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 );
4b882: 2f02 movel %d2,%sp@- 4b884: 486a 0058 pea %a2@(88) 4b888: 4eb9 0004 b7de jsr 4b7de <memfile_free_blocks_in_table> 4b88e: 508f addql #8,%sp
}
if ( info->triply_indirect ) {
4b890: 4aaa 005c tstl %a2@(92)
4b894: 6762 beqs 4b8f8 <IMFS_memfile_remove+0xd4>
4b896: 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);
4b898: 49f9 0004 b7de lea 4b7de <memfile_free_blocks_in_table>,%a4 4b89e: 603e bras 4b8de <IMFS_memfile_remove+0xba>
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
4b8a0: 2a03 movel %d3,%d5
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4b8a2: 206a 005c moveal %a2@(92),%a0
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
4b8a6: e58d lsll #2,%d5
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4b8a8: 2670 5800 moveal %a0@(00000000,%d5:l),%a3
if ( !p ) /* ensure we have a valid pointer */
4b8ac: 4a8b tstl %a3
4b8ae: 673a beqs 4b8ea <IMFS_memfile_remove+0xc6> <== NEVER TAKEN
4b8b0: 4284 clrl %d4 4b8b2: 6010 bras 4b8c4 <IMFS_memfile_remove+0xa0>
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
4b8b4: 4a93 tstl %a3@
4b8b6: 6708 beqs 4b8c0 <IMFS_memfile_remove+0x9c> <== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
4b8b8: 2f02 movel %d2,%sp@- 4b8ba: 2f0b movel %a3,%sp@- 4b8bc: 4e94 jsr %a4@ 4b8be: 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++ ) {
4b8c0: 5284 addql #1,%d4 4b8c2: 588b addql #4,%a3 4b8c4: 2039 0005 e074 movel 5e074 <imfs_memfile_bytes_per_block>,%d0 4b8ca: e488 lsrl #2,%d0 4b8cc: b084 cmpl %d4,%d0
4b8ce: 62e4 bhis 4b8b4 <IMFS_memfile_remove+0x90>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
4b8d0: 2f02 movel %d2,%sp@- 4b8d2: daaa 005c addl %a2@(92),%d5
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4b8d6: 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(
4b8d8: 2f05 movel %d5,%sp@- 4b8da: 4e94 jsr %a4@
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4b8dc: 508f addql #8,%sp 4b8de: 2039 0005 e074 movel 5e074 <imfs_memfile_bytes_per_block>,%d0 4b8e4: e488 lsrl #2,%d0 4b8e6: b083 cmpl %d3,%d0
4b8e8: 62b6 bhis 4b8a0 <IMFS_memfile_remove+0x7c>
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
4b8ea: 2f02 movel %d2,%sp@- 4b8ec: 486a 005c pea %a2@(92) 4b8f0: 4eb9 0004 b7de jsr 4b7de <memfile_free_blocks_in_table> 4b8f6: 508f addql #8,%sp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
4b8f8: 4280 clrl %d0 4b8fa: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4b900: 4e5e unlk %fp <== NOT EXECUTED
0004ba10 <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 ) {
4ba10: 4280 clrl %d0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4ba12: 4e56 ffd0 linkw %fp,#-48 4ba16: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4ba1a: 246e 0008 moveal %fp@(8),%a2 4ba1e: 242e 000c movel %fp@(12),%d2 4ba22: 262e 0010 movel %fp@(16),%d3 4ba26: 2c2e 0018 movel %fp@(24),%d6
/*
* 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;
4ba2a: 2046 moveal %d6,%a0 4ba2c: d1c3 addal %d3,%a0
if ( last_byte > the_jnode->info.file.size ) {
4ba2e: 2208 movel %a0,%d1
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4ba30: 2e2e 0014 movel %fp@(20),%d7
* 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 ) {
4ba34: 282a 004c movel %a2@(76),%d4 4ba38: 2a2a 0050 movel %a2@(80),%d5 4ba3c: 9a81 subl %d1,%d5 4ba3e: 9980 subxl %d0,%d4
4ba40: 6c28 bges 4ba6a <IMFS_memfile_write+0x5a> <== NEVER TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
4ba42: 2f08 movel %a0,%sp@- 4ba44: 2f00 movel %d0,%sp@- 4ba46: 2f0a movel %a2,%sp@- 4ba48: 4eb9 0004 b92c jsr 4b92c <IMFS_memfile_extend>
if ( status )
4ba4e: 4fef 000c lea %sp@(12),%sp 4ba52: 4a80 tstl %d0
4ba54: 6714 beqs 4ba6a <IMFS_memfile_write+0x5a>
rtems_set_errno_and_return_minus_one( ENOSPC );
4ba56: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4ba5c: 741c moveq #28,%d2 4ba5e: 2040 moveal %d0,%a0 4ba60: 387c ffff moveaw #-1,%a4 4ba64: 2082 movel %d2,%a0@ 4ba66: 6000 0102 braw 4bb6a <IMFS_memfile_write+0x15a>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4ba6a: 2879 0005 e074 moveal 5e074 <imfs_memfile_bytes_per_block>,%a4 4ba70: 2a0c movel %a4,%d5 4ba72: 5bc4 smi %d4 4ba74: 49c4 extbl %d4 4ba76: 2f05 movel %d5,%sp@- 4ba78: 2f04 movel %d4,%sp@- 4ba7a: 2f03 movel %d3,%sp@- 4ba7c: 2f02 movel %d2,%sp@- 4ba7e: 4eb9 0005 974c jsr 5974c <__moddi3> 4ba84: 4fef 0010 lea %sp@(16),%sp 4ba88: 2641 moveal %d1,%a3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4ba8a: 2f05 movel %d5,%sp@- 4ba8c: 2f04 movel %d4,%sp@- 4ba8e: 2f03 movel %d3,%sp@- 4ba90: 2f02 movel %d2,%sp@- 4ba92: 4eb9 0005 9398 jsr 59398 <__divdi3> 4ba98: 4fef 0010 lea %sp@(16),%sp 4ba9c: 2401 movel %d1,%d2
if ( start_offset ) {
4ba9e: 4a8b tstl %a3
4baa0: 673a beqs 4badc <IMFS_memfile_write+0xcc>
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 );
4baa2: 42a7 clrl %sp@- 4baa4: 2f01 movel %d1,%sp@- 4baa6: 2f0a movel %a2,%sp@- 4baa8: 4eb9 0004 b480 jsr 4b480 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4baae: 4fef 000c lea %sp@(12),%sp 4bab2: 4a80 tstl %d0 4bab4: 6700 00b2 beqw 4bb68 <IMFS_memfile_write+0x158>
* 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;
4bab8: 99cb subal %a3,%a4 4baba: bc8c cmpl %a4,%d6
4babc: 6402 bccs 4bac0 <IMFS_memfile_write+0xb0>
4babe: 2846 moveal %d6,%a4
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4bac0: 2f0c movel %a4,%sp@- 4bac2: 2040 moveal %d0,%a0
src += to_copy;
block++;
4bac4: 5282 addql #1,%d2
my_length -= to_copy;
4bac6: 9c8c subl %a4,%d6
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4bac8: 2f07 movel %d7,%sp@- 4baca: d7d0 addal %a0@,%a3
src += to_copy;
4bacc: de8c addl %a4,%d7
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4bace: 2f0b movel %a3,%sp@- 4bad0: 4eb9 0004 d37c jsr 4d37c <memcpy>
src += to_copy;
block++;
my_length -= to_copy;
copied += to_copy;
4bad6: 4fef 000c lea %sp@(12),%sp 4bada: 6002 bras 4bade <IMFS_memfile_write+0xce>
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
4badc: 99cc subal %a4,%a4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4bade: 2839 0005 e074 movel 5e074 <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 );
4bae4: 4bf9 0004 b480 lea 4b480 <IMFS_memfile_get_block_pointer>,%a5
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 );
4baea: 47f9 0004 d37c lea 4d37c <memcpy>,%a3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4baf0: 6026 bras 4bb18 <IMFS_memfile_write+0x108>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4baf2: 42a7 clrl %sp@- 4baf4: 2f02 movel %d2,%sp@- 4baf6: 2f0a movel %a2,%sp@- 4baf8: 4e95 jsr %a5@
if ( !block_ptr )
4bafa: 4fef 000c lea %sp@(12),%sp 4bafe: 4a80 tstl %d0
4bb00: 6768 beqs 4bb6a <IMFS_memfile_write+0x15a> <== 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 );
4bb02: 2f04 movel %d4,%sp@- 4bb04: 2040 moveal %d0,%a0
src += to_copy;
block++;
4bb06: 5282 addql #1,%d2
my_length -= to_copy;
4bb08: 9c84 subl %d4,%d6
* 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(
4bb0a: d9c4 addal %d4,%a4
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 );
4bb0c: 2f07 movel %d7,%sp@- 4bb0e: 2f10 movel %a0@,%sp@-
src += to_copy;
4bb10: de84 addl %d4,%d7
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 );
4bb12: 4e93 jsr %a3@
* 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(
4bb14: 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 ) {
4bb18: bcb9 0005 e074 cmpl 5e074 <imfs_memfile_bytes_per_block>,%d6
4bb1e: 64d2 bccs 4baf2 <IMFS_memfile_write+0xe2>
* 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 ) {
4bb20: 4a86 tstl %d6
4bb22: 6728 beqs 4bb4c <IMFS_memfile_write+0x13c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4bb24: 42a7 clrl %sp@- 4bb26: 2f02 movel %d2,%sp@- 4bb28: 2f0a movel %a2,%sp@- 4bb2a: 4eb9 0004 b480 jsr 4b480 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4bb30: 4fef 000c lea %sp@(12),%sp 4bb34: 4a80 tstl %d0
4bb36: 6732 beqs 4bb6a <IMFS_memfile_write+0x15a> <== 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 );
4bb38: 2f06 movel %d6,%sp@- 4bb3a: 2040 moveal %d0,%a0
my_length = 0;
copied += to_copy;
4bb3c: d9c6 addal %d6,%a4
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 );
4bb3e: 2f07 movel %d7,%sp@- 4bb40: 2f10 movel %a0@,%sp@- 4bb42: 4eb9 0004 d37c jsr 4d37c <memcpy>
my_length = 0;
copied += to_copy;
4bb48: 4fef 000c lea %sp@(12),%sp
}
IMFS_mtime_ctime_update( the_jnode );
4bb4c: 42a7 clrl %sp@- 4bb4e: 486e fff8 pea %fp@(-8) 4bb52: 4eb9 0004 2a74 jsr 42a74 <gettimeofday> 4bb58: 202e fff8 movel %fp@(-8),%d0
return copied;
4bb5c: 508f addql #8,%sp
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
4bb5e: 2540 0040 movel %d0,%a2@(64) 4bb62: 2540 0044 movel %d0,%a2@(68)
return copied;
4bb66: 6002 bras 4bb6a <IMFS_memfile_write+0x15a>
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;
4bb68: 99cc subal %a4,%a4 <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4bb6a: 200c movel %a4,%d0 4bb6c: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
4bb72: 4e5e unlk %fp <== NOT EXECUTED
0004213c <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
4213c: 4e56 ffb4 linkw %fp,#-76 42140: 48d7 003c moveml %d2-%d5,%sp@ 42144: 262e 0008 movel %fp@(8),%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 );
42148: 2f03 movel %d3,%sp@-
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
4214a: 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 );
4214e: 4eb9 0004 df28 jsr 4df28 <strlen> 42154: 588f addql #4,%sp 42156: 486e fffc pea %fp@(-4) 4215a: 486e ffc7 pea %fp@(-57)
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
4215e: 2a2e 0010 movel %fp@(16),%d5
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 );
42162: 2f00 movel %d0,%sp@-
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
42164: 282e 0014 movel %fp@(20),%d4
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 );
42168: 2f03 movel %d3,%sp@- 4216a: 4eb9 0004 9608 jsr 49608 <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
42170: 4fef 0010 lea %sp@(16),%sp 42174: 2002 movel %d2,%d0 42176: 0280 0000 f000 andil #61440,%d0 4217c: 0c80 0000 4000 cmpil #16384,%d0
42182: 6730 beqs 421b4 <IMFS_mknod+0x78>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
42184: 0c80 0000 8000 cmpil #32768,%d0
4218a: 672c beqs 421b8 <IMFS_mknod+0x7c>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
4218c: 0c80 0000 6000 cmpil #24576,%d0
42192: 6708 beqs 4219c <IMFS_mknod+0x60>
42194: 0c80 0000 2000 cmpil #8192,%d0
4219a: 660c bnes 421a8 <IMFS_mknod+0x6c>
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
4219c: 2d45 ffe8 movel %d5,%fp@(-24)
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;
421a0: 7002 moveq #2,%d0
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
421a2: 2d44 ffec movel %d4,%fp@(-20) 421a6: 6016 bras 421be <IMFS_mknod+0x82>
} else if (S_ISFIFO(mode))
421a8: 0c80 0000 1000 cmpil #4096,%d0
421ae: 670c beqs 421bc <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;
421b0: 4280 clrl %d0 <== NOT EXECUTED 421b2: 600a bras 421be <IMFS_mknod+0x82> <== NOT EXECUTED
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
421b4: 7001 moveq #1,%d0 421b6: 6006 bras 421be <IMFS_mknod+0x82>
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
421b8: 7005 moveq #5,%d0 421ba: 6002 bras 421be <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;
421bc: 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 );
421be: 486e ffe8 pea %fp@(-24) 421c2: 2f02 movel %d2,%sp@- 421c4: 486e ffc7 pea %fp@(-57) 421c8: 2f00 movel %d0,%sp@- 421ca: 2f2e 0018 movel %fp@(24),%sp@- 421ce: 4eb9 0004 8d6e jsr 48d6e <IMFS_create_node>
if ( !new_node )
421d4: 4fef 0014 lea %sp@(20),%sp 421d8: 4a80 tstl %d0
421da: 6610 bnes 421ec <IMFS_mknod+0xb0>
rtems_set_errno_and_return_minus_one( ENOMEM );
421dc: 4eb9 0004 cad0 jsr 4cad0 <__errno> 421e2: 2040 moveal %d0,%a0 421e4: 700c moveq #12,%d0 421e6: 2080 movel %d0,%a0@ 421e8: 70ff moveq #-1,%d0 421ea: 6002 bras 421ee <IMFS_mknod+0xb2>
return 0;
421ec: 4280 clrl %d0
}
421ee: 4cee 003c ffb4 moveml %fp@(-76),%d2-%d5
421f4: 4e5e unlk %fp <== NOT EXECUTED
000421f8 <IMFS_mount>:
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
421f8: 7001 moveq #1,%d0
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
421fa: 4e56 0000 linkw %fp,#0 421fe: 226e 0008 moveal %fp@(8),%a1
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
42202: 2069 0008 moveal %a1@(8),%a0
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
42206: b0a8 0048 cmpl %a0@(72),%d0
4220a: 6710 beqs 4221c <IMFS_mount+0x24> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
4220c: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 42212: 2040 moveal %d0,%a0 <== NOT EXECUTED 42214: 7014 moveq #20,%d0 <== NOT EXECUTED 42216: 2080 movel %d0,%a0@ <== NOT EXECUTED 42218: 70ff moveq #-1,%d0 <== NOT EXECUTED 4221a: 6006 bras 42222 <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;
4221c: 2149 0058 movel %a1,%a0@(88)
return 0;
42220: 4280 clrl %d0
}
42222: 4e5e unlk %fp
...
00044898 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
44898: 4e56 0000 linkw %fp,#0
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4489c: 2079 0006 2dec moveal 62dec <_impure_ptr>,%a0
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
448a2: 2f0a movel %a2,%sp@- 448a4: 246e 0008 moveal %fp@(8),%a2 448a8: 2f02 movel %d2,%sp@-
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
448aa: 2f28 0008 movel %a0@(8),%sp@-
switch( the_jnode->type ) {
448ae: 7406 moveq #6,%d2
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
448b0: 486a 000c pea %a2@(12) 448b4: 4eb9 0005 0df4 jsr 50df4 <fputs>
switch( the_jnode->type ) {
448ba: 202a 0048 movel %a2@(72),%d0 448be: 2200 movel %d0,%d1 448c0: 508f addql #8,%sp 448c2: 5381 subql #1,%d1 448c4: b481 cmpl %d1,%d2 448c6: 6500 009c bcsw 44964 <IMFS_print_jnode+0xcc> 448ca: 2079 0006 2dec moveal 62dec <_impure_ptr>,%a0 448d0: 303b 1a08 movew %pc@(448da <IMFS_print_jnode+0x42>,%d1:l:2),%d0 448d4: 48c0 extl %d0 448d6: 4efb 0802 jmp %pc@(448da <IMFS_print_jnode+0x42>,%d0:l)
448da: 000e .short 0x000e <== NOT EXECUTED 448dc: 0022 .short 0x0022 <== NOT EXECUTED 448de: 006a .short 0x006a <== NOT EXECUTED 448e0: 006a .short 0x006a <== NOT EXECUTED 448e2: 0050 .short 0x0050 <== NOT EXECUTED 448e4: 0032 .short 0x0032 <== NOT EXECUTED 448e6: 0076 .short 0x0076 <== NOT EXECUTED
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
448e8: 2f28 0008 movel %a0@(8),%sp@- 448ec: 4878 002f pea 2f <OPER2+0x1b> 448f0: 4eb9 0005 0d24 jsr 50d24 <fputc>
break;
448f6: 508f addql #8,%sp 448f8: 6000 0088 braw 44982 <IMFS_print_jnode+0xea>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
448fc: 2f2a 0050 movel %a2@(80),%sp@- 44900: 2f2a 004c movel %a2@(76),%sp@- 44904: 4879 0006 1454 pea 61454 <IntUartPollCallbacks.6374+0x20> 4490a: 600e bras 4491a <IMFS_print_jnode+0x82>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
4490c: 2f2a 0054 movel %a2@(84),%sp@- 44910: 2f2a 0050 movel %a2@(80),%sp@- 44914: 4879 0006 1467 pea 61467 <IntUartPollCallbacks.6374+0x33> 4491a: 2f28 0008 movel %a0@(8),%sp@- 4491e: 4eb9 0005 0ca6 jsr 50ca6 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
44924: 4fef 0010 lea %sp@(16),%sp 44928: 6058 bras 44982 <IMFS_print_jnode+0xea>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
4492a: 2f2a 0050 movel %a2@(80),%sp@- 4492e: 4879 0006 1476 pea 61476 <IntUartPollCallbacks.6374+0x42> 44934: 2f28 0008 movel %a0@(8),%sp@- 44938: 4eb9 0005 0ca6 jsr 50ca6 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
4493e: 4fef 000c lea %sp@(12),%sp 44942: 603e bras 44982 <IMFS_print_jnode+0xea>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
44944: 2f28 0008 movel %a0@(8),%sp@- 44948: 4879 0006 1482 pea 61482 <IntUartPollCallbacks.6374+0x4e> 4494e: 600a bras 4495a <IMFS_print_jnode+0xc2>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
44950: 2f28 0008 movel %a0@(8),%sp@- 44954: 4879 0006 1496 pea 61496 <IntUartPollCallbacks.6374+0x62> 4495a: 4eb9 0005 0df4 jsr 50df4 <fputs>
return;
44960: 508f addql #8,%sp 44962: 6038 bras 4499c <IMFS_print_jnode+0x104>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
44964: 2f00 movel %d0,%sp@- <== NOT EXECUTED 44966: 4879 0006 14a9 pea 614a9 <IntUartPollCallbacks.6374+0x75> <== NOT EXECUTED 4496c: 2079 0006 2dec moveal 62dec <_impure_ptr>,%a0 <== NOT EXECUTED 44972: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED 44976: 4eb9 0005 0ca6 jsr 50ca6 <fprintf> <== NOT EXECUTED
return;
4497c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED 44980: 601a bras 4499c <IMFS_print_jnode+0x104> <== NOT EXECUTED
}
puts("");
}
44982: 242e fff8 movel %fp@(-8),%d2
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44986: 203c 0006 1b5c movel #400220,%d0
}
4498c: 246e fffc moveal %fp@(-4),%a2
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44990: 2d40 0008 movel %d0,%fp@(8)
}
44994: 4e5e unlk %fp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44996: 4ef9 0005 25c2 jmp 525c2 <puts>
}
4499c: 242e fff8 movel %fp@(-8),%d2 449a0: 246e fffc moveal %fp@(-4),%a2
449a4: 4e5e unlk %fp <== NOT EXECUTED
00042270 <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 */
)
{
42270: 4e56 fff8 linkw %fp,#-8
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
42274: 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 */
)
{
42278: 2f0a movel %a2,%sp@-
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
4227a: 2450 moveal %a0@,%a2
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
4227c: 4878 0020 pea 20 <OPER2+0xc> 42280: 2f2e 0014 movel %fp@(20),%sp@- 42284: 486a 000c pea %a2@(12) 42288: 4eb9 0004 df40 jsr 4df40 <strncpy>
if ( the_jnode->Parent != NULL )
4228e: 4fef 000c lea %sp@(12),%sp 42292: 4aaa 0008 tstl %a2@(8)
42296: 670a beqs 422a2 <IMFS_rename+0x32> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
42298: 2f0a movel %a2,%sp@- 4229a: 4eb9 0004 6240 jsr 46240 <_Chain_Extract> 422a0: 588f addql #4,%sp
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
422a2: 206e 0010 moveal %fp@(16),%a0 422a6: 2050 moveal %a0@,%a0
the_jnode->Parent = new_parent;
422a8: 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 );
422ac: 2f0a movel %a2,%sp@- 422ae: 4868 004c pea %a0@(76) 422b2: 4eb9 0004 6208 jsr 46208 <_Chain_Append>
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
422b8: 42a7 clrl %sp@- 422ba: 486e fff8 pea %fp@(-8) 422be: 4eb9 0004 2a74 jsr 42a74 <gettimeofday> 422c4: 256e fff8 0044 movel %fp@(-8),%a2@(68)
return 0;
}
422ca: 4280 clrl %d0 422cc: 246e fff4 moveal %fp@(-12),%a2
422d0: 4e5e unlk %fp <== NOT EXECUTED
00049794 <IMFS_stat>:
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
49794: 7205 moveq #5,%d1
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
49796: 4e56 0000 linkw %fp,#0 4979a: 206e 000c moveal %fp@(12),%a0 4979e: 2f0a movel %a2,%sp@- 497a0: 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;
497a4: 2252 moveal %a2@,%a1
switch ( the_jnode->type ) {
497a6: 2029 0048 movel %a1@(72),%d0 497aa: 5580 subql #2,%d0 497ac: b280 cmpl %d0,%d1
497ae: 653e bcss 497ee <IMFS_stat+0x5a> <== NEVER TAKEN
497b0: 303b 0a08 movew %pc@(497ba <IMFS_stat+0x26>,%d0:l:2),%d0 497b4: 48c0 extl %d0 497b6: 4efb 0802 jmp %pc@(497ba <IMFS_stat+0x26>,%d0:l)
497ba: 000c .short 0x000c <== NOT EXECUTED 497bc: 0034 .short 0x0034 <== NOT EXECUTED 497be: 0026 .short 0x0026 <== NOT EXECUTED 497c0: 001c .short 0x001c <== NOT EXECUTED 497c2: 001c .short 0x001c <== NOT EXECUTED 497c4: 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 );
497c6: 2029 0050 movel %a1@(80),%d0 497ca: 2169 004c 0016 movel %a1@(76),%a0@(22) 497d0: 2140 001a movel %d0,%a0@(26)
break;
497d4: 602a bras 49800 <IMFS_stat+0x6c>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
497d6: 2029 004c movel %a1@(76),%d0 497da: 2229 0050 movel %a1@(80),%d1 497de: 6004 bras 497e4 <IMFS_stat+0x50>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
497e0: 4280 clrl %d0 497e2: 4281 clrl %d1 497e4: 2140 001e movel %d0,%a0@(30) 497e8: 2141 0022 movel %d1,%a0@(34)
break;
497ec: 6012 bras 49800 <IMFS_stat+0x6c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
497ee: 4eb9 0004 cad0 jsr 4cad0 <__errno> 497f4: 2040 moveal %d0,%a0 497f6: 70ff moveq #-1,%d0 497f8: 20bc 0000 0086 movel #134,%a0@ 497fe: 6046 bras 49846 <IMFS_stat+0xb2>
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
49800: 246a 0010 moveal %a2@(16),%a2
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
49804: 246a 0034 moveal %a2@(52),%a2 49808: 2012 movel %a2@,%d0
buf->st_mode = the_jnode->st_mode;
4980a: 2169 002e 000c movel %a1@(46),%a0@(12)
buf->st_nlink = the_jnode->st_nlink;
49810: 3169 0032 0010 movew %a1@(50),%a0@(16)
buf->st_ino = the_jnode->st_ino;
49816: 2169 0034 0008 movel %a1@(52),%a0@(8)
buf->st_uid = the_jnode->st_uid;
4981c: 3169 0038 0012 movew %a1@(56),%a0@(18)
buf->st_gid = the_jnode->st_gid;
49822: 3169 003a 0014 movew %a1@(58),%a0@(20)
buf->st_atime = the_jnode->stat_atime;
49828: 2169 003c 0026 movel %a1@(60),%a0@(38)
buf->st_mtime = the_jnode->stat_mtime;
4982e: 2169 0040 002e movel %a1@(64),%a0@(46)
buf->st_ctime = the_jnode->stat_ctime;
49834: 2169 0044 0036 movel %a1@(68),%a0@(54)
/* * 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 =
4983a: 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;
return 0;
4983e: 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 =
49840: 20bc 0000 fffe movel #65534,%a0@
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
return 0;
}
49846: 246e fffc moveal %fp@(-4),%a2 4984a: 4e5e unlk %fp
...
00042370 <IMFS_unlink>:
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
42370: 7003 moveq #3,%d0
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
42372: 4e56 ffd0 linkw %fp,#-48 42376: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 4237a: 246e 000c moveal %fp@(12),%a2 4237e: 262e 0008 movel %fp@(8),%d3
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
42382: 2652 moveal %a2@,%a3
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
42384: b0ab 0048 cmpl %a3@(72),%d0 42388: 6600 0082 bnew 4240c <IMFS_unlink+0x9c>
if ( !node->info.hard_link.link_node )
4238c: 282b 004c movel %a3@(76),%d4
42390: 660e bnes 423a0 <IMFS_unlink+0x30> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
42392: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 42398: 2040 moveal %d0,%a0 <== NOT EXECUTED 4239a: 7016 moveq #22,%d0 <== NOT EXECUTED 4239c: 2080 movel %d0,%a0@ <== NOT EXECUTED 4239e: 607e bras 4241e <IMFS_unlink+0xae> <== NOT EXECUTED
the_link = *loc;
423a0: 4878 0014 pea 14 <OPER2> 423a4: 240e movel %fp,%d2 423a6: 0682 ffff ffe4 addil #-28,%d2 423ac: 2f0a movel %a2,%sp@- 423ae: 2f02 movel %d2,%sp@- 423b0: 4eb9 0004 d37c jsr 4d37c <memcpy>
the_link.node_access = node->info.hard_link.link_node;
423b6: 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)
423ba: 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 );
423bc: 2f02 movel %d2,%sp@- 423be: 4eb9 0004 8ebc jsr 48ebc <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)
423c4: 206b 004c moveal %a3@(76),%a0 423c8: 4281 clrl %d1 423ca: 4fef 0010 lea %sp@(16),%sp 423ce: 3028 0032 movew %a0@(50),%d0 423d2: 3200 movew %d0,%d1 423d4: b881 cmpl %d1,%d4
423d6: 6616 bnes 423ee <IMFS_unlink+0x7e>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
423d8: 2f02 movel %d2,%sp@- 423da: 206e ffec moveal %fp@(-20),%a0 423de: 2f03 movel %d3,%sp@- 423e0: 2068 0034 moveal %a0@(52),%a0 423e4: 4e90 jsr %a0@
if ( result != 0 )
423e6: 508f addql #8,%sp 423e8: 4a80 tstl %d0
423ea: 6720 beqs 4240c <IMFS_unlink+0x9c>
423ec: 6030 bras 4241e <IMFS_unlink+0xae>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
423ee: 5380 subql #1,%d0 423f0: 3140 0032 movew %d0,%a0@(50)
IMFS_update_ctime( node->info.hard_link.link_node );
423f4: 42a7 clrl %sp@- 423f6: 486e fff8 pea %fp@(-8) 423fa: 4eb9 0004 2a74 jsr 42a74 <gettimeofday> 42400: 206b 004c moveal %a3@(76),%a0 42404: 508f addql #8,%sp 42406: 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 );
4240c: 206a 0008 moveal %a2@(8),%a0 42410: 2f0a movel %a2,%sp@- 42412: 2f03 movel %d3,%sp@- 42414: 2068 0034 moveal %a0@(52),%a0 42418: 4e90 jsr %a0@
return result;
4241a: 508f addql #8,%sp 4241c: 6002 bras 42420 <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;
4241e: 70ff moveq #-1,%d0
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
return result;
}
42420: 4cee 0c1c ffd0 moveml %fp@(-48),%d2-%d4/%a2-%a3 42426: 4e5e unlk %fp
...
0004242c <IMFS_unmount>:
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
4242c: 7001 moveq #1,%d0
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
4242e: 4e56 0000 linkw %fp,#0
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
42432: 206e 0008 moveal %fp@(8),%a0 42436: 2068 0008 moveal %a0@(8),%a0
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
4243a: b0a8 0048 cmpl %a0@(72),%d0
4243e: 670e beqs 4244e <IMFS_unmount+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
42440: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 42446: 7214 moveq #20,%d1 <== NOT EXECUTED 42448: 2040 moveal %d0,%a0 <== NOT EXECUTED 4244a: 2081 movel %d1,%a0@ <== NOT EXECUTED 4244c: 6012 bras 42460 <IMFS_unmount+0x34> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
4244e: 4aa8 0058 tstl %a0@(88)
42452: 6610 bnes 42464 <IMFS_unmount+0x38> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
42454: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 4245a: 2040 moveal %d0,%a0 <== NOT EXECUTED 4245c: 7016 moveq #22,%d0 <== NOT EXECUTED 4245e: 2080 movel %d0,%a0@ <== NOT EXECUTED 42460: 70ff moveq #-1,%d0 <== NOT EXECUTED 42462: 6006 bras 4246a <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;
42464: 42a8 0058 clrl %a0@(88)
return 0;
42468: 4280 clrl %d0
}
4246a: 4e5e unlk %fp
...
00042554 <Stack_check_Dump_threads_usage>:
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
42554: 70ff moveq #-1,%d0 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
42556: 4e56 ffe0 linkw %fp,#-32 <== NOT EXECUTED 4255a: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@ <== NOT EXECUTED 4255e: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
42562: b08a cmpl %a2,%d0 <== NOT EXECUTED 42564: 6616 bnes 4257c <Stack_check_Dump_threads_usage+0x28><== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
42566: 4ab9 0006 12d8 tstl 612d8 <Stack_check_Interrupt_stack+0x4><== NOT EXECUTED 4256c: 6700 00fe beqw 4266c <Stack_check_Dump_threads_usage+0x118><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
42570: 49f9 0006 12d4 lea 612d4 <Stack_check_Interrupt_stack>,%a4 <== NOT EXECUTED
the_thread = 0;
current = 0;
42576: 4284 clrl %d4 <== 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;
42578: 95ca subal %a2,%a2 <== NOT EXECUTED 4257a: 6008 bras 42584 <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 );
4257c: 282a 00f2 movel %a2@(242),%d4 <== NOT EXECUTED
the_thread = 0;
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
42580: 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);
42584: 2614 movel %a4@,%d3 <== 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++)
42586: 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);
42588: 0683 ffff fff0 addil #-16,%d3 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
4258e: 206c 0004 moveal %a4@(4),%a0 <== NOT EXECUTED 42592: 43e8 0010 lea %a0@(16),%a1 <== NOT EXECUTED
* Try to print out how much stack was actually used by the task.
*/
static void *print_context;
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
42596: 41e8 0020 lea %a0@(32),%a0 <== 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++)
4259a: c083 andl %d3,%d0 <== NOT EXECUTED 4259c: 47f1 0810 lea %a1@(00000010,%d0:l),%a3 <== NOT EXECUTED 425a0: 600a bras 425ac <Stack_check_Dump_threads_usage+0x58><== NOT EXECUTED
if (*base != U32_PATTERN)
425a2: 223c a5a5 a5a5 movel #-1515870811,%d1 <== NOT EXECUTED 425a8: b298 cmpl %a0@+,%d1 <== NOT EXECUTED 425aa: 6608 bnes 425b4 <Stack_check_Dump_threads_usage+0x60><== NOT EXECUTED 425ac: 2008 movel %a0,%d0 <== 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++)
425ae: b7c8 cmpal %a0,%a3 <== NOT EXECUTED 425b0: 62f0 bhis 425a2 <Stack_check_Dump_threads_usage+0x4e><== NOT EXECUTED 425b2: 600c bras 425c0 <Stack_check_Dump_threads_usage+0x6c><== 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 )
425b4: 4a80 tstl %d0 <== NOT EXECUTED 425b6: 6708 beqs 425c0 <Stack_check_Dump_threads_usage+0x6c><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
425b8: 2409 movel %a1,%d2 <== NOT EXECUTED 425ba: d483 addl %d3,%d2 <== NOT EXECUTED 425bc: 9480 subl %d0,%d2 <== NOT EXECUTED 425be: 6002 bras 425c2 <Stack_check_Dump_threads_usage+0x6e><== NOT EXECUTED
else
used = 0;
425c0: 4282 clrl %d2 <== NOT EXECUTED 425c2: 2679 0006 0abc moveal 60abc <print_handler>,%a3 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
425c8: 4a8a tstl %a2 <== NOT EXECUTED 425ca: 672c beqs 425f8 <Stack_check_Dump_threads_usage+0xa4><== NOT EXECUTED
#endif
{
(*print_handler)(
425cc: 486e fffb pea %fp@(-5) <== NOT EXECUTED 425d0: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED 425d4: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED 425d8: 4eb9 0004 7d58 jsr 47d58 <rtems_object_get_name> <== NOT EXECUTED 425de: 2f00 movel %d0,%sp@- <== NOT EXECUTED 425e0: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED 425e4: 4879 0005 e440 pea 5e440 <IntUartPollCallbacks.6374+0x20> <== NOT EXECUTED 425ea: 2f39 0006 0ab8 movel 60ab8 <print_context>,%sp@- <== NOT EXECUTED 425f0: 4e93 jsr %a3@ <== NOT EXECUTED 425f2: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED 425f6: 6016 bras 4260e <Stack_check_Dump_threads_usage+0xba><== 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 );
425f8: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED 425fc: 4879 0005 e44d pea 5e44d <IntUartPollCallbacks.6374+0x2d> <== NOT EXECUTED 42602: 2f39 0006 0ab8 movel 60ab8 <print_context>,%sp@- <== NOT EXECUTED 42608: 4e93 jsr %a3@ <== NOT EXECUTED 4260a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
4260e: 206c 0004 moveal %a4@(4),%a0 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
42612: 2f03 movel %d3,%sp@- <== NOT EXECUTED 42614: 2f04 movel %d4,%sp@- <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
42616: 2014 movel %a4@,%d0 <== NOT EXECUTED 42618: 5380 subql #1,%d0 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
4261a: 4870 0800 pea %a0@(00000000,%d0:l) <== NOT EXECUTED 4261e: 2f08 movel %a0,%sp@- <== NOT EXECUTED 42620: 4879 0005 e45b pea 5e45b <IntUartPollCallbacks.6374+0x3b> <== NOT EXECUTED 42626: 2f39 0006 0ab8 movel 60ab8 <print_context>,%sp@- <== NOT EXECUTED 4262c: 2079 0006 0abc moveal 60abc <print_handler>,%a0 <== NOT EXECUTED 42632: 4e90 jsr %a0@ <== NOT EXECUTED 42634: 2679 0006 0abc moveal 60abc <print_handler>,%a3 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
4263a: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED 4263e: 4ab9 0006 0ac0 tstl 60ac0 <Stack_check_Initialized> <== NOT EXECUTED 42644: 6612 bnes 42658 <Stack_check_Dump_threads_usage+0x104><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
42646: 4879 0005 e479 pea 5e479 <IntUartPollCallbacks.6374+0x59> <== NOT EXECUTED 4264c: 2f39 0006 0ab8 movel 60ab8 <print_context>,%sp@- <== NOT EXECUTED 42652: 4e93 jsr %a3@ <== NOT EXECUTED 42654: 508f addql #8,%sp <== NOT EXECUTED 42656: 6014 bras 4266c <Stack_check_Dump_threads_usage+0x118><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
42658: 2f02 movel %d2,%sp@- <== NOT EXECUTED 4265a: 4879 0005 e486 pea 5e486 <IntUartPollCallbacks.6374+0x66> <== NOT EXECUTED 42660: 2f39 0006 0ab8 movel 60ab8 <print_context>,%sp@- <== NOT EXECUTED 42666: 4e93 jsr %a3@ <== NOT EXECUTED 42668: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
}
4266c: 4cee 1c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a4 <== NOT EXECUTED 42672: 4e5e unlk %fp <== NOT EXECUTED
00042676 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
42676: 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 )
4267a: 4ab9 0006 0ac0 tstl 60ac0 <Stack_check_Initialized>
42680: 6668 bnes 426ea <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 ];
42682: 203c feed f00d movel #-17960947,%d0 42688: 23c0 0006 12c4 movel %d0,612c4 <Stack_check_Pattern> 4268e: 203c 0bad 0d06 movel #195890438,%d0 42694: 23c0 0006 12c8 movel %d0,612c8 <Stack_check_Pattern+0x4> 4269a: 203c dead f00d movel #-559026163,%d0 426a0: 23c0 0006 12cc movel %d0,612cc <Stack_check_Pattern+0x8> 426a6: 203c 600d 0d06 movel #1611468038,%d0 426ac: 23c0 0006 12d0 movel %d0,612d0 <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) {
426b2: 2039 0006 18fe movel 618fe <_Per_CPU_Information>,%d0
426b8: 6728 beqs 426e2 <Stack_check_Initialize+0x6c> <== NEVER TAKEN
426ba: 2239 0006 1902 movel 61902 <_Per_CPU_Information+0x4>,%d1
426c0: 6720 beqs 426e2 <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 -
426c2: 9280 subl %d0,%d1
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
426c4: 2f01 movel %d1,%sp@- 426c6: 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;
426ca: 23c0 0006 12d8 movel %d0,612d8 <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);
426d0: 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 -
426d2: 23c1 0006 12d4 movel %d1,612d4 <Stack_check_Interrupt_stack>
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
426d8: 4eb9 0004 faec jsr 4faec <memset> 426de: 4fef 000c lea %sp@(12),%sp
}
#endif
Stack_check_Initialized = 1;
426e2: 7001 moveq #1,%d0 426e4: 23c0 0006 0ac0 movel %d0,60ac0 <Stack_check_Initialized>
}
426ea: 4e5e unlk %fp <== NOT EXECUTED
00042750 <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)
{
42750: 4e56 ffd0 linkw %fp,#-48 <== NOT EXECUTED 42754: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED 42758: 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");
4275c: 45f9 0004 4408 lea 44408 <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);
42762: 286b 00b6 moveal %a3@(182),%a4 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
42766: 4879 0005 e48c pea 5e48c <IntUartPollCallbacks.6374+0x6c> <== 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)
{
4276c: 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");
42770: 4e92 jsr %a2@ <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
42772: 2f0b movel %a3,%sp@- <== NOT EXECUTED 42774: 4879 0005 e49c pea 5e49c <IntUartPollCallbacks.6374+0x7c> <== NOT EXECUTED 4277a: 4e92 jsr %a2@ <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
4277c: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED 42780: 4879 0005 e4b9 pea 5e4b9 <IntUartPollCallbacks.6374+0x99> <== NOT EXECUTED 42786: 4e92 jsr %a2@ <== NOT EXECUTED
printk(
42788: 2f2b 000c movel %a3@(12),%sp@- <== NOT EXECUTED 4278c: 4879 0005 e4cb pea 5e4cb <IntUartPollCallbacks.6374+0xab> <== NOT EXECUTED 42792: 4e92 jsr %a2@ <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
42794: 486e ffe0 pea %fp@(-32) <== NOT EXECUTED 42798: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED 4279c: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED 427a0: 4eb9 0004 7d58 jsr 47d58 <rtems_object_get_name> <== NOT EXECUTED 427a6: 4fef 0024 lea %sp@(36),%sp <== NOT EXECUTED 427aa: 2e80 movel %d0,%sp@ <== NOT EXECUTED 427ac: 4879 0005 e4df pea 5e4df <IntUartPollCallbacks.6374+0xbf> <== NOT EXECUTED 427b2: 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)
427b4: 206b 00b6 moveal %a3@(182),%a0 <== NOT EXECUTED 427b8: 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(
427bc: 4870 0800 pea %a0@(00000000,%d0:l) <== NOT EXECUTED 427c0: 2f08 movel %a0,%sp@- <== NOT EXECUTED 427c2: 2f00 movel %d0,%sp@- <== NOT EXECUTED 427c4: 4879 0005 e4f5 pea 5e4f5 <IntUartPollCallbacks.6374+0xd5> <== NOT EXECUTED 427ca: 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) {
427cc: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED 427d0: 4a02 tstb %d2 <== NOT EXECUTED 427d2: 6618 bnes 427ec <Stack_check_report_blown_task+0x9c><== NOT EXECUTED
printk(
427d4: 486c 0018 pea %a4@(24) <== NOT EXECUTED 427d8: 486c 0008 pea %a4@(8) <== NOT EXECUTED 427dc: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED 427e0: 4879 0005 e526 pea 5e526 <IntUartPollCallbacks.6374+0x106> <== NOT EXECUTED 427e6: 4e92 jsr %a2@ <== NOT EXECUTED 427e8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
427ec: 4878 0081 pea 81 <DBL_MANT_DIG+0x4c> <== NOT EXECUTED 427f0: 4eb9 0004 8574 jsr 48574 <rtems_fatal_error_occurred> <== NOT EXECUTED
000461d4 <_API_Mutex_Unlock>:
#include <rtems/score/apimutex.h>
void _API_Mutex_Unlock(
API_Mutex_Control *the_mutex
)
{
461d4: 4e56 0000 linkw %fp,#0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
461d8: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0 461de: 5280 addql #1,%d0 461e0: 206e 0008 moveal %fp@(8),%a0 461e4: 23c0 0005 e9c8 movel %d0,5e9c8 <_Thread_Dispatch_disable_level>
_Thread_Disable_dispatch();
_CORE_mutex_Surrender(
461ea: 42a7 clrl %sp@- 461ec: 2f28 0008 movel %a0@(8),%sp@- 461f0: 4868 0010 pea %a0@(16) 461f4: 4eb9 0004 6458 jsr 46458 <_CORE_mutex_Surrender>
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
461fa: 4fef 000c lea %sp@(12),%sp
}
461fe: 4e5e unlk %fp
_CORE_mutex_Surrender(
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
46200: 4ef9 0004 7ac2 jmp 47ac2 <_Thread_Enable_dispatch>
...
000483b0 <_CORE_RWLock_Obtain_for_reading>:
* If unlocked, then OK to read.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
483b0: 203c 0000 0700 movel #1792,%d0
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
483b6: 4e56 ffe8 linkw %fp,#-24 483ba: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 483be: 246e 0008 moveal %fp@(8),%a2 483c2: 282e 000c movel %fp@(12),%d4 483c6: 262e 0014 movel %fp@(20),%d3 483ca: 1a2e 0013 moveb %fp@(19),%d5
ISR_Level level; Thread_Control *executing = _Thread_Executing;
483ce: 2679 0006 1a86 moveal 61a86 <_Per_CPU_Information+0xc>,%a3
* If unlocked, then OK to read.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
483d4: 40c2 movew %sr,%d2 483d6: 8082 orl %d2,%d0 483d8: 46c0 movew %d0,%sr
switch ( the_rwlock->current_state ) {
483da: 202a 0044 movel %a2@(68),%d0
483de: 6708 beqs 483e8 <_CORE_RWLock_Obtain_for_reading+0x38>
483e0: 7201 moveq #1,%d1 483e2: b280 cmpl %d0,%d1
483e4: 662a bnes 48410 <_CORE_RWLock_Obtain_for_reading+0x60><== NEVER TAKEN
483e6: 600e bras 483f6 <_CORE_RWLock_Obtain_for_reading+0x46>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
483e8: 7001 moveq #1,%d0
the_rwlock->number_of_readers += 1;
483ea: 52aa 0048 addql #1,%a2@(72)
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
483ee: 2540 0044 movel %d0,%a2@(68)
the_rwlock->number_of_readers += 1; _ISR_Enable( level );
483f2: 46c2 movew %d2,%sr 483f4: 6014 bras 4840a <_CORE_RWLock_Obtain_for_reading+0x5a>
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
return;
case CORE_RWLOCK_LOCKED_FOR_READING: {
Thread_Control *waiter;
waiter = _Thread_queue_First( &the_rwlock->Wait_queue );
483f6: 2f0a movel %a2,%sp@- 483f8: 4eb9 0004 a254 jsr 4a254 <_Thread_queue_First>
if ( !waiter ) {
483fe: 588f addql #4,%sp 48400: 4a80 tstl %d0
48402: 660c bnes 48410 <_CORE_RWLock_Obtain_for_reading+0x60> the_rwlock->number_of_readers += 1;
48404: 52aa 0048 addql #1,%a2@(72)
_ISR_Enable( level );
48408: 46c2 movew %d2,%sr
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
4840a: 42ab 0034 clrl %a3@(52)
return;
4840e: 6046 bras 48456 <_CORE_RWLock_Obtain_for_reading+0xa6>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
48410: 4a05 tstb %d5
48412: 660a bnes 4841e <_CORE_RWLock_Obtain_for_reading+0x6e>
_ISR_Enable( level );
48414: 46c2 movew %d2,%sr
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
48416: 7202 moveq #2,%d1 48418: 2741 0034 movel %d1,%a3@(52) 4841c: 6038 bras 48456 <_CORE_RWLock_Obtain_for_reading+0xa6> 4841e: 7001 moveq #1,%d0 48420: 2540 0030 movel %d0,%a2@(48)
/*
* We need to wait to enter this critical section
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
48424: 274a 0044 movel %a2,%a3@(68)
executing->Wait.id = id;
48428: 2744 0020 movel %d4,%a3@(32)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
4842c: 42ab 0030 clrl %a3@(48)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
48430: 42ab 0034 clrl %a3@(52)
_ISR_Enable( level );
48434: 46c2 movew %d2,%sr
_Thread_queue_Enqueue_with_handler(
48436: 2d43 000c movel %d3,%fp@(12) 4843a: 223c 0004 85a0 movel #296352,%d1 48440: 2d4a 0008 movel %a2,%fp@(8)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
48444: 4cee 0c3c ffe8 moveml %fp@(-24),%d2-%d5/%a2-%a3
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
4844a: 2d41 0010 movel %d1,%fp@(16)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
4844e: 4e5e unlk %fp
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
48450: 4ef9 0004 9f40 jmp 49f40 <_Thread_queue_Enqueue_with_handler>
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
48456: 4cee 0c3c ffe8 moveml %fp@(-24),%d2-%d5/%a2-%a3
4845c: 4e5e unlk %fp <== NOT EXECUTED
000484ec <_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 );
484ec: 223c 0000 0700 movel #1792,%d1
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
484f2: 4e56 fff0 linkw %fp,#-16
ISR_Level level; Thread_Control *executing = _Thread_Executing;
484f6: 2079 0006 1a86 moveal 61a86 <_Per_CPU_Information+0xc>,%a0
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
484fc: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 48500: 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 );
48504: 40c0 movew %sr,%d0 48506: 8280 orl %d0,%d1 48508: 46c1 movew %d1,%sr
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
4850a: 222a 0044 movel %a2@(68),%d1
4850e: 660a bnes 4851a <_CORE_RWLock_Release+0x2e>
_ISR_Enable( level );
48510: 46c0 movew %d0,%sr
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
48512: 7002 moveq #2,%d0 48514: 2140 0034 movel %d0,%a0@(52)
return CORE_RWLOCK_SUCCESSFUL;
48518: 6078 bras 48592 <_CORE_RWLock_Release+0xa6>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
4851a: 7401 moveq #1,%d2 4851c: b481 cmpl %d1,%d2
4851e: 6610 bnes 48530 <_CORE_RWLock_Release+0x44> the_rwlock->number_of_readers -= 1;
48520: 222a 0048 movel %a2@(72),%d1 48524: 5381 subql #1,%d1 48526: 2541 0048 movel %d1,%a2@(72)
if ( the_rwlock->number_of_readers != 0 ) {
4852a: 6704 beqs 48530 <_CORE_RWLock_Release+0x44>
/* must be unlocked again */
_ISR_Enable( level );
4852c: 46c0 movew %d0,%sr
return CORE_RWLOCK_SUCCESSFUL;
4852e: 6062 bras 48592 <_CORE_RWLock_Release+0xa6>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
48530: 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;
48534: 42aa 0044 clrl %a2@(68)
_ISR_Enable( level );
48538: 46c0 movew %d0,%sr
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
4853a: 2f0a movel %a2,%sp@- 4853c: 4eb9 0004 9e00 jsr 49e00 <_Thread_queue_Dequeue>
if ( next ) {
48542: 588f addql #4,%sp 48544: 4a80 tstl %d0
48546: 674a beqs 48592 <_CORE_RWLock_Release+0xa6>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
48548: 7201 moveq #1,%d1 4854a: 2040 moveal %d0,%a0 4854c: b2a8 0030 cmpl %a0@(48),%d1
48550: 6608 bnes 4855a <_CORE_RWLock_Release+0x6e>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
48552: 7002 moveq #2,%d0 48554: 2540 0044 movel %d0,%a2@(68)
return CORE_RWLOCK_SUCCESSFUL;
48558: 6038 bras 48592 <_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;
4855a: 7201 moveq #1,%d1
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
4855c: 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 );
48560: 49f9 0004 a254 lea 4a254 <_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 );
48566: 47f9 0004 a124 lea 4a124 <_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;
4856c: 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 );
48570: 2f0a movel %a2,%sp@- 48572: 4e94 jsr %a4@
if ( !next ||
48574: 588f addql #4,%sp 48576: 4a80 tstl %d0
48578: 6718 beqs 48592 <_CORE_RWLock_Release+0xa6>
4857a: 7401 moveq #1,%d2 4857c: 2040 moveal %d0,%a0 4857e: b4a8 0030 cmpl %a0@(48),%d2
48582: 670e beqs 48592 <_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;
48584: 52aa 0048 addql #1,%a2@(72)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
48588: 2f00 movel %d0,%sp@- 4858a: 2f0a movel %a2,%sp@- 4858c: 4e93 jsr %a3@
}
4858e: 508f addql #8,%sp 48590: 60de bras 48570 <_CORE_RWLock_Release+0x84>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
48592: 4280 clrl %d0 48594: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 4859a: 4e5e unlk %fp
...
000485a0 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
485a0: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
485a4: 486e fffc pea %fp@(-4) 485a8: 2f2e 0008 movel %fp@(8),%sp@- 485ac: 4eb9 0004 9b38 jsr 49b38 <_Thread_Get>
switch ( location ) {
485b2: 508f addql #8,%sp 485b4: 4aae fffc tstl %fp@(-4)
485b8: 6618 bnes 485d2 <_CORE_RWLock_Timeout+0x32> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
485ba: 2f00 movel %d0,%sp@- 485bc: 4eb9 0004 a354 jsr 4a354 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
485c2: 588f addql #4,%sp 485c4: 2039 0006 161c movel 6161c <_Thread_Dispatch_disable_level>,%d0 485ca: 5380 subql #1,%d0 485cc: 23c0 0006 161c movel %d0,6161c <_Thread_Dispatch_disable_level>
_Thread_Unnest_dispatch();
break;
}
}
485d2: 4e5e unlk %fp
...
0004726c <_CORE_barrier_Wait>:
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4726c: 203c 0000 0700 movel #1792,%d0
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
47272: 4e56 fff4 linkw %fp,#-12
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
47276: 2279 0006 0416 moveal 60416 <_Per_CPU_Information+0xc>,%a1
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4727c: 48d7 001c moveml %d2-%d4,%sp@ 47280: 206e 0008 moveal %fp@(8),%a0
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
47284: 42a9 0034 clrl %a1@(52)
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
47288: 242e 000c movel %fp@(12),%d2 4728c: 262e 0014 movel %fp@(20),%d3 47290: 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 );
47294: 40c1 movew %sr,%d1 47296: 8081 orl %d1,%d0 47298: 46c0 movew %d0,%sr
the_barrier->number_of_waiting_threads++;
4729a: 2028 0048 movel %a0@(72),%d0 4729e: 5280 addql #1,%d0 472a0: 2140 0048 movel %d0,%a0@(72)
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
472a4: 4aa8 0040 tstl %a0@(64)
472a8: 6626 bnes 472d0 <_CORE_barrier_Wait+0x64>
if ( the_barrier->number_of_waiting_threads ==
472aa: b0a8 0044 cmpl %a0@(68),%d0
472ae: 6620 bnes 472d0 <_CORE_barrier_Wait+0x64>
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
472b0: 7001 moveq #1,%d0 472b2: 2340 0034 movel %d0,%a1@(52)
_ISR_Enable( level );
472b6: 46c1 movew %d1,%sr
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
472b8: 2d44 0010 movel %d4,%fp@(16) 472bc: 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 );
}
472c0: 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 );
472c4: 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 );
}
472c8: 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 );
472ca: 4ef9 0004 bc58 jmp 4bc58 <_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;
472d0: 7001 moveq #1,%d0 472d2: 2140 0030 movel %d0,%a0@(48)
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
472d6: 2348 0044 movel %a0,%a1@(68)
executing->Wait.id = id;
472da: 2342 0020 movel %d2,%a1@(32)
_ISR_Enable( level );
472de: 46c1 movew %d1,%sr
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
472e0: 2d43 000c movel %d3,%fp@(12) 472e4: 203c 0004 91f4 movel #299508,%d0 472ea: 2d48 0008 movel %a0,%fp@(8)
}
472ee: 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 );
472f2: 2d40 0010 movel %d0,%fp@(16)
}
472f6: 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 );
472f8: 4ef9 0004 8ee0 jmp 48ee0 <_Thread_queue_Enqueue_with_handler>
...
0004e084 <_CORE_message_queue_Initialize>:
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
4e084: 7003 moveq #3,%d0
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
4e086: 4e56 fff4 linkw %fp,#-12 4e08a: 222e 0014 movel %fp@(20),%d1 4e08e: 48d7 040c moveml %d2-%d3/%a2,%sp@ 4e092: 246e 0008 moveal %fp@(8),%a2 4e096: 242e 0010 movel %fp@(16),%d2
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
4e09a: c081 andl %d1,%d0
)
{
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
4e09c: 2542 0044 movel %d2,%a2@(68)
the_message_queue->number_of_pending_messages = 0;
4e0a0: 42aa 0048 clrl %a2@(72)
the_message_queue->maximum_message_size = maximum_message_size;
4e0a4: 2541 004c movel %d1,%a2@(76)
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
4e0a8: 42aa 0060 clrl %a2@(96)
the_message_queue->notify_argument = the_argument;
4e0ac: 42aa 0064 clrl %a2@(100)
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
4e0b0: 4a80 tstl %d0
4e0b2: 670e beqs 4e0c2 <_CORE_message_queue_Initialize+0x3e>
allocated_message_size += sizeof(uint32_t);
4e0b4: 2001 movel %d1,%d0 4e0b6: 5880 addql #4,%d0
allocated_message_size &= ~(sizeof(uint32_t) - 1);
4e0b8: 76fc moveq #-4,%d3 4e0ba: c083 andl %d3,%d0
}
if (allocated_message_size < maximum_message_size)
4e0bc: b280 cmpl %d0,%d1
4e0be: 6272 bhis 4e132 <_CORE_message_queue_Initialize+0xae><== NEVER TAKEN
4e0c0: 6002 bras 4e0c4 <_CORE_message_queue_Initialize+0x40>
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
4e0c2: 2001 movel %d1,%d0
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
4e0c4: 2600 movel %d0,%d3 4e0c6: 0683 0000 0014 addil #20,%d3
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
4e0cc: 2203 movel %d3,%d1 4e0ce: 4c02 1800 mulsl %d2,%d1
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
4e0d2: b081 cmpl %d1,%d0
4e0d4: 625c bhis 4e132 <_CORE_message_queue_Initialize+0xae><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
4e0d6: 2f01 movel %d1,%sp@- 4e0d8: 4eb9 0005 0b44 jsr 50b44 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
4e0de: 588f addql #4,%sp
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
4e0e0: 2540 005c movel %d0,%a2@(92)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
4e0e4: 674c beqs 4e132 <_CORE_message_queue_Initialize+0xae>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
4e0e6: 2f03 movel %d3,%sp@- 4e0e8: 2f02 movel %d2,%sp@- 4e0ea: 2f00 movel %d0,%sp@- 4e0ec: 486a 0068 pea %a2@(104) 4e0f0: 4eb9 0005 2d8c jsr 52d8c <_Chain_Initialize>
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 );
4e0f6: 41ea 0054 lea %a2@(84),%a0
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
4e0fa: 7001 moveq #1,%d0 4e0fc: 2548 0050 movel %a0,%a2@(80)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e100: 41ea 0050 lea %a2@(80),%a0
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4e104: 42aa 0054 clrl %a2@(84)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e108: 2548 0058 movel %a0,%a2@(88) 4e10c: 4878 0006 pea 6 <EXTENDSFDF> 4e110: 206e 000c moveal %fp@(12),%a0 4e114: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b> 4e118: b090 cmpl %a0@,%d0 4e11a: 57c0 seq %d0 4e11c: 49c0 extbl %d0 4e11e: 4480 negl %d0 4e120: 2f00 movel %d0,%sp@- 4e122: 2f0a movel %a2,%sp@- 4e124: 4eb9 0005 02a0 jsr 502a0 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
4e12a: 4fef 0020 lea %sp@(32),%sp 4e12e: 7001 moveq #1,%d0 4e130: 6002 bras 4e134 <_CORE_message_queue_Initialize+0xb0>
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
return false;
4e132: 4200 clrb %d0
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
4e134: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 4e13a: 4e5e unlk %fp
...
0004e140 <_CORE_message_queue_Seize>:
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4e140: 223c 0000 0700 movel #1792,%d1
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
4e146: 4e56 ffe0 linkw %fp,#-32
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
4e14a: 2079 0006 7a3a moveal 67a3a <_Per_CPU_Information+0xc>,%a0
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
4e150: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@ 4e154: 246e 0008 moveal %fp@(8),%a2 4e158: 262e 000c movel %fp@(12),%d3 4e15c: 2a2e 0010 movel %fp@(16),%d5 4e160: 226e 0014 moveal %fp@(20),%a1 4e164: 242e 001c movel %fp@(28),%d2 4e168: 182e 001b moveb %fp@(27),%d4
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
4e16c: 42a8 0034 clrl %a0@(52)
_ISR_Disable( level );
4e170: 40c0 movew %sr,%d0 4e172: 8280 orl %d0,%d1 4e174: 46c1 movew %d1,%sr
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4e176: 220a movel %a2,%d1 4e178: 0681 0000 0054 addil #84,%d1
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4e17e: 266a 0050 moveal %a2@(80),%a3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4e182: b28b cmpl %a3,%d1 4e184: 6700 00a6 beqw 4e22c <_CORE_message_queue_Seize+0xec>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
4e188: 2a53 moveal %a3@,%a5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e18a: 49ea 0050 lea %a2@(80),%a4
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
4e18e: 254d 0050 movel %a5,%a2@(80)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e192: 2b4c 0004 movel %a4,%a5@(4)
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
4e196: 4a8b tstl %a3 4e198: 6700 0092 beqw 4e22c <_CORE_message_queue_Seize+0xec>
the_message_queue->number_of_pending_messages -= 1;
4e19c: 53aa 0048 subql #1,%a2@(72)
_ISR_Enable( level );
4e1a0: 46c0 movew %d0,%sr
*size_p = the_message->Contents.size;
_Thread_Executing->Wait.count =
4e1a2: 2079 0006 7a3a moveal 67a3a <_Per_CPU_Information+0xc>,%a0
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
4e1a8: 22ab 000c movel %a3@(12),%a1@
_Thread_Executing->Wait.count =
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
4e1ac: 240b movel %a3,%d2 4e1ae: 0682 0000 0010 addil #16,%d2
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
_Thread_Executing->Wait.count =
4e1b4: 216b 0008 0024 movel %a3@(8),%a0@(36)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4e1ba: 49f9 0005 55dc lea 555dc <memcpy>,%a4 4e1c0: 2f11 movel %a1@,%sp@- 4e1c2: 2f02 movel %d2,%sp@- 4e1c4: 2f05 movel %d5,%sp@- 4e1c6: 4e94 jsr %a4@
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
4e1c8: 2f0a movel %a2,%sp@- 4e1ca: 4eb9 0004 ff1c jsr 4ff1c <_Thread_queue_Dequeue>
if ( !the_thread ) {
4e1d0: 4fef 0010 lea %sp@(16),%sp
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
4e1d4: 2040 moveal %d0,%a0
if ( !the_thread ) {
4e1d6: 4a80 tstl %d0
4e1d8: 661a bnes 4e1f4 <_CORE_message_queue_Seize+0xb4>
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
4e1da: 45ea 0068 lea %a2@(104),%a2 4e1de: 2d4b 000c movel %a3,%fp@(12) 4e1e2: 2d4a 0008 movel %a2,%fp@(8)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4e1e6: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5 4e1ec: 4e5e unlk %fp 4e1ee: 4ef9 0004 dfc0 jmp 4dfc0 <_Chain_Append>
*/
_CORE_message_queue_Set_message_priority(
the_message,
the_thread->Wait.count
);
the_message->Contents.size = (size_t) the_thread->Wait.option;
4e1f4: 2028 0030 movel %a0@(48),%d0
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
4e1f8: 2768 0024 0008 movel %a0@(36),%a3@(8) 4e1fe: 2740 000c movel %d0,%a3@(12)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4e202: 2f00 movel %d0,%sp@- 4e204: 2f28 002c movel %a0@(44),%sp@- 4e208: 2f02 movel %d2,%sp@- 4e20a: 4e94 jsr %a4@
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
4e20c: 2d6b 0008 0010 movel %a3@(8),%fp@(16) 4e212: 4fef 000c lea %sp@(12),%sp 4e216: 2d4b 000c movel %a3,%fp@(12) 4e21a: 2d4a 0008 movel %a2,%fp@(8)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4e21e: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5 4e224: 4e5e unlk %fp
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
4e226: 4ef9 0005 2dd0 jmp 52dd0 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
4e22c: 4a04 tstb %d4
4e22e: 6612 bnes 4e242 <_CORE_message_queue_Seize+0x102>
_ISR_Enable( level );
4e230: 46c0 movew %d0,%sr
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
4e232: 7004 moveq #4,%d0
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4e234: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5
#endif
}
if ( !wait ) {
_ISR_Enable( level );
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
4e23a: 2140 0034 movel %d0,%a0@(52)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4e23e: 4e5e unlk %fp 4e240: 4e75 rts
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;
4e242: 7201 moveq #1,%d1 4e244: 2541 0030 movel %d1,%a2@(48)
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
executing->Wait.id = id;
executing->Wait.return_argument_second.mutable_object = buffer;
4e248: 2145 002c movel %d5,%a0@(44)
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
4e24c: 214a 0044 movel %a2,%a0@(68)
executing->Wait.id = id;
4e250: 2143 0020 movel %d3,%a0@(32)
executing->Wait.return_argument_second.mutable_object = buffer; executing->Wait.return_argument = size_p;
4e254: 2149 0028 movel %a1,%a0@(40)
/* Wait.count will be filled in with the message priority */ _ISR_Enable( level );
4e258: 46c0 movew %d0,%sr
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
4e25a: 49f9 0005 0370 lea 50370 <_Thread_queue_Timeout>,%a4 4e260: 2d42 000c movel %d2,%fp@(12) 4e264: 2d4c 0010 movel %a4,%fp@(16) 4e268: 2d4a 0008 movel %a2,%fp@(8)
}
4e26c: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5 4e272: 4e5e unlk %fp
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
4e274: 4ef9 0005 005c jmp 5005c <_Thread_queue_Enqueue_with_handler>
...
000463b4 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
463b4: 4e56 0000 linkw %fp,#0
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
463b8: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
463be: 2f0a movel %a2,%sp@- 463c0: 246e 0008 moveal %fp@(8),%a2 463c4: 2f02 movel %d2,%sp@- 463c6: 142e 0013 moveb %fp@(19),%d2
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
463ca: 4a80 tstl %d0
463cc: 671c beqs 463ea <_CORE_mutex_Seize+0x36>
463ce: 4a02 tstb %d2
463d0: 6718 beqs 463ea <_CORE_mutex_Seize+0x36> <== NEVER TAKEN
463d2: 7001 moveq #1,%d0 463d4: b0b9 0005 eb14 cmpl 5eb14 <_System_state_Current>,%d0
463da: 640e bccs 463ea <_CORE_mutex_Seize+0x36>
463dc: 4878 0012 pea 12 <INVALID_OPERATION+0x2> 463e0: 42a7 clrl %sp@- 463e2: 42a7 clrl %sp@- 463e4: 4eb9 0004 6a08 jsr 46a08 <_Internal_error_Occurred> 463ea: 486e 0018 pea %fp@(24) 463ee: 2f0a movel %a2,%sp@- 463f0: 4eb9 0004 ac50 jsr 4ac50 <_CORE_mutex_Seize_interrupt_trylock> 463f6: 508f addql #8,%sp 463f8: 4a80 tstl %d0
463fa: 6750 beqs 4644c <_CORE_mutex_Seize+0x98>
463fc: 4a02 tstb %d2
463fe: 6614 bnes 46414 <_CORE_mutex_Seize+0x60>
46400: 202e 0018 movel %fp@(24),%d0 46404: 46c0 movew %d0,%sr 46406: 2079 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a0 4640c: 7001 moveq #1,%d0 4640e: 2140 0034 movel %d0,%a0@(52) 46412: 6038 bras 4644c <_CORE_mutex_Seize+0x98>
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;
46414: 7001 moveq #1,%d0 46416: 2079 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a0 4641c: 2540 0030 movel %d0,%a2@(48) 46420: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0 46426: 5280 addql #1,%d0 46428: 216e 000c 0020 movel %fp@(12),%a0@(32) 4642e: 214a 0044 movel %a2,%a0@(68) 46432: 23c0 0005 e9c8 movel %d0,5e9c8 <_Thread_Dispatch_disable_level> 46438: 202e 0018 movel %fp@(24),%d0 4643c: 46c0 movew %d0,%sr 4643e: 2f2e 0014 movel %fp@(20),%sp@- 46442: 2f0a movel %a2,%sp@- 46444: 4eb9 0004 6350 jsr 46350 <_CORE_mutex_Seize_interrupt_blocking> 4644a: 508f addql #8,%sp
}
4644c: 242e fff8 movel %fp@(-8),%d2 46450: 246e fffc moveal %fp@(-4),%a2
46454: 4e5e unlk %fp <== NOT EXECUTED
00046590 <_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
)
{
46590: 4e56 0000 linkw %fp,#0 46594: 2f0a movel %a2,%sp@- 46596: 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)) ) {
4659a: 2f0a movel %a2,%sp@- 4659c: 4eb9 0004 7db0 jsr 47db0 <_Thread_queue_Dequeue> 465a2: 588f addql #4,%sp 465a4: 4a80 tstl %d0
465a6: 6624 bnes 465cc <_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 );
465a8: 303c 0700 movew #1792,%d0 465ac: 40c1 movew %sr,%d1 465ae: 8081 orl %d1,%d0 465b0: 46c0 movew %d0,%sr
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
465b2: 202a 0048 movel %a2@(72),%d0 465b6: b0aa 0040 cmpl %a2@(64),%d0
465ba: 640a bccs 465c6 <_CORE_semaphore_Surrender+0x36> <== NEVER TAKEN
the_semaphore->count += 1;
465bc: 5280 addql #1,%d0 465be: 2540 0048 movel %d0,%a2@(72)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
465c2: 4280 clrl %d0 465c4: 6002 bras 465c8 <_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;
465c6: 7004 moveq #4,%d0 <== NOT EXECUTED
_ISR_Enable( level );
465c8: 46c1 movew %d1,%sr 465ca: 6002 bras 465ce <_CORE_semaphore_Surrender+0x3e>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
465cc: 4280 clrl %d0
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
465ce: 246e fffc moveal %fp@(-4),%a2 465d2: 4e5e unlk %fp
...
00045458 <_Event_Surrender>:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
45458: 203c 0000 0700 movel #1792,%d0
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
4545e: 4e56 ffe8 linkw %fp,#-24 45462: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 45466: 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 ];
4546a: 206a 00fe moveal %a2@(254),%a0
option_set = (rtems_option) the_thread->Wait.option;
4546e: 282a 0030 movel %a2@(48),%d4
_ISR_Disable( level );
45472: 40c1 movew %sr,%d1 45474: 8081 orl %d1,%d0 45476: 46c0 movew %d0,%sr
pending_events = api->pending_events; event_condition = (rtems_event_set) the_thread->Wait.count;
45478: 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 );
4547c: 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;
4547e: 2410 movel %a0@,%d2 45480: 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 ) ) {
45482: 6606 bnes 4548a <_Event_Surrender+0x32>
_ISR_Enable( level );
45484: 46c1 movew %d1,%sr
return;
45486: 6000 00ca braw 45552 <_Event_Surrender+0xfa>
/*
* 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() &&
4548a: 4ab9 0005 ee2e tstl 5ee2e <_Per_CPU_Information+0x8>
45490: 674a beqs 454dc <_Event_Surrender+0x84>
45492: b5f9 0005 ee32 cmpal 5ee32 <_Per_CPU_Information+0xc>,%a2
45498: 6642 bnes 454dc <_Event_Surrender+0x84>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
4549a: 2279 0005 f204 moveal 5f204 <_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 ) &&
454a0: 7a02 moveq #2,%d5 454a2: ba89 cmpl %a1,%d5
454a4: 670e beqs 454b4 <_Event_Surrender+0x5c> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
454a6: 2279 0005 f204 moveal 5f204 <_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) ||
454ac: 1a3c 0001 moveb #1,%d5 454b0: ba89 cmpl %a1,%d5
454b2: 6628 bnes 454dc <_Event_Surrender+0x84>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
454b4: b680 cmpl %d0,%d3
454b6: 6706 beqs 454be <_Event_Surrender+0x66>
454b8: 0804 0001 btst #1,%d4
454bc: 671a beqs 454d8 <_Event_Surrender+0x80> <== NEVER TAKEN
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) );
454be: 2600 movel %d0,%d3 454c0: 4683 notl %d3 454c2: c682 andl %d2,%d3 454c4: 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;
454c6: 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;
454ca: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
454ce: 2080 movel %d0,%a0@
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
454d0: 7003 moveq #3,%d0 454d2: 23c0 0005 f204 movel %d0,5f204 <_Event_Sync_state>
}
_ISR_Enable( level );
454d8: 46c1 movew %d1,%sr
return;
454da: 6076 bras 45552 <_Event_Surrender+0xfa>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
454dc: 2a2a 0010 movel %a2@(16),%d5 454e0: 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 ) ) {
454e6: 6768 beqs 45550 <_Event_Surrender+0xf8>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
454e8: b680 cmpl %d0,%d3
454ea: 6706 beqs 454f2 <_Event_Surrender+0x9a>
454ec: 0804 0001 btst #1,%d4
454f0: 675e beqs 45550 <_Event_Surrender+0xf8> <== NEVER TAKEN
454f2: 2600 movel %d0,%d3 454f4: 4683 notl %d3 454f6: c682 andl %d2,%d3 454f8: 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;
454fa: 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;
454fe: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
45502: 2080 movel %d0,%a0@
_ISR_Flash( level );
45504: 203c 0000 0700 movel #1792,%d0 4550a: 46c1 movew %d1,%sr 4550c: 8081 orl %d1,%d0 4550e: 46c0 movew %d0,%sr 45510: 47f9 0004 7780 lea 47780 <_Thread_Clear_state>,%a3
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
45516: 7a02 moveq #2,%d5 45518: baaa 0050 cmpl %a2@(80),%d5
4551c: 6710 beqs 4552e <_Event_Surrender+0xd6>
_ISR_Enable( level );
4551e: 46c1 movew %d1,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
45520: 2f3c 1003 fff8 movel #268697592,%sp@- 45526: 2f0a movel %a2,%sp@- 45528: 4e93 jsr %a3@ 4552a: 508f addql #8,%sp 4552c: 6024 bras 45552 <_Event_Surrender+0xfa>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
4552e: 7003 moveq #3,%d0 45530: 2540 0050 movel %d0,%a2@(80)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
45534: 46c1 movew %d1,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
45536: 486a 0048 pea %a2@(72) 4553a: 4eb9 0004 8880 jsr 48880 <_Watchdog_Remove> 45540: 2f3c 1003 fff8 movel #268697592,%sp@- 45546: 2f0a movel %a2,%sp@- 45548: 4e93 jsr %a3@ 4554a: 4fef 000c lea %sp@(12),%sp 4554e: 6002 bras 45552 <_Event_Surrender+0xfa>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
45550: 46c1 movew %d1,%sr
}
45552: 4cee 0c3c ffe8 moveml %fp@(-24),%d2-%d5/%a2-%a3
45558: 4e5e unlk %fp <== NOT EXECUTED
0004555c <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
4555c: 4e56 fffc linkw %fp,#-4 45560: 2f03 movel %d3,%sp@- 45562: 2f02 movel %d2,%sp@-
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
45564: 486e fffc pea %fp@(-4) 45568: 2f2e 0008 movel %fp@(8),%sp@- 4556c: 4eb9 0004 7ae8 jsr 47ae8 <_Thread_Get>
switch ( location ) {
45572: 508f addql #8,%sp 45574: 4aae fffc tstl %fp@(-4)
45578: 6656 bnes 455d0 <_Event_Timeout+0x74> <== 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 );
4557a: 223c 0000 0700 movel #1792,%d1 45580: 40c2 movew %sr,%d2 45582: 8282 orl %d2,%d1 45584: 46c1 movew %d1,%sr
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
45586: 2040 moveal %d0,%a0 45588: 42a8 0024 clrl %a0@(36)
if ( _Thread_Is_executing( the_thread ) ) {
4558c: b0b9 0005 ee32 cmpl 5ee32 <_Per_CPU_Information+0xc>,%d0
45592: 6614 bnes 455a8 <_Event_Timeout+0x4c>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
45594: 2239 0005 f204 movel 5f204 <_Event_Sync_state>,%d1 4559a: 7601 moveq #1,%d3 4559c: b681 cmpl %d1,%d3
4559e: 6608 bnes 455a8 <_Event_Timeout+0x4c>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
455a0: 7202 moveq #2,%d1 455a2: 23c1 0005 f204 movel %d1,5f204 <_Event_Sync_state>
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
455a8: 7606 moveq #6,%d3 455aa: 2040 moveal %d0,%a0 455ac: 2143 0034 movel %d3,%a0@(52)
_ISR_Enable( level );
455b0: 46c2 movew %d2,%sr 455b2: 2f3c 1003 fff8 movel #268697592,%sp@- 455b8: 2f00 movel %d0,%sp@- 455ba: 4eb9 0004 7780 jsr 47780 <_Thread_Clear_state>
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
455c0: 508f addql #8,%sp
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
455c2: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0 455c8: 5380 subql #1,%d0 455ca: 23c0 0005 e9c8 movel %d0,5e9c8 <_Thread_Dispatch_disable_level>
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
455d0: 242e fff4 movel %fp@(-12),%d2 455d4: 262e fff8 movel %fp@(-8),%d3
455d8: 4e5e unlk %fp <== NOT EXECUTED
0004b228 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
4b228: 4e56 ffcc linkw %fp,#-52 4b22c: 202e 0010 movel %fp@(16),%d0 4b230: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4b234: 246e 0008 moveal %fp@(8),%a2 4b238: 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;
4b23c: 2403 movel %d3,%d2 4b23e: d480 addl %d0,%d2
uintptr_t const free_size = stats->free_size;
4b240: 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;
4b244: 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;
4b248: 2a2a 0010 movel %a2@(16),%d5
uintptr_t const min_block_size = heap->min_block_size;
4b24c: 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;
4b250: 42ae fffc clrl %fp@(-4)
Heap_Block *extend_last_block = NULL;
4b254: 42ae fff8 clrl %fp@(-8)
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;
4b258: 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 ) {
4b25c: b682 cmpl %d2,%d3 4b25e: 6200 01aa bhiw 4b40a <_Heap_Extend+0x1e2>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
4b262: 486e fff8 pea %fp@(-8) 4b266: 486e fffc pea %fp@(-4) 4b26a: 2f01 movel %d1,%sp@- 4b26c: 2f05 movel %d5,%sp@- 4b26e: 2f00 movel %d0,%sp@- 4b270: 2f03 movel %d3,%sp@- 4b272: 4eb9 0004 6ac6 jsr 46ac6 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
4b278: 4fef 0018 lea %sp@(24),%sp 4b27c: 4a00 tstb %d0 4b27e: 6700 018a beqw 4b40a <_Heap_Extend+0x1e2> 4b282: 2044 moveal %d4,%a0 4b284: 9bcd subal %a5,%a5 4b286: 4281 clrl %d1 4b288: 97cb subal %a3,%a3 4b28a: 99cc subal %a4,%a4
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
4b28c: b888 cmpl %a0,%d4
4b28e: 6704 beqs 4b294 <_Heap_Extend+0x6c>
4b290: 2248 moveal %a0,%a1 4b292: 6004 bras 4b298 <_Heap_Extend+0x70> 4b294: 226a 0018 moveal %a2@(24),%a1
uintptr_t const sub_area_end = start_block->prev_size;
4b298: 2010 movel %a0@,%d0
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4b29a: b680 cmpl %d0,%d3
4b29c: 6406 bccs 4b2a4 <_Heap_Extend+0x7c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
4b29e: b3c2 cmpal %d2,%a1 4b2a0: 6500 0168 bcsw 4b40a <_Heap_Extend+0x1e2>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4b2a4: b3c2 cmpal %d2,%a1
4b2a6: 6706 beqs 4b2ae <_Heap_Extend+0x86>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4b2a8: b082 cmpl %d2,%d0
4b2aa: 6206 bhis 4b2b2 <_Heap_Extend+0x8a>
4b2ac: 6006 bras 4b2b4 <_Heap_Extend+0x8c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4b2ae: 2848 moveal %a0,%a4 4b2b0: 6002 bras 4b2b4 <_Heap_Extend+0x8c>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4b2b2: 2208 movel %a0,%d1 4b2b4: 2e00 movel %d0,%d7 4b2b6: 2240 moveal %d0,%a1 4b2b8: 5189 subql #8,%a1 4b2ba: 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);
4b2be: 93c6 subal %d6,%a1
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4b2c0: b680 cmpl %d0,%d3
4b2c2: 6606 bnes 4b2ca <_Heap_Extend+0xa2>
start_block->prev_size = extend_area_end;
4b2c4: 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 )
4b2c6: 2649 moveal %a1,%a3 4b2c8: 6006 bras 4b2d0 <_Heap_Extend+0xa8>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
4b2ca: b680 cmpl %d0,%d3
4b2cc: 6302 blss 4b2d0 <_Heap_Extend+0xa8>
4b2ce: 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;
4b2d0: 70fe moveq #-2,%d0 4b2d2: 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);
4b2d6: 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 );
4b2da: b888 cmpl %a0,%d4
4b2dc: 66ae bnes 4b28c <_Heap_Extend+0x64>
if ( extend_area_begin < heap->area_begin ) {
4b2de: b6aa 0018 cmpl %a2@(24),%d3
4b2e2: 6406 bccs 4b2ea <_Heap_Extend+0xc2>
heap->area_begin = extend_area_begin;
4b2e4: 2543 0018 movel %d3,%a2@(24) 4b2e8: 600a bras 4b2f4 <_Heap_Extend+0xcc>
} else if ( heap->area_end < extend_area_end ) {
4b2ea: b4aa 001c cmpl %a2@(28),%d2
4b2ee: 6304 blss 4b2f4 <_Heap_Extend+0xcc>
heap->area_end = extend_area_end;
4b2f0: 2542 001c movel %d2,%a2@(28)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4b2f4: 206e fff8 moveal %fp@(-8),%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 =
4b2f8: 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;
4b2fa: 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;
4b2fc: 226e fffc moveal %fp@(-4),%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 =
4b300: 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;
4b302: 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;
4b304: 2282 movel %d2,%a1@
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4b306: 2344 0004 movel %d4,%a1@(4)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
4b30a: 2080 movel %d0,%a0@
extend_last_block->size_and_flag = 0;
4b30c: 42a8 0004 clrl %a0@(4)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4b310: b3ea 0020 cmpal %a2@(32),%a1
4b314: 6406 bccs 4b31c <_Heap_Extend+0xf4>
heap->first_block = extend_first_block;
4b316: 2549 0020 movel %a1,%a2@(32) 4b31a: 600a bras 4b326 <_Heap_Extend+0xfe>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4b31c: b1ea 0024 cmpal %a2@(36),%a0
4b320: 6304 blss 4b326 <_Heap_Extend+0xfe>
heap->last_block = extend_last_block;
4b322: 2548 0024 movel %a0,%a2@(36)
}
if ( merge_below_block != NULL ) {
4b326: 4a8c tstl %a4
4b328: 6732 beqs 4b35c <_Heap_Extend+0x134>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
4b32a: 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 );
4b32e: 5083 addql #8,%d3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
4b330: 2803 movel %d3,%d4 4b332: 4c40 4001 remul %d0,%d1,%d4
if ( remainder != 0 ) {
4b336: 4a81 tstl %d1
4b338: 6704 beqs 4b33e <_Heap_Extend+0x116>
return value - remainder + alignment;
4b33a: d680 addl %d0,%d3 4b33c: 9681 subl %d1,%d3
uintptr_t const new_first_block_begin =
4b33e: 2043 moveal %d3,%a0 4b340: 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 =
4b342: 200c movel %a4,%d0 4b344: 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;
4b346: 7201 moveq #1,%d1 4b348: 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;
4b34a: 2094 movel %a4@,%a0@
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4b34c: 2141 0004 movel %d1,%a0@(4)
_Heap_Free_block( heap, new_first_block );
4b350: 2f08 movel %a0,%sp@- 4b352: 2f0a movel %a2,%sp@- 4b354: 4eba feb6 jsr %pc@(4b20c <_Heap_Free_block>) 4b358: 508f addql #8,%sp 4b35a: 6012 bras 4b36e <_Heap_Extend+0x146>
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 ) {
4b35c: 4a81 tstl %d1
4b35e: 670e beqs 4b36e <_Heap_Extend+0x146>
_Heap_Link_below(
4b360: 206e fff8 moveal %fp@(-8),%a0
{
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;
4b364: 7801 moveq #1,%d4 4b366: 9288 subl %a0,%d1 4b368: 8881 orl %d1,%d4 4b36a: 2144 0004 movel %d4,%a0@(4)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
4b36e: 4a8b tstl %a3
4b370: 6734 beqs 4b3a6 <_Heap_Extend+0x17e>
)
{
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,
4b372: 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(
4b374: 948b subl %a3,%d2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4b376: 2202 movel %d2,%d1 4b378: 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;
4b37e: 7201 moveq #1,%d1 4b380: 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)
4b382: 202b 0004 movel %a3@(4),%d0 4b386: 9082 subl %d2,%d0
| HEAP_PREV_BLOCK_USED;
4b388: 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;
4b38a: 7001 moveq #1,%d0 4b38c: 2781 2804 movel %d1,%a3@(00000004,%d2:l) 4b390: c0ab 0004 andl %a3@(4),%d0
block->size_and_flag = size | flag;
4b394: 8480 orl %d0,%d2 4b396: 2742 0004 movel %d2,%a3@(4)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
4b39a: 2f0b movel %a3,%sp@- 4b39c: 2f0a movel %a2,%sp@- 4b39e: 4eba fe6c jsr %pc@(4b20c <_Heap_Free_block>) 4b3a2: 508f addql #8,%sp 4b3a4: 6020 bras 4b3c6 <_Heap_Extend+0x19e>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
4b3a6: 4a8d tstl %a5
4b3a8: 671c beqs 4b3c6 <_Heap_Extend+0x19e>
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;
4b3aa: 7001 moveq #1,%d0
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;
4b3ac: 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 );
4b3ae: 222e fffc movel %fp@(-4),%d1 4b3b2: 928d subl %a5,%d1 4b3b4: c0ad 0004 andl %a5@(4),%d0
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
4b3b8: 206e fff8 moveal %fp@(-8),%a0
block->size_and_flag = size | flag;
4b3bc: 8280 orl %d0,%d1 4b3be: 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;
4b3c2: 89a8 0004 orl %d4,%a0@(4)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4b3c6: 4a8c tstl %a4
4b3c8: 6610 bnes 4b3da <_Heap_Extend+0x1b2>
4b3ca: 4a8b tstl %a3
4b3cc: 660c bnes 4b3da <_Heap_Extend+0x1b2>
_Heap_Free_block( heap, extend_first_block );
4b3ce: 2f2e fffc movel %fp@(-4),%sp@- 4b3d2: 2f0a movel %a2,%sp@- 4b3d4: 4eba fe36 jsr %pc@(4b20c <_Heap_Free_block>) 4b3d8: 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
4b3da: 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;
4b3de: 7001 moveq #1,%d0
* 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(
4b3e0: 222a 0020 movel %a2@(32),%d1 4b3e4: 9288 subl %a0,%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;
4b3e6: c0a8 0004 andl %a0@(4),%d0
block->size_and_flag = size | flag;
4b3ea: 8280 orl %d0,%d1
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
4b3ec: 202a 0030 movel %a2@(48),%d0 4b3f0: 90ae fff4 subl %fp@(-12),%d0 4b3f4: 2141 0004 movel %d1,%a0@(4)
/* Statistics */
stats->size += extended_size;
4b3f8: d1aa 002c addl %d0,%a2@(44)
if ( extended_size_ptr != NULL )
4b3fc: 4aae 0014 tstl %fp@(20)
4b400: 670c beqs 4b40e <_Heap_Extend+0x1e6> <== NEVER TAKEN
*extended_size_ptr = extended_size;
4b402: 206e 0014 moveal %fp@(20),%a0 4b406: 2080 movel %d0,%a0@ 4b408: 6004 bras 4b40e <_Heap_Extend+0x1e6>
_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;
4b40a: 4200 clrb %d0 4b40c: 6002 bras 4b410 <_Heap_Extend+0x1e8>
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
4b40e: 7001 moveq #1,%d0
}
4b410: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5 4b416: 4e5e unlk %fp
...
0004af2c <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4af2c: 4e56 ffe8 linkw %fp,#-24 4af30: 206e 0008 moveal %fp@(8),%a0 4af34: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 4af38: 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 ) {
4af3c: 6700 0150 beqw 4b08e <_Heap_Free+0x162> 4af40: 2240 moveal %d0,%a1 4af42: 5189 subql #8,%a1 4af44: 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
4af4a: 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);
4af4e: 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;
4af50: b889 cmpl %a1,%d4
4af52: 620c bhis 4af60 <_Heap_Free+0x34>
4af54: b3e8 0024 cmpal %a0@(36),%a1 4af58: 53c0 sls %d0 4af5a: 49c0 extbl %d0 4af5c: 4480 negl %d0 4af5e: 6002 bras 4af62 <_Heap_Free+0x36> 4af60: 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 ) ) {
4af62: 4a00 tstb %d0 4af64: 6700 012c beqw 4b092 <_Heap_Free+0x166>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4af68: 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;
4af6c: 70fe moveq #-2,%d0 4af6e: 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);
4af70: 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;
4af74: b88a cmpl %a2,%d4
4af76: 620c bhis 4af84 <_Heap_Free+0x58> <== NEVER TAKEN
4af78: b5e8 0024 cmpal %a0@(36),%a2 4af7c: 53c1 sls %d1 4af7e: 49c1 extbl %d1 4af80: 4481 negl %d1 4af82: 6002 bras 4af86 <_Heap_Free+0x5a>
4af84: 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 ) ) {
4af86: 4a01 tstb %d1 4af88: 6700 0108 beqw 4b092 <_Heap_Free+0x166>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4af8c: 242a 0004 movel %a2@(4),%d2
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4af90: 0802 0000 btst #0,%d2 4af94: 6700 00fc beqw 4b092 <_Heap_Free+0x166>
- 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;
4af98: 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
4af9a: 2668 0024 moveal %a0@(36),%a3 4af9e: c481 andl %d1,%d2
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4afa0: b7ca cmpal %a2,%a3
4afa2: 670c beqs 4afb0 <_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;
4afa4: 7201 moveq #1,%d1 4afa6: c2b2 2804 andl %a2@(00000004,%d2:l),%d1
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
4afaa: 5381 subql #1,%d1 4afac: 4481 negl %d1 4afae: 6002 bras 4afb2 <_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 ));
4afb0: 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
4afb2: 1a01 moveb %d1,%d5
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
4afb4: 0803 0000 btst #0,%d3
4afb8: 6662 bnes 4b01c <_Heap_Free+0xf0>
uintptr_t const prev_size = block->prev_size;
4afba: 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);
4afbc: 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;
4afbe: b889 cmpl %a1,%d4
4afc0: 620a bhis 4afcc <_Heap_Free+0xa0> <== NEVER TAKEN
4afc2: b3cb cmpal %a3,%a1 4afc4: 53c1 sls %d1 4afc6: 49c1 extbl %d1 4afc8: 4481 negl %d1 4afca: 6002 bras 4afce <_Heap_Free+0xa2>
4afcc: 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 ) ) {
4afce: 4a01 tstb %d1 4afd0: 6700 00c0 beqw 4b092 <_Heap_Free+0x166>
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;
4afd4: 7201 moveq #1,%d1 4afd6: 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) ) {
4afda: 6700 00b6 beqw 4b092 <_Heap_Free+0x166>
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4afde: 4a05 tstb %d5
4afe0: 6726 beqs 4b008 <_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;
4afe2: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + prev_size + next_block_size;
4afe6: d480 addl %d0,%d2 4afe8: d682 addl %d2,%d3
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4afea: 7401 moveq #1,%d2
Heap_Block *prev = block->prev;
4afec: 246a 000c moveal %a2@(12),%a2
prev->next = next;
4aff0: 254b 0008 movel %a3,%a2@(8) 4aff4: 8483 orl %d3,%d2
next->prev = prev;
4aff6: 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;
4affa: 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;
4affe: 2383 3800 movel %d3,%a1@(00000000,%d3: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;
4b002: 2342 0004 movel %d2,%a1@(4) 4b006: 607a bras 4b082 <_Heap_Free+0x156>
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;
4b008: d680 addl %d0,%d3
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b00a: 7201 moveq #1,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b00c: 74fe moveq #-2,%d2
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;
4b00e: 8283 orl %d3,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
4b010: 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;
4b012: 2341 0004 movel %d1,%a1@(4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b016: c5aa 0004 andl %d2,%a2@(4) 4b01a: 6066 bras 4b082 <_Heap_Free+0x156>
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
4b01c: 4a01 tstb %d1
4b01e: 672a beqs 4b04a <_Heap_Free+0x11e>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
4b020: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + next_block_size;
4b024: 2202 movel %d2,%d1 4b026: d280 addl %d0,%d1
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b028: 7401 moveq #1,%d2
Heap_Block *prev = old_block->prev;
4b02a: 246a 000c moveal %a2@(12),%a2
new_block->next = next;
4b02e: 234b 0008 movel %a3,%a1@(8) 4b032: 8481 orl %d1,%d2
new_block->prev = prev;
4b034: 234a 000c movel %a2,%a1@(12)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4b038: 2381 1800 movel %d1,%a1@(00000000,%d1:l)
next->prev = new_block;
4b03c: 2749 000c movel %a1,%a3@(12)
prev->next = new_block;
4b040: 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;
4b044: 2342 0004 movel %d2,%a1@(4) 4b048: 6038 bras 4b082 <_Heap_Free+0x156>
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;
4b04a: 7201 moveq #1,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b04c: 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;
4b04e: 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;
4b050: 2668 0008 moveal %a0@(8),%a3
new_block->next = next;
new_block->prev = block_before;
4b054: 2348 000c movel %a0,%a1@(12) 4b058: 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;
4b05c: 2228 0038 movel %a0@(56),%d1 4b060: 5281 addql #1,%d1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4b062: 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;
4b066: c5aa 0004 andl %d2,%a2@(4)
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
4b06a: 2749 000c movel %a1,%a3@(12)
next_block->prev_size = block_size;
4b06e: 2480 movel %d0,%a2@
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
4b070: 2149 0008 movel %a1,%a0@(8)
/* Statistics */
++stats->free_blocks;
4b074: 2141 0038 movel %d1,%a0@(56)
if ( stats->max_free_blocks < stats->free_blocks ) {
4b078: b2a8 003c cmpl %a0@(60),%d1
4b07c: 6304 blss 4b082 <_Heap_Free+0x156>
stats->max_free_blocks = stats->free_blocks;
4b07e: 2141 003c movel %d1,%a0@(60)
}
}
/* Statistics */
--stats->used_blocks;
4b082: 53a8 0040 subql #1,%a0@(64)
++stats->frees;
4b086: 52a8 0050 addql #1,%a0@(80)
stats->free_size += block_size;
4b08a: 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;
4b08e: 7001 moveq #1,%d0 4b090: 6002 bras 4b094 <_Heap_Free+0x168>
/* 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 );
4b092: 4200 clrb %d0
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4b094: 4cd7 0c3c moveml %sp@,%d2-%d5/%a2-%a3
4b098: 4e5e unlk %fp <== NOT EXECUTED
0005b188 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
5b188: 4e56 0000 linkw %fp,#0 5b18c: 202e 000c movel %fp@(12),%d0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
5b190: 2040 moveal %d0,%a0 5b192: 5188 subql #8,%a0 5b194: 226e 0008 moveal %fp@(8),%a1 5b198: 2f02 movel %d2,%sp@- 5b19a: 2400 movel %d0,%d2 5b19c: 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
5b1a2: 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);
5b1a6: 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;
5b1a8: b488 cmpl %a0,%d2
5b1aa: 620c bhis 5b1b8 <_Heap_Size_of_alloc_area+0x30>
5b1ac: b1e9 0024 cmpal %a1@(36),%a0 5b1b0: 53c1 sls %d1 5b1b2: 49c1 extbl %d1 5b1b4: 4481 negl %d1 5b1b6: 6002 bras 5b1ba <_Heap_Size_of_alloc_area+0x32> 5b1b8: 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 ) ) {
5b1ba: 4a01 tstb %d1
5b1bc: 6738 beqs 5b1f6 <_Heap_Size_of_alloc_area+0x6e>
- 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;
5b1be: 72fe moveq #-2,%d1 5b1c0: 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);
5b1c4: d1c1 addal %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;
5b1c6: b488 cmpl %a0,%d2
5b1c8: 620c bhis 5b1d6 <_Heap_Size_of_alloc_area+0x4e> <== NEVER TAKEN
5b1ca: b1e9 0024 cmpal %a1@(36),%a0 5b1ce: 53c1 sls %d1 5b1d0: 49c1 extbl %d1 5b1d2: 4481 negl %d1 5b1d4: 6002 bras 5b1d8 <_Heap_Size_of_alloc_area+0x50>
5b1d6: 4281 clrl %d1 <== NOT EXECUTED
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
5b1d8: 4a01 tstb %d1
5b1da: 671a beqs 5b1f6 <_Heap_Size_of_alloc_area+0x6e> <== 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;
5b1dc: 7201 moveq #1,%d1 5b1de: c2a8 0004 andl %a0@(4),%d1
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
5b1e2: 6712 beqs 5b1f6 <_Heap_Size_of_alloc_area+0x6e> <== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
5b1e4: 7204 moveq #4,%d1 5b1e6: 9280 subl %d0,%d1 5b1e8: 2001 movel %d1,%d0 5b1ea: d088 addl %a0,%d0 5b1ec: 226e 0010 moveal %fp@(16),%a1 5b1f0: 2280 movel %d0,%a1@
return true;
5b1f2: 7001 moveq #1,%d0 5b1f4: 6002 bras 5b1f8 <_Heap_Size_of_alloc_area+0x70>
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
5b1f6: 4200 clrb %d0
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
5b1f8: 241f movel %sp@+,%d2 5b1fa: 4e5e unlk %fp
...
00047426 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
47426: 4e56 ffd0 linkw %fp,#-48 4742a: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4742e: 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;
47432: 45fa ffac lea %pc@(473e0 <_Heap_Walk_print_nothing>),%a2
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
47436: 242e 000c movel %fp@(12),%d2
uintptr_t const page_size = heap->page_size;
4743a: 282b 0010 movel %a3@(16),%d4
uintptr_t const min_block_size = heap->min_block_size;
4743e: 2a2b 0014 movel %a3@(20),%d5
Heap_Block *const first_block = heap->first_block;
47442: 2c2b 0020 movel %a3@(32),%d6
Heap_Block *const last_block = heap->last_block;
47446: 2e2b 0024 movel %a3@(36),%d7
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
4744a: 4a2e 0013 tstb %fp@(19)
4744e: 6704 beqs 47454 <_Heap_Walk+0x2e>
47450: 45fa ff96 lea %pc@(473e8 <_Heap_Walk_print>),%a2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
47454: 7003 moveq #3,%d0 47456: b0b9 0006 0ebc cmpl 60ebc <_System_state_Current>,%d0 4745c: 6600 02fc bnew 4775a <_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)(
47460: 2f2b 000c movel %a3@(12),%sp@- 47464: 2f2b 0008 movel %a3@(8),%sp@- 47468: 2f07 movel %d7,%sp@- 4746a: 2f06 movel %d6,%sp@- 4746c: 2f2b 001c movel %a3@(28),%sp@- 47470: 2f2b 0018 movel %a3@(24),%sp@- 47474: 2f05 movel %d5,%sp@- 47476: 2f04 movel %d4,%sp@- 47478: 4879 0005 d139 pea 5d139 <_Status_Object_name_errors_to_status+0x5d> 4747e: 42a7 clrl %sp@- 47480: 2f02 movel %d2,%sp@- 47482: 4e92 jsr %a2@
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
47484: 4fef 002c lea %sp@(44),%sp 47488: 4a84 tstl %d4
4748a: 6608 bnes 47494 <_Heap_Walk+0x6e>
(*printer)( source, true, "page size is zero\n" );
4748c: 4879 0005 d1ca pea 5d1ca <_Status_Object_name_errors_to_status+0xee> 47492: 6050 bras 474e4 <_Heap_Walk+0xbe>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
47494: 7003 moveq #3,%d0 47496: c084 andl %d4,%d0
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
47498: 670c beqs 474a6 <_Heap_Walk+0x80>
(*printer)(
4749a: 2f04 movel %d4,%sp@- 4749c: 4879 0005 d1dd pea 5d1dd <_Status_Object_name_errors_to_status+0x101> 474a2: 6000 02ca braw 4776e <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
474a6: 2205 movel %d5,%d1 474a8: 4c44 1000 remul %d4,%d0,%d1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
474ac: 4a80 tstl %d0
474ae: 670c beqs 474bc <_Heap_Walk+0x96>
(*printer)(
474b0: 2f05 movel %d5,%sp@- 474b2: 4879 0005 d1fb pea 5d1fb <_Status_Object_name_errors_to_status+0x11f> 474b8: 6000 02b4 braw 4776e <_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;
474bc: 2006 movel %d6,%d0 474be: 5080 addql #8,%d0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
474c0: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if (
474c4: 4a81 tstl %d1
474c6: 670c beqs 474d4 <_Heap_Walk+0xae>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
474c8: 2f06 movel %d6,%sp@- 474ca: 4879 0005 d21f pea 5d21f <_Status_Object_name_errors_to_status+0x143> 474d0: 6000 029c braw 4776e <_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;
474d4: 7001 moveq #1,%d0 474d6: 2046 moveal %d6,%a0 474d8: c0a8 0004 andl %a0@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
474dc: 6616 bnes 474f4 <_Heap_Walk+0xce>
(*printer)(
474de: 4879 0005 d250 pea 5d250 <_Status_Object_name_errors_to_status+0x174> 474e4: 4878 0001 pea 1 <ADD> 474e8: 2f02 movel %d2,%sp@- 474ea: 4e92 jsr %a2@ 474ec: 4fef 000c lea %sp@(12),%sp 474f0: 6000 00ba braw 475ac <_Heap_Walk+0x186>
- 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;
474f4: 70fe moveq #-2,%d0 474f6: 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);
474f8: 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;
474fa: 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);
474fe: 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;
47500: 7001 moveq #1,%d0 47502: c0ac 0004 andl %a4@(4),%d0
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
47506: 6608 bnes 47510 <_Heap_Walk+0xea>
(*printer)(
47508: 4879 0005 d27e pea 5d27e <_Status_Object_name_errors_to_status+0x1a2> 4750e: 60d4 bras 474e4 <_Heap_Walk+0xbe>
);
return false;
}
if (
47510: bc8c cmpl %a4,%d6
47512: 6708 beqs 4751c <_Heap_Walk+0xf6>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
47514: 4879 0005 d293 pea 5d293 <_Status_Object_name_errors_to_status+0x1b7> 4751a: 60c8 bras 474e4 <_Heap_Walk+0xbe>
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
4751c: 262b 0010 movel %a3@(16),%d3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
47520: 220b movel %a3,%d1
block = next_block;
} while ( block != first_block );
return true;
}
47522: 206b 0008 moveal %a3@(8),%a0 47526: 2d44 fff8 movel %d4,%fp@(-8) 4752a: 2d43 fffc movel %d3,%fp@(-4) 4752e: 6000 0088 braw 475b8 <_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;
47532: b1eb 0020 cmpal %a3@(32),%a0
47536: 650c bcss 47544 <_Heap_Walk+0x11e>
47538: b1eb 0024 cmpal %a3@(36),%a0 4753c: 53c0 sls %d0 4753e: 49c0 extbl %d0 47540: 4480 negl %d0 47542: 6002 bras 47546 <_Heap_Walk+0x120> 47544: 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 ) ) {
47546: 4a00 tstb %d0
47548: 660c bnes 47556 <_Heap_Walk+0x130>
(*printer)(
4754a: 2f08 movel %a0,%sp@- 4754c: 4879 0005 d2c2 pea 5d2c2 <_Status_Object_name_errors_to_status+0x1e6> 47552: 6000 021a braw 4776e <_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;
47556: 4be8 0008 lea %a0@(8),%a5
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4755a: 200d movel %a5,%d0 4755c: 262e fffc movel %fp@(-4),%d3 47560: 4c43 0004 remul %d3,%d4,%d0
);
return false;
}
if (
47564: 4a84 tstl %d4
47566: 670c beqs 47574 <_Heap_Walk+0x14e>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
47568: 2f08 movel %a0,%sp@- 4756a: 4879 0005 d2e2 pea 5d2e2 <_Status_Object_name_errors_to_status+0x206> 47570: 6000 01fc braw 4776e <_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;
47574: 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;
47576: 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;
47578: 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;
4757c: c6b0 0804 andl %a0@(00000004,%d0:l),%d3
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
47580: 670c beqs 4758e <_Heap_Walk+0x168>
(*printer)(
47582: 2f08 movel %a0,%sp@- 47584: 4879 0005 d312 pea 5d312 <_Status_Object_name_errors_to_status+0x236> 4758a: 6000 01e2 braw 4776e <_Heap_Walk+0x348>
);
return false;
}
if ( free_block->prev != prev_block ) {
4758e: 2028 000c movel %a0@(12),%d0 47592: b280 cmpl %d0,%d1
47594: 671c beqs 475b2 <_Heap_Walk+0x18c>
(*printer)(
47596: 2f00 movel %d0,%sp@- 47598: 2f08 movel %a0,%sp@- 4759a: 4879 0005 d32e pea 5d32e <_Status_Object_name_errors_to_status+0x252> 475a0: 4878 0001 pea 1 <ADD> 475a4: 2f02 movel %d2,%sp@- 475a6: 4e92 jsr %a2@ 475a8: 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;
475ac: 4200 clrb %d0 475ae: 6000 01ac braw 4775c <_Heap_Walk+0x336>
return false;
}
prev_block = free_block;
free_block = free_block->next;
475b2: 2208 movel %a0,%d1 475b4: 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 ) {
475b8: b7c8 cmpal %a0,%a3 475ba: 6600 ff76 bnew 47532 <_Heap_Walk+0x10c> 475be: 282e fff8 movel %fp@(-8),%d4 475c2: 6002 bras 475c6 <_Heap_Walk+0x1a0>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
475c4: 284d moveal %a5,%a4
return true;
}
475c6: 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;
475ca: 76fe moveq #-2,%d3 475cc: c680 andl %d0,%d3 475ce: 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);
475d2: 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;
475d6: bbeb 0020 cmpal %a3@(32),%a5
475da: 650c bcss 475e8 <_Heap_Walk+0x1c2> <== NEVER TAKEN
475dc: bbeb 0024 cmpal %a3@(36),%a5 475e0: 53c0 sls %d0 475e2: 49c0 extbl %d0 475e4: 4480 negl %d0 475e6: 6002 bras 475ea <_Heap_Walk+0x1c4>
475e8: 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 ) ) {
475ea: 4a00 tstb %d0
475ec: 660c bnes 475fa <_Heap_Walk+0x1d4>
(*printer)(
475ee: 2f0d movel %a5,%sp@- 475f0: 2f0c movel %a4,%sp@- 475f2: 4879 0005 d360 pea 5d360 <_Status_Object_name_errors_to_status+0x284> 475f8: 60a6 bras 475a0 <_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;
475fa: be8c cmpl %a4,%d7 475fc: 56c0 sne %d0 475fe: 2200 movel %d0,%d1 47600: 4481 negl %d1
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
47602: 2003 movel %d3,%d0 47604: 1d41 fffb moveb %d1,%fp@(-5) 47608: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
4760c: 4a81 tstl %d1
4760e: 6714 beqs 47624 <_Heap_Walk+0x1fe>
47610: 4a2e fffb tstb %fp@(-5)
47614: 670e beqs 47624 <_Heap_Walk+0x1fe>
(*printer)(
47616: 2f03 movel %d3,%sp@- 47618: 2f0c movel %a4,%sp@- 4761a: 4879 0005 d38d pea 5d38d <_Status_Object_name_errors_to_status+0x2b1> 47620: 6000 ff7e braw 475a0 <_Heap_Walk+0x17a>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
47624: ba83 cmpl %d3,%d5
47626: 6322 blss 4764a <_Heap_Walk+0x224>
47628: 4a2e fffb tstb %fp@(-5)
4762c: 671c beqs 4764a <_Heap_Walk+0x224> <== NEVER TAKEN
(*printer)(
4762e: 2f05 movel %d5,%sp@- 47630: 2f03 movel %d3,%sp@- 47632: 2f0c movel %a4,%sp@- 47634: 4879 0005 d3bb pea 5d3bb <_Status_Object_name_errors_to_status+0x2df> 4763a: 4878 0001 pea 1 <ADD> 4763e: 2f02 movel %d2,%sp@- 47640: 4e92 jsr %a2@
block,
block_size,
min_block_size
);
return false;
47642: 4fef 0018 lea %sp@(24),%sp 47646: 6000 ff64 braw 475ac <_Heap_Walk+0x186>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
4764a: b9cd cmpal %a5,%a4
4764c: 6514 bcss 47662 <_Heap_Walk+0x23c>
4764e: 4a2e fffb tstb %fp@(-5)
47652: 670e beqs 47662 <_Heap_Walk+0x23c>
(*printer)(
47654: 2f0d movel %a5,%sp@- 47656: 2f0c movel %a4,%sp@- 47658: 4879 0005 d3e6 pea 5d3e6 <_Status_Object_name_errors_to_status+0x30a> 4765e: 6000 ff40 braw 475a0 <_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;
47662: 7001 moveq #1,%d0 47664: c0ae fffc andl %fp@(-4),%d0 47668: 2d40 fffc movel %d0,%fp@(-4) 4766c: 7001 moveq #1,%d0 4766e: c0ad 0004 andl %a5@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
47672: 6600 00ae bnew 47722 <_Heap_Walk+0x2fc>
block = next_block;
} while ( block != first_block );
return true;
}
47676: 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)(
4767a: 43f9 0005 d106 lea 5d106 <_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 ?
47680: 206c 0008 moveal %a4@(8),%a0
block = next_block;
} while ( block != first_block );
return true;
}
47684: 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)(
47688: b1eb 000c cmpal %a3@(12),%a0
4768c: 6710 beqs 4769e <_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)" : "")
4768e: 43f9 0005 d04e lea 5d04e <rtems_filesystem_default_pathconf+0xb4>,%a1 47694: b7c8 cmpal %a0,%a3
47696: 6606 bnes 4769e <_Heap_Walk+0x278>
47698: 43f9 0005 d115 lea 5d115 <_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 ?
4769e: 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)(
476a2: 223c 0005 d11f movel #381215,%d1 476a8: b0ae fff8 cmpl %fp@(-8),%d0
476ac: 6710 beqs 476be <_Heap_Walk+0x298>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
476ae: 223c 0005 d04e movel #381006,%d1 476b4: b7c0 cmpal %d0,%a3
476b6: 6606 bnes 476be <_Heap_Walk+0x298>
476b8: 223c 0005 d12f movel #381231,%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)(
476be: 2f09 movel %a1,%sp@- 476c0: 2f08 movel %a0,%sp@- 476c2: 2f01 movel %d1,%sp@- 476c4: 2f00 movel %d0,%sp@- 476c6: 2f03 movel %d3,%sp@- 476c8: 2f0c movel %a4,%sp@- 476ca: 4879 0005 d41a pea 5d41a <_Status_Object_name_errors_to_status+0x33e> 476d0: 42a7 clrl %sp@- 476d2: 2f02 movel %d2,%sp@- 476d4: 4e92 jsr %a2@
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
476d6: 2015 movel %a5@,%d0 476d8: 4fef 0024 lea %sp@(36),%sp 476dc: b083 cmpl %d3,%d0
476de: 671e beqs 476fe <_Heap_Walk+0x2d8>
(*printer)(
476e0: 2f0d movel %a5,%sp@- 476e2: 2f00 movel %d0,%sp@- 476e4: 2f03 movel %d3,%sp@- 476e6: 2f0c movel %a4,%sp@- 476e8: 4879 0005 d44f pea 5d44f <_Status_Object_name_errors_to_status+0x373> 476ee: 4878 0001 pea 1 <ADD> 476f2: 2f02 movel %d2,%sp@- 476f4: 4e92 jsr %a2@ 476f6: 4fef 001c lea %sp@(28),%sp 476fa: 6000 feb0 braw 475ac <_Heap_Walk+0x186>
);
return false;
}
if ( !prev_used ) {
476fe: 4aae fffc tstl %fp@(-4)
47702: 660a bnes 4770e <_Heap_Walk+0x2e8>
(*printer)(
47704: 2f0c movel %a4,%sp@- 47706: 4879 0005 d488 pea 5d488 <_Status_Object_name_errors_to_status+0x3ac> 4770c: 6060 bras 4776e <_Heap_Walk+0x348>
block = next_block;
} while ( block != first_block );
return true;
}
4770e: 206b 0008 moveal %a3@(8),%a0 47712: 6008 bras 4771c <_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 ) {
47714: b9c8 cmpal %a0,%a4
47716: 673c beqs 47754 <_Heap_Walk+0x32e>
return true;
}
free_block = free_block->next;
47718: 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 ) {
4771c: b7c8 cmpal %a0,%a3
4771e: 66f4 bnes 47714 <_Heap_Walk+0x2ee>
47720: 6044 bras 47766 <_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) {
47722: 4aae fffc tstl %fp@(-4)
47726: 6716 beqs 4773e <_Heap_Walk+0x318>
(*printer)(
47728: 2f03 movel %d3,%sp@- 4772a: 2f0c movel %a4,%sp@- 4772c: 4879 0005 d4b7 pea 5d4b7 <_Status_Object_name_errors_to_status+0x3db> 47732: 42a7 clrl %sp@- 47734: 2f02 movel %d2,%sp@- 47736: 4e92 jsr %a2@ 47738: 4fef 0014 lea %sp@(20),%sp 4773c: 6016 bras 47754 <_Heap_Walk+0x32e>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4773e: 2f14 movel %a4@,%sp@- 47740: 2f03 movel %d3,%sp@- 47742: 2f0c movel %a4,%sp@- 47744: 4879 0005 d4ce pea 5d4ce <_Status_Object_name_errors_to_status+0x3f2> 4774a: 42a7 clrl %sp@- 4774c: 2f02 movel %d2,%sp@- 4774e: 4e92 jsr %a2@ 47750: 4fef 0018 lea %sp@(24),%sp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
47754: bc8d cmpl %a5,%d6 47756: 6600 fe6c bnew 475c4 <_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;
4775a: 7001 moveq #1,%d0
block = next_block;
} while ( block != first_block );
return true;
}
4775c: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5 47762: 4e5e unlk %fp 47764: 4e75 rts
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
47766: 2f0c movel %a4,%sp@- 47768: 4879 0005 d4f3 pea 5d4f3 <_Status_Object_name_errors_to_status+0x417> 4776e: 4878 0001 pea 1 <ADD> 47772: 2f02 movel %d2,%sp@- 47774: 4e92 jsr %a2@ 47776: 4fef 0010 lea %sp@(16),%sp 4777a: 6000 fe30 braw 475ac <_Heap_Walk+0x186>
...
000473e8 <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
473e8: 41f9 0004 3de0 lea 43de0 <printk>,%a0 473ee: 4e56 0000 linkw %fp,#0 473f2: 202e 0008 movel %fp@(8),%d0
va_list ap;
if ( error ) {
473f6: 4a2e 000f tstb %fp@(15)
473fa: 670a beqs 47406 <_Heap_Walk_print+0x1e> <== NEVER TAKEN
printk( "FAIL[%d]: ", source );
473fc: 2f00 movel %d0,%sp@- 473fe: 4879 0005 d0f0 pea 5d0f0 <_Status_Object_name_errors_to_status+0x14> 47404: 6008 bras 4740e <_Heap_Walk_print+0x26>
} else {
printk( "PASS[%d]: ", source );
47406: 2f00 movel %d0,%sp@- 47408: 4879 0005 d0fb pea 5d0fb <_Status_Object_name_errors_to_status+0x1f> 4740e: 4e90 jsr %a0@ 47410: 508f addql #8,%sp
}
va_start( ap, fmt );
vprintk( fmt, ap );
47412: 486e 0014 pea %fp@(20) 47416: 2f2e 0010 movel %fp@(16),%sp@- 4741a: 4eb9 0004 56f8 jsr 456f8 <vprintk>
va_end( ap );
47420: 508f addql #8,%sp
}
47422: 4e5e unlk %fp <== NOT EXECUTED
00046a08 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
46a08: 4e56 0000 linkw %fp,#0 46a0c: 222e 000c movel %fp@(12),%d1 46a10: 2f02 movel %d2,%sp@- 46a12: 242e 0010 movel %fp@(16),%d2
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
46a16: 13c1 0005 ea62 moveb %d1,5ea62 <_Internal_errors_What_happened+0x4>
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
46a1c: 2f02 movel %d2,%sp@-
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
46a1e: 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 );
46a22: 0281 0000 00ff andil #255,%d1
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
46a28: 23c0 0005 ea5e movel %d0,5ea5e <_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 );
46a2e: 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;
46a30: 23c2 0005 ea64 movel %d2,5ea64 <_Internal_errors_What_happened+0x6>
_User_extensions_Fatal( the_source, is_internal, the_error );
46a36: 2f00 movel %d0,%sp@- 46a38: 4eb9 0004 860e jsr 4860e <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
46a3e: 7005 moveq #5,%d0 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
46a40: 2042 moveal %d2,%a0 <== NOT EXECUTED 46a42: 243c 0000 0700 movel #1792,%d2 <== NOT EXECUTED 46a48: 23c0 0005 eb14 movel %d0,5eb14 <_System_state_Current> <== NOT EXECUTED 46a4e: 40c0 movew %sr,%d0 <== NOT EXECUTED 46a50: 8082 orl %d2,%d0 <== NOT EXECUTED 46a52: 46c0 movew %d0,%sr <== NOT EXECUTED 46a54: 2008 movel %a0,%d0 <== NOT EXECUTED 46a56: 223c dead beef movel #-559038737,%d1 <== NOT EXECUTED 46a5c: 4ac8 halt <== NOT EXECUTED 46a5e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED 46a62: 60fe bras 46a62 <_Internal_error_Occurred+0x5a> <== NOT EXECUTED
00046ac4 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
46ac4: 4e56 fff0 linkw %fp,#-16 46ac8: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 46acc: 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 )
46ad0: 4aaa 0014 tstl %a2@(20)
46ad4: 675e beqs 46b34 <_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 );
46ad6: 240a movel %a2,%d2 46ad8: 0682 0000 001c addil #28,%d2 46ade: 47f9 0004 6268 lea 46268 <_Chain_Get>,%a3 46ae4: 2f02 movel %d2,%sp@- 46ae6: 4e93 jsr %a3@
if ( information->auto_extend ) {
46ae8: 588f addql #4,%sp 46aea: 4a2a 0010 tstb %a2@(16)
46aee: 6746 beqs 46b36 <_Objects_Allocate+0x72>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
46af0: 4a80 tstl %d0
46af2: 6612 bnes 46b06 <_Objects_Allocate+0x42>
_Objects_Extend_information( information );
46af4: 2f0a movel %a2,%sp@- 46af6: 4eb9 0004 6b6c jsr 46b6c <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
46afc: 2f02 movel %d2,%sp@- 46afe: 4e93 jsr %a3@
}
if ( the_object ) {
46b00: 508f addql #8,%sp 46b02: 4a80 tstl %d0
46b04: 6730 beqs 46b36 <_Objects_Allocate+0x72>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46b06: 2040 moveal %d0,%a0 46b08: 4281 clrl %d1 46b0a: 4282 clrl %d2 46b0c: 3228 000a movew %a0@(10),%d1 46b10: 342a 0008 movew %a2@(8),%d2
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
46b14: 206a 002a moveal %a2@(42),%a0
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46b18: 9282 subl %d2,%d1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
46b1a: 342a 0012 movew %a2@(18),%d2 46b1e: 4c42 1001 remul %d2,%d1,%d1
information->inactive_per_block[ block ]--;
46b22: e589 lsll #2,%d1 46b24: d1c1 addal %d1,%a0 46b26: 5390 subql #1,%a0@
information->inactive--;
46b28: 322a 0028 movew %a2@(40),%d1 46b2c: 5381 subql #1,%d1 46b2e: 3541 0028 movew %d1,%a2@(40) 46b32: 6002 bras 46b36 <_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;
46b34: 4280 clrl %d0 <== NOT EXECUTED
);
}
#endif
return the_object;
}
46b36: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
46b3c: 4e5e unlk %fp <== NOT EXECUTED
00046b40 <_Objects_Close>:
RTEMS_INLINE_ROUTINE void _Objects_Invalidate_Id(
Objects_Information *information,
Objects_Control *the_object
)
{
_Objects_Set_local_object(
46b40: 4280 clrl %d0
void _Objects_Close(
Objects_Information *information,
Objects_Control *the_object
)
{
46b42: 4e56 0000 linkw %fp,#0 46b46: 226e 000c moveal %fp@(12),%a1 46b4a: 206e 0008 moveal %fp@(8),%a0 46b4e: 2f0a movel %a2,%sp@-
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46b50: 2468 0018 moveal %a0@(24),%a2
RTEMS_INLINE_ROUTINE void _Objects_Invalidate_Id(
Objects_Information *information,
Objects_Control *the_object
)
{
_Objects_Set_local_object(
46b54: 3029 000a movew %a1@(10),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46b58: 42b2 0c00 clrl %a2@(00000000,%d0:l:4)
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
}
46b5c: 245f moveal %sp@+,%a2
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
46b5e: 2d49 000c movel %a1,%fp@(12)
}
46b62: 4e5e unlk %fp
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
46b64: 4ef9 0004 7074 jmp 47074 <_Objects_Namespace_remove>
...
00046e64 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
46e64: 4e56 0000 linkw %fp,#0 46e68: 2f03 movel %d3,%sp@- 46e6a: 362e 000e movew %fp@(14),%d3 46e6e: 2f02 movel %d2,%sp@- 46e70: 242e 0008 movel %fp@(8),%d2
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
46e74: 4a43 tstw %d3
46e76: 673a beqs 46eb2 <_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 );
46e78: 2f02 movel %d2,%sp@- 46e7a: 4eb9 0004 b09c jsr 4b09c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
46e80: 588f addql #4,%sp 46e82: 4a80 tstl %d0
46e84: 672c beqs 46eb2 <_Objects_Get_information+0x4e>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
46e86: 0283 0000 ffff andil #65535,%d3 46e8c: b083 cmpl %d3,%d0
46e8e: 6522 bcss 46eb2 <_Objects_Get_information+0x4e>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
46e90: 41f9 0005 e984 lea 5e984 <_Objects_Information_table>,%a0 46e96: 2070 2c00 moveal %a0@(00000000,%d2:l:4),%a0 46e9a: 4a88 tstl %a0
46e9c: 6714 beqs 46eb2 <_Objects_Get_information+0x4e> <== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
46e9e: 2030 3c00 movel %a0@(00000000,%d3:l:4),%d0
if ( !info )
46ea2: 6710 beqs 46eb4 <_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;
46ea4: 2040 moveal %d0,%a0 46ea6: 4a68 000e tstw %a0@(14) 46eaa: 56c1 sne %d1 46eac: 49c1 extbl %d1 46eae: c081 andl %d1,%d0 46eb0: 6002 bras 46eb4 <_Objects_Get_information+0x50>
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
return NULL;
46eb2: 4280 clrl %d0
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
46eb4: 242e fff8 movel %fp@(-8),%d2 46eb8: 262e fffc movel %fp@(-4),%d3
46ebc: 4e5e unlk %fp <== NOT EXECUTED
0005468c <_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;
5468c: 7001 moveq #1,%d0
if ( information->maximum >= index ) {
5468e: 4281 clrl %d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
54690: 4e56 0000 linkw %fp,#0 54694: 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;
54698: 90a8 0006 subl %a0@(6),%d0 5469c: d0ae 000c addl %fp@(12),%d0
if ( information->maximum >= index ) {
546a0: 3228 000e movew %a0@(14),%d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
546a4: 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 ) {
546a8: b081 cmpl %d1,%d0
546aa: 620e bhis 546ba <_Objects_Get_no_protection+0x2e>
if ( (the_object = information->local_table[ index ]) != NULL ) {
546ac: 2068 0018 moveal %a0@(24),%a0 546b0: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
546b4: 6704 beqs 546ba <_Objects_Get_no_protection+0x2e><== NEVER TAKEN
*location = OBJECTS_LOCAL;
546b6: 4291 clrl %a1@
return the_object;
546b8: 6006 bras 546c0 <_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;
546ba: 7001 moveq #1,%d0 546bc: 2280 movel %d0,%a1@
return NULL;
546be: 4280 clrl %d0
}
546c0: 4e5e unlk %fp <== NOT EXECUTED
00047e44 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
47e44: 4e56 fffc linkw %fp,#-4 47e48: 222e 0008 movel %fp@(8),%d1 47e4c: 2f02 movel %d2,%sp@-
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
47e4e: 4a81 tstl %d1
47e50: 660a bnes 47e5c <_Objects_Id_to_name+0x18>
47e52: 2079 0006 02ea moveal 602ea <_Per_CPU_Information+0xc>,%a0 47e58: 2228 0008 movel %a0@(8),%d1 47e5c: 7418 moveq #24,%d2 47e5e: 2001 movel %d1,%d0 47e60: e4a8 lsrl %d2,%d0 47e62: 143c 0007 moveb #7,%d2 47e66: c082 andl %d2,%d0
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47e68: 143c 0002 moveb #2,%d2 47e6c: 2040 moveal %d0,%a0 47e6e: 5388 subql #1,%a0 47e70: b488 cmpl %a0,%d2
47e72: 6540 bcss 47eb4 <_Objects_Id_to_name+0x70>
47e74: 6048 bras 47ebe <_Objects_Id_to_name+0x7a>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
47e76: 2001 movel %d1,%d0 47e78: 741b moveq #27,%d2 47e7a: 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 ];
47e7c: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
if ( !information )
47e80: 4a88 tstl %a0
47e82: 6730 beqs 47eb4 <_Objects_Id_to_name+0x70> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
47e84: 4a28 0032 tstb %a0@(50)
47e88: 662a bnes 47eb4 <_Objects_Id_to_name+0x70> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
47e8a: 486e fffc pea %fp@(-4) 47e8e: 2f01 movel %d1,%sp@- 47e90: 2f08 movel %a0,%sp@- 47e92: 4eb9 0004 7de4 jsr 47de4 <_Objects_Get>
if ( !the_object )
47e98: 4fef 000c lea %sp@(12),%sp 47e9c: 4a80 tstl %d0
47e9e: 6714 beqs 47eb4 <_Objects_Id_to_name+0x70>
return OBJECTS_INVALID_ID;
*name = the_object->name;
47ea0: 206e 000c moveal %fp@(12),%a0 47ea4: 2240 moveal %d0,%a1 47ea6: 20a9 000c movel %a1@(12),%a0@
_Thread_Enable_dispatch();
47eaa: 4eb9 0004 8a1a jsr 48a1a <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
47eb0: 4280 clrl %d0 47eb2: 6002 bras 47eb6 <_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;
47eb4: 7003 moveq #3,%d0
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
47eb6: 242e fff8 movel %fp@(-8),%d2 47eba: 4e5e unlk %fp 47ebc: 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 ] )
47ebe: 41f9 0005 fe3c lea 5fe3c <_Objects_Information_table>,%a0 47ec4: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0 47ec8: 4a88 tstl %a0
47eca: 66aa bnes 47e76 <_Objects_Id_to_name+0x32>
47ecc: 60e6 bras 47eb4 <_Objects_Id_to_name+0x70>
...
0004748c <_Objects_Set_name>:
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
4748c: 4280 clrl %d0
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
4748e: 4e56 ffec linkw %fp,#-20 47492: 48d7 3c04 moveml %d2/%a2-%a5,%sp@ 47496: 2a6e 0008 moveal %fp@(8),%a5
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
4749a: 302d 0034 movew %a5@(52),%d0
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
4749e: 246e 0010 moveal %fp@(16),%a2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
474a2: 2f00 movel %d0,%sp@-
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
474a4: 286e 000c moveal %fp@(12),%a4
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
474a8: 2f0a movel %a2,%sp@- 474aa: 4eb9 0004 e69c jsr 4e69c <strnlen>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
474b0: 508f addql #8,%sp
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
474b2: 2640 moveal %d0,%a3
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
474b4: 4a2d 0032 tstb %a5@(50)
474b8: 673c beqs 474f6 <_Objects_Set_name+0x6a>
char *d;
d = _Workspace_Allocate( length + 1 );
474ba: 486b 0001 pea %a3@(1) 474be: 4eb9 0004 8e18 jsr 48e18 <_Workspace_Allocate>
if ( !d )
474c4: 588f addql #4,%sp
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
474c6: 2a40 moveal %d0,%a5
if ( !d )
474c8: 4a80 tstl %d0
474ca: 677a beqs 47546 <_Objects_Set_name+0xba> <== NEVER TAKEN
return false;
_Workspace_Free( (void *)the_object->name.name_p );
474cc: 2f2c 000c movel %a4@(12),%sp@- 474d0: 4eb9 0004 8e34 jsr 48e34 <_Workspace_Free>
the_object->name.name_p = NULL;
474d6: 42ac 000c clrl %a4@(12)
strncpy( d, name, length );
474da: 2f0b movel %a3,%sp@- 474dc: 2f0a movel %a2,%sp@- 474de: 2f0d movel %a5,%sp@- 474e0: 4eb9 0004 e618 jsr 4e618 <strncpy>
d[length] = '\0';
the_object->name.name_p = d;
474e6: 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';
474ea: 4200 clrb %d0 474ec: 1b80 b800 moveb %d0,%a5@(00000000,%a3:l)
the_object->name.name_p = d;
474f0: 294d 000c movel %a5,%a4@(12) 474f4: 604c bras 47542 <_Objects_Set_name+0xb6>
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
474f6: 7418 moveq #24,%d2 474f8: 1212 moveb %a2@,%d1 474fa: 7020 moveq #32,%d0 474fc: 4840 swap %d0 474fe: 49c1 extbl %d1 47500: e5a9 lsll %d2,%d1 47502: 143c 0001 moveb #1,%d2 47506: b48b cmpl %a3,%d2
47508: 640a bccs 47514 <_Objects_Set_name+0x88>
4750a: 102a 0001 moveb %a2@(1),%d0 4750e: 49c0 extbl %d0 47510: 4840 swap %d0 47512: 4240 clrw %d0 47514: 7402 moveq #2,%d2 47516: 8280 orl %d0,%d1 47518: 203c 0000 2000 movel #8192,%d0 4751e: b48b cmpl %a3,%d2
47520: 6408 bccs 4752a <_Objects_Set_name+0x9e>
47522: 102a 0002 moveb %a2@(2),%d0 47526: 49c0 extbl %d0 47528: e188 lsll #8,%d0 4752a: 8081 orl %d1,%d0 4752c: 7203 moveq #3,%d1 4752e: b28b cmpl %a3,%d1
47530: 6408 bccs 4753a <_Objects_Set_name+0xae>
47532: 142a 0003 moveb %a2@(3),%d2 47536: 49c2 extbl %d2 47538: 6002 bras 4753c <_Objects_Set_name+0xb0> 4753a: 7420 moveq #32,%d2 4753c: 8082 orl %d2,%d0 4753e: 2940 000c movel %d0,%a4@(12)
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
47542: 7001 moveq #1,%d0 47544: 6002 bras 47548 <_Objects_Set_name+0xbc>
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
47546: 4200 clrb %d0
);
}
return true;
}
47548: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5 4754e: 4e5e unlk %fp
...
00045924 <_POSIX_Keys_Free_memory>:
#include <rtems/posix/key.h>
void _POSIX_Keys_Free_memory(
POSIX_Keys_Control *the_key
)
{
45924: 4e56 0000 linkw %fp,#0 45928: 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 ] );
4592a: 47f9 0004 983c lea 4983c <_Workspace_Free>,%a3
#include <rtems/posix/key.h>
void _POSIX_Keys_Free_memory(
POSIX_Keys_Control *the_key
)
{
45930: 2f0a movel %a2,%sp@- 45932: 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 ] );
45936: 2f2a 0018 movel %a2@(24),%sp@- 4593a: 4e93 jsr %a3@ 4593c: 2f2a 001c movel %a2@(28),%sp@- 45940: 4e93 jsr %a3@ 45942: 2d6a 0020 0008 movel %a2@(32),%fp@(8) 45948: 508f addql #8,%sp
}
4594a: 246e fff8 moveal %fp@(-8),%a2 4594e: 266e fffc moveal %fp@(-4),%a3 45952: 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 ] );
45954: 4ef9 0004 983c jmp 4983c <_Workspace_Free>
...
00049bc4 <_POSIX_Message_queue_Delete>:
*/
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq
)
{
49bc4: 4e56 0000 linkw %fp,#0 49bc8: 2f0a movel %a2,%sp@- 49bca: 246e 0008 moveal %fp@(8),%a2
if ( !the_mq->linked && !the_mq->open_count ) {
49bce: 4a2a 0015 tstb %a2@(21)
49bd2: 6636 bnes 49c0a <_POSIX_Message_queue_Delete+0x46><== NEVER TAKEN
49bd4: 4aaa 0016 tstl %a2@(22)
49bd8: 6630 bnes 49c0a <_POSIX_Message_queue_Delete+0x46>
);
_Workspace_Free( (void *)the_object->name.name_p );
}
#endif
_Objects_Close( &_POSIX_Message_queue_Information, the_object );
49bda: 2f0a movel %a2,%sp@- 49bdc: 4879 0006 6e8e pea 66e8e <_POSIX_Message_queue_Information> 49be2: 4eb9 0004 c8a4 jsr 4c8a4 <_Objects_Close>
_CORE_message_queue_Close(
49be8: 4878 0005 pea 5 <COMPARE> 49bec: 42a7 clrl %sp@- 49bee: 486a 001a pea %a2@(26) 49bf2: 4eb9 0004 bcfc jsr 4bcfc <_CORE_message_queue_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
49bf8: 2f0a movel %a2,%sp@- 49bfa: 4879 0006 6e8e pea 66e8e <_POSIX_Message_queue_Information> 49c00: 4eb9 0004 cb18 jsr 4cb18 <_Objects_Free> 49c06: 4fef 001c lea %sp@(28),%sp
);
_POSIX_Message_queue_Free( the_mq );
}
}
49c0a: 246e fffc moveal %fp@(-4),%a2 49c0e: 4e5e unlk %fp
...
00049f00 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
49f00: 4e56 ffe4 linkw %fp,#-28 49f04: 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(
49f08: 486e fffc pea %fp@(-4) 49f0c: 242e 0008 movel %fp@(8),%d2 49f10: 2f02 movel %d2,%sp@- 49f12: 4879 0006 6ffc pea 66ffc <_POSIX_Message_queue_Information_fds> 49f18: 162e 001b moveb %fp@(27),%d3 49f1c: 4eb9 0004 cc7c jsr 4cc7c <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
49f22: 4fef 000c lea %sp@(12),%sp 49f26: 4aae fffc tstl %fp@(-4) 49f2a: 6600 00c0 bnew 49fec <_POSIX_Message_queue_Receive_support+0xec>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
49f2e: 2040 moveal %d0,%a0 49f30: 7803 moveq #3,%d4 49f32: 7a01 moveq #1,%d5 49f34: 2228 0014 movel %a0@(20),%d1 49f38: c881 andl %d1,%d4 49f3a: ba84 cmpl %d4,%d5
49f3c: 660a bnes 49f48 <_POSIX_Message_queue_Receive_support+0x48>
_Thread_Enable_dispatch();
49f3e: 4eb9 0004 d832 jsr 4d832 <_Thread_Enable_dispatch> 49f44: 6000 00a6 braw 49fec <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
49f48: 2240 moveal %d0,%a1 49f4a: 2069 0010 moveal %a1@(16),%a0
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
49f4e: 2028 0066 movel %a0@(102),%d0 49f52: b0ae 0010 cmpl %fp@(16),%d0
49f56: 6316 blss 49f6e <_POSIX_Message_queue_Receive_support+0x6e>
_Thread_Enable_dispatch();
49f58: 4eb9 0004 d832 jsr 4d832 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
49f5e: 4eb9 0005 2f48 jsr 52f48 <__errno> 49f64: 727a moveq #122,%d1 49f66: 2040 moveal %d0,%a0 49f68: 2081 movel %d1,%a0@ 49f6a: 6000 008c braw 49ff8 <_POSIX_Message_queue_Receive_support+0xf8>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
49f6e: 70ff moveq #-1,%d0 49f70: 2d40 fff8 movel %d0,%fp@(-8)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
49f74: 4a03 tstb %d3
49f76: 670a beqs 49f82 <_POSIX_Message_queue_Receive_support+0x82><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
49f78: 0801 000e btst #14,%d1 49f7c: 57c0 seq %d0 49f7e: 4480 negl %d0 49f80: 6002 bras 49f84 <_POSIX_Message_queue_Receive_support+0x84>
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
49f82: 4200 clrb %d0 <== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
49f84: 2f2e 001c movel %fp@(28),%sp@- 49f88: 0280 0000 00ff andil #255,%d0 49f8e: 2f00 movel %d0,%sp@- 49f90: 486e fff8 pea %fp@(-8) 49f94: 2f2e 000c movel %fp@(12),%sp@- 49f98: 2f02 movel %d2,%sp@- 49f9a: 4868 001a pea %a0@(26) 49f9e: 4eb9 0004 bd98 jsr 4bd98 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
49fa4: 4eb9 0004 d832 jsr 4d832 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
49faa: 2079 0006 706e moveal 6706e <_Per_CPU_Information+0xc>,%a0
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);
49fb0: 2028 0024 movel %a0@(36),%d0
49fb4: 6c02 bges 49fb8 <_POSIX_Message_queue_Receive_support+0xb8>
49fb6: 4480 negl %d0
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
49fb8: 226e 0014 moveal %fp@(20),%a1
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
49fbc: 4fef 0018 lea %sp@(24),%sp
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
49fc0: 2280 movel %d0,%a1@
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
49fc2: 4aa8 0034 tstl %a0@(52)
49fc6: 6606 bnes 49fce <_POSIX_Message_queue_Receive_support+0xce>
return length_out;
49fc8: 202e fff8 movel %fp@(-8),%d0 49fcc: 602c bras 49ffa <_POSIX_Message_queue_Receive_support+0xfa>
rtems_set_errno_and_return_minus_one(
49fce: 4eb9 0005 2f48 jsr 52f48 <__errno> 49fd4: 2079 0006 706e moveal 6706e <_Per_CPU_Information+0xc>,%a0 49fda: 2440 moveal %d0,%a2 49fdc: 2f28 0034 movel %a0@(52),%sp@- 49fe0: 4eb9 0004 a214 jsr 4a214 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 49fe6: 588f addql #4,%sp 49fe8: 2480 movel %d0,%a2@ 49fea: 600c bras 49ff8 <_POSIX_Message_queue_Receive_support+0xf8>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
49fec: 4eb9 0005 2f48 jsr 52f48 <__errno> 49ff2: 2040 moveal %d0,%a0 49ff4: 7009 moveq #9,%d0 49ff6: 2080 movel %d0,%a0@ 49ff8: 70ff moveq #-1,%d0
}
49ffa: 4cee 043c ffe4 moveml %fp@(-28),%d2-%d5/%a2
4a000: 4e5e unlk %fp <== NOT EXECUTED
0004a280 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
4a280: 4e56 0000 linkw %fp,#0 4a284: 226e 0008 moveal %fp@(8),%a1
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a288: 2069 0102 moveal %a1@(258),%a0
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4a28c: 4aa8 00d8 tstl %a0@(216)
4a290: 662e bnes 4a2c0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40><== NEVER TAKEN
4a292: 7001 moveq #1,%d0 4a294: b0a8 00dc cmpl %a0@(220),%d0
4a298: 6626 bnes 4a2c0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
4a29a: 4aa8 00e0 tstl %a0@(224)
4a29e: 6720 beqs 4a2c0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
4a2a0: 4878 ffff pea ffffffff <LESS>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
4a2a4: 2039 0005 f03c movel 5f03c <_Thread_Dispatch_disable_level>,%d0 4a2aa: 5380 subql #1,%d0 4a2ac: 2f09 movel %a1,%sp@- 4a2ae: 23c0 0005 f03c movel %d0,5f03c <_Thread_Dispatch_disable_level> 4a2b4: 4eb9 0004 aa58 jsr 4aa58 <_POSIX_Thread_Exit> 4a2ba: 508f addql #8,%sp
} else
_Thread_Enable_dispatch();
}
4a2bc: 4e5e unlk %fp 4a2be: 4e75 rts 4a2c0: 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();
4a2c2: 4ef9 0004 7dde jmp 47dde <_Thread_Enable_dispatch>
0004b4d4 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4b4d4: 4e56 ffec linkw %fp,#-20 4b4d8: 48d7 3c04 moveml %d2/%a2-%a5,%sp@ 4b4dc: 246e 000c moveal %fp@(12),%a2
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4b4e0: 2f12 movel %a2@,%sp@-
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4b4e2: 242e 0008 movel %fp@(8),%d2 4b4e6: 266e 0010 moveal %fp@(16),%a3 4b4ea: 286e 0014 moveal %fp@(20),%a4
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4b4ee: 4eb9 0004 b4b0 jsr 4b4b0 <_POSIX_Priority_Is_valid> 4b4f4: 588f addql #4,%sp 4b4f6: 4a00 tstb %d0
4b4f8: 6778 beqs 4b572 <_POSIX_Thread_Translate_sched_param+0x9e><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4b4fa: 4293 clrl %a3@
*budget_callout = NULL;
4b4fc: 4294 clrl %a4@
if ( policy == SCHED_OTHER ) {
4b4fe: 4a82 tstl %d2
4b500: 6606 bnes 4b508 <_POSIX_Thread_Translate_sched_param+0x34>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4b502: 7201 moveq #1,%d1 4b504: 2681 movel %d1,%a3@ 4b506: 6066 bras 4b56e <_POSIX_Thread_Translate_sched_param+0x9a>
return 0;
}
if ( policy == SCHED_FIFO ) {
4b508: 7001 moveq #1,%d0 4b50a: b082 cmpl %d2,%d0
4b50c: 6760 beqs 4b56e <_POSIX_Thread_Translate_sched_param+0x9a>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4b50e: 103c 0002 moveb #2,%d0 4b512: b082 cmpl %d2,%d0
4b514: 6606 bnes 4b51c <_POSIX_Thread_Translate_sched_param+0x48>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4b516: 2680 movel %d0,%a3@
return 0;
4b518: 4200 clrb %d0 4b51a: 6058 bras 4b574 <_POSIX_Thread_Translate_sched_param+0xa0>
}
if ( policy == SCHED_SPORADIC ) {
4b51c: 7004 moveq #4,%d0 4b51e: b082 cmpl %d2,%d0
4b520: 6650 bnes 4b572 <_POSIX_Thread_Translate_sched_param+0x9e>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4b522: 4aaa 0008 tstl %a2@(8)
4b526: 6606 bnes 4b52e <_POSIX_Thread_Translate_sched_param+0x5a>
4b528: 4aaa 000c tstl %a2@(12)
4b52c: 6744 beqs 4b572 <_POSIX_Thread_Translate_sched_param+0x9e>
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
4b52e: 4aaa 0010 tstl %a2@(16)
4b532: 6606 bnes 4b53a <_POSIX_Thread_Translate_sched_param+0x66>
4b534: 4aaa 0014 tstl %a2@(20)
4b538: 6738 beqs 4b572 <_POSIX_Thread_Translate_sched_param+0x9e>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4b53a: 486a 0008 pea %a2@(8) 4b53e: 4bf9 0004 93cc lea 493cc <_Timespec_To_ticks>,%a5 4b544: 4e95 jsr %a5@
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4b546: 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 ) <
4b54a: 2400 movel %d0,%d2
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4b54c: 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 ) <
4b54e: 508f addql #8,%sp 4b550: b082 cmpl %d2,%d0
4b552: 621e bhis 4b572 <_POSIX_Thread_Translate_sched_param+0x9e>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
4b554: 2f2a 0004 movel %a2@(4),%sp@- 4b558: 4eb9 0004 b4b0 jsr 4b4b0 <_POSIX_Priority_Is_valid> 4b55e: 588f addql #4,%sp 4b560: 4a00 tstb %d0
4b562: 670e beqs 4b572 <_POSIX_Thread_Translate_sched_param+0x9e>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4b564: 7003 moveq #3,%d0 4b566: 2680 movel %d0,%a3@
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4b568: 28bc 0004 5edc movel #286428,%a4@
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
4b56e: 4280 clrl %d0 4b570: 6002 bras 4b574 <_POSIX_Thread_Translate_sched_param+0xa0>
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;
4b572: 7016 moveq #22,%d0
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
4b574: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5 4b57a: 4e5e unlk %fp
...
00045c0c <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
45c0c: 4e56 ff98 linkw %fp,#-104 45c10: 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;
45c14: 2479 0005 e11e moveal 5e11e <Configuration_POSIX_API+0x34>,%a2
maximum = Configuration_POSIX_API.number_of_initialization_threads;
45c1a: 2839 0005 e11a movel 5e11a <Configuration_POSIX_API+0x30>,%d4
if ( !user_threads || maximum == 0 )
45c20: 4a8a tstl %a2
45c22: 676a beqs 45c8e <_POSIX_Threads_Initialize_user_threads_body+0x82><== NEVER TAKEN
45c24: 4a84 tstl %d4
45c26: 6766 beqs 45c8e <_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 );
45c28: 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(
45c2a: 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 )
45c2c: 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 );
45c2e: 0682 ffff ffbc addil #-68,%d2 45c34: 2c3c 0004 b580 movel #308608,%d6
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
45c3a: 4bf9 0004 b5ac lea 4b5ac <pthread_attr_setinheritsched>,%a5
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
45c40: 49f9 0004 b5e4 lea 4b5e4 <pthread_attr_setstacksize>,%a4
status = pthread_create(
45c46: 5985 subql #4,%d5 45c48: 47f9 0004 5960 lea 45960 <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 );
45c4e: 2f02 movel %d2,%sp@- 45c50: 2046 moveal %d6,%a0 45c52: 4e90 jsr %a0@
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
45c54: 4878 0002 pea 2 <DOUBLE_FLOAT> 45c58: 2f02 movel %d2,%sp@- 45c5a: 4e95 jsr %a5@
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
45c5c: 2f2a 0004 movel %a2@(4),%sp@- 45c60: 2f02 movel %d2,%sp@- 45c62: 4e94 jsr %a4@
status = pthread_create(
45c64: 42a7 clrl %sp@- 45c66: 2f12 movel %a2@,%sp@- 45c68: 2f02 movel %d2,%sp@- 45c6a: 2f05 movel %d5,%sp@- 45c6c: 4e93 jsr %a3@
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
45c6e: 4fef 0024 lea %sp@(36),%sp 45c72: 4a80 tstl %d0
45c74: 6710 beqs 45c86 <_POSIX_Threads_Initialize_user_threads_body+0x7a>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
45c76: 2f00 movel %d0,%sp@- 45c78: 4878 0001 pea 1 <ADD> 45c7c: 4878 0002 pea 2 <DOUBLE_FLOAT> 45c80: 4eb9 0004 7924 jsr 47924 <_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++ ) {
45c86: 5283 addql #1,%d3 45c88: 508a addql #8,%a2 45c8a: b883 cmpl %d3,%d4
45c8c: 62c0 bhis 45c4e <_POSIX_Threads_Initialize_user_threads_body+0x42><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
45c8e: 4cee 3c7c ff98 moveml %fp@(-104),%d2-%d6/%a2-%a5
45c94: 4e5e unlk %fp <== NOT EXECUTED
0004a618 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
4a618: 4e56 0000 linkw %fp,#0 4a61c: 2f0b movel %a3,%sp@- 4a61e: 2f0a movel %a2,%sp@- 4a620: 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 ];
4a624: 266a 0102 moveal %a2@(258),%a3
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
4a628: 486b 0098 pea %a3@(152) 4a62c: 4eb9 0004 b388 jsr 4b388 <_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 ) {
4a632: 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;
4a634: 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);
4a638: 4280 clrl %d0 4a63a: 1039 0005 d0d2 moveb 5d0d2 <rtems_maximum_priority>,%d0 4a640: 90ab 0088 subl %a3@(136),%d0
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
4a644: 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 ) {
4a648: 4aaa 001c tstl %a2@(28)
4a64c: 6618 bnes 4a666 <_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 ) {
4a64e: b0aa 0014 cmpl %a2@(20),%d0
4a652: 6412 bccs 4a666 <_POSIX_Threads_Sporadic_budget_TSR+0x4e>
_Thread_Change_priority( the_thread, new_priority, true );
4a654: 4878 0001 pea 1 <ADD> 4a658: 2f00 movel %d0,%sp@- 4a65a: 2f0a movel %a2,%sp@- 4a65c: 4eb9 0004 76a4 jsr 476a4 <_Thread_Change_priority> 4a662: 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 );
4a666: 486b 0090 pea %a3@(144) 4a66a: 4eb9 0004 b388 jsr 4b388 <_Timespec_To_ticks>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
4a670: 246e fff8 moveal %fp@(-8),%a2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4a674: 588f addql #4,%sp
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4a676: 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 );
4a67a: 47eb 00a8 lea %a3@(168),%a3
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4a67e: 203c 0005 ea88 movel #387720,%d0 4a684: 2d4b 000c movel %a3,%fp@(12)
}
4a688: 266e fffc moveal %fp@(-4),%a3 4a68c: 2d40 0008 movel %d0,%fp@(8) 4a690: 4e5e unlk %fp 4a692: 4ef9 0004 8758 jmp 48758 <_Watchdog_Insert>
0004a698 <_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 */
4a698: 70ff moveq #-1,%d0
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
4a69a: 4e56 0000 linkw %fp,#0 4a69e: 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 */
4a6a2: 2140 0076 movel %d0,%a0@(118) 4a6a6: 4280 clrl %d0 4a6a8: 1039 0005 d0d2 moveb 5d0d2 <rtems_maximum_priority>,%d0
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a6ae: 2268 0102 moveal %a0@(258),%a1 4a6b2: 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;
4a6b6: 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 ) {
4a6ba: 4aa8 001c tstl %a0@(28)
4a6be: 6618 bnes 4a6d8 <_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 ) {
4a6c0: b0a8 0014 cmpl %a0@(20),%d0
4a6c4: 6312 blss 4a6d8 <_POSIX_Threads_Sporadic_budget_callout+0x40><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
4a6c6: 4878 0001 pea 1 <ADD> 4a6ca: 2f00 movel %d0,%sp@- 4a6cc: 2f08 movel %a0,%sp@- 4a6ce: 4eb9 0004 76a4 jsr 476a4 <_Thread_Change_priority> 4a6d4: 4fef 000c lea %sp@(12),%sp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
4a6d8: 4e5e unlk %fp <== NOT EXECUTED
00045794 <_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)
{
45794: 4e56 0000 linkw %fp,#0 45798: 2f0a movel %a2,%sp@- 4579a: 246e 000c moveal %fp@(12),%a2
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
4579e: 52aa 0066 addql #1,%a2@(102)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
457a2: 4aaa 0052 tstl %a2@(82)
457a6: 6606 bnes 457ae <_POSIX_Timer_TSR+0x1a>
457a8: 4aaa 0056 tstl %a2@(86)
457ac: 6736 beqs 457e4 <_POSIX_Timer_TSR+0x50> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
457ae: 2f0a movel %a2,%sp@- 457b0: 4879 0004 5794 pea 45794 <_POSIX_Timer_TSR> 457b6: 2f2a 0008 movel %a2@(8),%sp@- 457ba: 2f2a 0062 movel %a2@(98),%sp@- 457be: 486a 0010 pea %a2@(16) 457c2: 4eb9 0004 af80 jsr 4af80 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
457c8: 4fef 0014 lea %sp@(20),%sp 457cc: 4a00 tstb %d0
457ce: 672e beqs 457fe <_POSIX_Timer_TSR+0x6a> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
457d0: 486a 006a pea %a2@(106) 457d4: 4eb9 0004 6cc4 jsr 46cc4 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
457da: 588f addql #4,%sp 457dc: 7003 moveq #3,%d0 457de: 1540 003c moveb %d0,%a2@(60) 457e2: 6006 bras 457ea <_POSIX_Timer_TSR+0x56>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
457e4: 7004 moveq #4,%d0 <== NOT EXECUTED 457e6: 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 ) ) {
457ea: 2f2a 0042 movel %a2@(66),%sp@- 457ee: 2f2a 0038 movel %a2@(56),%sp@- 457f2: 4eb9 0004 ab74 jsr 4ab74 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
457f8: 508f addql #8,%sp 457fa: 42aa 0066 clrl %a2@(102)
}
457fe: 246e fffc moveal %fp@(-4),%a2 45802: 4e5e unlk %fp
...
0004c3f4 <_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,
4c3f4: 4280 clrl %d0
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c3f6: 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,
4c3fa: 102e 0013 moveb %fp@(19),%d0
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c3fe: 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,
4c402: 4878 0001 pea 1 <ADD> 4c406: 2a0e movel %fp,%d5 4c408: 0685 ffff fff4 addil #-12,%d5 4c40e: 2f00 movel %d0,%sp@-
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c410: 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,
4c414: 2f05 movel %d5,%sp@-
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c416: 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,
4c41a: 2f02 movel %d2,%sp@- 4c41c: 2f0a movel %a2,%sp@- 4c41e: 4eb9 0004 c4cc jsr 4c4cc <_POSIX_signals_Clear_signals> 4c424: 4fef 0014 lea %sp@(20),%sp 4c428: 4a00 tstb %d0 4c42a: 6700 0092 beqw 4c4be <_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 )
4c42e: 2002 movel %d2,%d0 4c430: 2602 movel %d2,%d3 4c432: e588 lsll #2,%d0 4c434: e98b lsll #4,%d3 4c436: 9680 subl %d0,%d3 4c438: 2043 moveal %d3,%a0 4c43a: d1fc 0005 ee64 addal #388708,%a0 4c440: 7001 moveq #1,%d0 4c442: 2668 0008 moveal %a0@(8),%a3 4c446: b08b cmpl %a3,%d0
4c448: 6774 beqs 4c4be <_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;
4c44a: 2028 0004 movel %a0@(4),%d0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
4c44e: 282a 00d0 movel %a2@(208),%d4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4c452: 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,
4c454: 2079 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a0 4c45a: 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;
4c45e: 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,
4c462: 4878 0028 pea 28 <OPER2+0x14> 4c466: 2f08 movel %a0,%sp@- 4c468: 486e ffcc pea %fp@(-52) 4c46c: 4eb9 0004 d37c jsr 4d37c <memcpy>
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
4c472: 4fef 000c lea %sp@(12),%sp 4c476: 41f9 0005 ee64 lea 5ee64 <_POSIX_signals_Vectors>,%a0 4c47c: 7002 moveq #2,%d0 4c47e: b0b0 3800 cmpl %a0@(00000000,%d3:l),%d0
4c482: 660e bnes 4c492 <_POSIX_signals_Check_signal+0x9e>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
4c484: 42a7 clrl %sp@- 4c486: 2f05 movel %d5,%sp@- 4c488: 2f02 movel %d2,%sp@- 4c48a: 4e93 jsr %a3@
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
4c48c: 4fef 000c lea %sp@(12),%sp 4c490: 6006 bras 4c498 <_POSIX_signals_Check_signal+0xa4>
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
4c492: 2f02 movel %d2,%sp@- 4c494: 4e93 jsr %a3@
break;
4c496: 588f addql #4,%sp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
4c498: 4878 0028 pea 28 <OPER2+0x14> 4c49c: 486e ffcc pea %fp@(-52) 4c4a0: 2079 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a0 4c4a6: 41e8 0020 lea %a0@(32),%a0 4c4aa: 2f08 movel %a0,%sp@- 4c4ac: 4eb9 0004 d37c jsr 4d37c <memcpy>
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
4c4b2: 4fef 000c lea %sp@(12),%sp
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
4c4b6: 2544 00d0 movel %d4,%a2@(208)
return true;
4c4ba: 7001 moveq #1,%d0 4c4bc: 6002 bras 4c4c0 <_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;
4c4be: 4200 clrb %d0
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
}
4c4c0: 4cee 0c3c ffb4 moveml %fp@(-76),%d2-%d5/%a2-%a3 4c4c6: 4e5e unlk %fp
...
0004ca44 <_POSIX_signals_Clear_process_signals>:
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4ca44: 203c 0000 0700 movel #1792,%d0
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
4ca4a: 4e56 0000 linkw %fp,#0 4ca4e: 222e 0008 movel %fp@(8),%d1 4ca52: 2f03 movel %d3,%sp@- 4ca54: 2f02 movel %d2,%sp@-
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4ca56: 40c2 movew %sr,%d2 4ca58: 8082 orl %d2,%d0 4ca5a: 46c0 movew %d0,%sr
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4ca5c: 2601 movel %d1,%d3 4ca5e: 2001 movel %d1,%d0 4ca60: 41f9 0005 ee64 lea 5ee64 <_POSIX_signals_Vectors>,%a0 4ca66: e58b lsll #2,%d3 4ca68: e988 lsll #4,%d0 4ca6a: 9083 subl %d3,%d0 4ca6c: 7602 moveq #2,%d3 4ca6e: b6b0 0800 cmpl %a0@(00000000,%d0:l),%d3
4ca72: 6614 bnes 4ca88 <_POSIX_signals_Clear_process_signals+0x44>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4ca74: 2040 moveal %d0,%a0 4ca76: d1fc 0005 f060 addal #389216,%a0
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
4ca7c: 43f9 0005 f05c lea 5f05c <_POSIX_signals_Siginfo>,%a1 4ca82: b1f1 0800 cmpal %a1@(00000000,%d0:l),%a0
4ca86: 660e bnes 4ca96 <_POSIX_signals_Clear_process_signals+0x52><== NEVER TAKEN
4ca88: 5381 subql #1,%d1 4ca8a: 7001 moveq #1,%d0 4ca8c: e3a8 lsll %d1,%d0
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
4ca8e: 4680 notl %d0 4ca90: c1b9 0005 f058 andl %d0,5f058 <_POSIX_signals_Pending>
}
_ISR_Enable( level );
4ca96: 46c2 movew %d2,%sr
}
4ca98: 241f movel %sp@+,%d2 4ca9a: 261f movel %sp@+,%d3
4ca9c: 4e5e unlk %fp <== NOT EXECUTED
00046284 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
46284: 701b moveq #27,%d0
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
46286: 4e56 fff4 linkw %fp,#-12 4628a: 48d7 001c moveml %d2-%d4,%sp@ 4628e: 242e 0008 movel %fp@(8),%d2 46292: 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(
46294: 2200 movel %d0,%d1 46296: 5381 subql #1,%d1 46298: 2803 movel %d3,%d4 4629a: e3ac lsll %d1,%d4 4629c: 2204 movel %d4,%d1
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
4629e: c282 andl %d2,%d1
462a0: 6626 bnes 462c8 <_POSIX_signals_Get_lowest+0x44> <== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
462a2: 5280 addql #1,%d0 462a4: 123c 0020 moveb #32,%d1 462a8: b280 cmpl %d0,%d1
462aa: 66e8 bnes 46294 <_POSIX_signals_Get_lowest+0x10>
462ac: 7001 moveq #1,%d0 462ae: 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(
462b0: 2200 movel %d0,%d1 462b2: 5381 subql #1,%d1 462b4: 2803 movel %d3,%d4 462b6: e3ac lsll %d1,%d4 462b8: 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 ) ) {
462ba: c282 andl %d2,%d1
462bc: 660a bnes 462c8 <_POSIX_signals_Get_lowest+0x44>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
462be: 5280 addql #1,%d0 462c0: 123c 001b moveb #27,%d1 462c4: b280 cmpl %d0,%d1
462c6: 66e8 bnes 462b0 <_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; }
462c8: 4cd7 001c moveml %sp@,%d2-%d4
462cc: 4e5e unlk %fp <== NOT EXECUTED
0005ae6c <_POSIX_signals_Unblock_thread>:
5ae6c: 7201 moveq #1,%d1
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
5ae6e: 4e56 fff4 linkw %fp,#-12 5ae72: 226e 0010 moveal %fp@(16),%a1 5ae76: 48d7 040c moveml %d2-%d3/%a2,%sp@ 5ae7a: 242e 000c movel %fp@(12),%d2 5ae7e: 2002 movel %d2,%d0 5ae80: 5380 subql #1,%d0 5ae82: 246e 0008 moveal %fp@(8),%a2 5ae86: e1a9 lsll %d0,%d1
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
5ae88: 202a 0010 movel %a2@(16),%d0 5ae8c: 2600 movel %d0,%d3 5ae8e: 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 ];
5ae94: 206a 0102 moveal %a2@(258),%a0
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
5ae98: 0c83 1000 8000 cmpil #268468224,%d3
5ae9e: 6650 bnes 5aef0 <_POSIX_signals_Unblock_thread+0x84>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
5aea0: 2001 movel %d1,%d0 5aea2: c0aa 0030 andl %a2@(48),%d0
5aea6: 660c bnes 5aeb4 <_POSIX_signals_Unblock_thread+0x48>
5aea8: 2028 00d0 movel %a0@(208),%d0 5aeac: 4680 notl %d0 5aeae: c280 andl %d0,%d1 5aeb0: 6700 00a8 beqw 5af5a <_POSIX_signals_Unblock_thread+0xee>
the_thread->Wait.return_code = EINTR;
5aeb4: 7004 moveq #4,%d0
the_info = (siginfo_t *) the_thread->Wait.return_argument;
5aeb6: 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;
5aeba: 2540 0034 movel %d0,%a2@(52)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
5aebe: 4a89 tstl %a1
5aec0: 660e bnes 5aed0 <_POSIX_signals_Unblock_thread+0x64>
the_info->si_signo = signo;
the_info->si_code = SI_USER;
5aec2: 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;
5aec4: 2082 movel %d2,%a0@
the_info->si_code = SI_USER;
5aec6: 2141 0004 movel %d1,%a0@(4)
the_info->si_value.sival_int = 0;
5aeca: 42a8 0008 clrl %a0@(8) 5aece: 6012 bras 5aee2 <_POSIX_signals_Unblock_thread+0x76>
} else {
*the_info = *info;
5aed0: 4878 000c pea c <OPER1> 5aed4: 2f09 movel %a1,%sp@- 5aed6: 2f08 movel %a0,%sp@- 5aed8: 4eb9 0004 d37c jsr 4d37c <memcpy> 5aede: 4fef 000c lea %sp@(12),%sp
}
_Thread_queue_Extract_with_proxy( the_thread );
5aee2: 2f0a movel %a2,%sp@- 5aee4: 4eb9 0004 80d4 jsr 480d4 <_Thread_queue_Extract_with_proxy>
return true;
5aeea: 588f addql #4,%sp 5aeec: 7001 moveq #1,%d0 5aeee: 606c bras 5af5c <_POSIX_signals_Unblock_thread+0xf0>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
5aef0: 2428 00d0 movel %a0@(208),%d2 5aef4: 4682 notl %d2 5aef6: c282 andl %d2,%d1
5aef8: 6760 beqs 5af5a <_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 ) ) {
5aefa: 0800 001c btst #28,%d0
5aefe: 673e beqs 5af3e <_POSIX_signals_Unblock_thread+0xd2>
the_thread->Wait.return_code = EINTR;
5af00: 7204 moveq #4,%d1 5af02: 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);
5af06: 2200 movel %d0,%d1 5af08: 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) )
5af0e: 670c beqs 5af1c <_POSIX_signals_Unblock_thread+0xb0>
_Thread_queue_Extract_with_proxy( the_thread );
5af10: 2f0a movel %a2,%sp@- 5af12: 4eb9 0004 80d4 jsr 480d4 <_Thread_queue_Extract_with_proxy> 5af18: 588f addql #4,%sp 5af1a: 603e bras 5af5a <_POSIX_signals_Unblock_thread+0xee>
else if ( _States_Is_delaying(the_thread->current_state) ) {
5af1c: 44c0 movew %d0,%ccr
5af1e: 6a3a bpls 5af5a <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
5af20: 486a 0048 pea %a2@(72) 5af24: 4eb9 0004 8880 jsr 48880 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
5af2a: 2f3c 1003 fff8 movel #268697592,%sp@- 5af30: 2f0a movel %a2,%sp@- 5af32: 4eb9 0004 7780 jsr 47780 <_Thread_Clear_state> 5af38: 4fef 000c lea %sp@(12),%sp 5af3c: 601c bras 5af5a <_POSIX_signals_Unblock_thread+0xee>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
5af3e: 4a80 tstl %d0
5af40: 6618 bnes 5af5a <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
5af42: 4ab9 0005 ee2e tstl 5ee2e <_Per_CPU_Information+0x8>
5af48: 6710 beqs 5af5a <_POSIX_signals_Unblock_thread+0xee>
5af4a: b5f9 0005 ee32 cmpal 5ee32 <_Per_CPU_Information+0xc>,%a2
5af50: 6608 bnes 5af5a <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
5af52: 7001 moveq #1,%d0 5af54: 13c0 0005 ee3e moveb %d0,5ee3e <_Per_CPU_Information+0x18>
}
}
return false;
5af5a: 4200 clrb %d0
}
5af5c: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 5af62: 4e5e unlk %fp
...
0004637c <_Rate_monotonic_Get_status>:
bool _Rate_monotonic_Get_status(
Rate_monotonic_Control *the_period,
Rate_monotonic_Period_time_t *wall_since_last_period,
Thread_CPU_usage_t *cpu_since_last_period
)
{
4637c: 4e56 ffd4 linkw %fp,#-44 46380: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 46384: 266e 0008 moveal %fp@(8),%a3
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
46388: 240e movel %fp,%d2 4638a: 5182 subql #8,%d2
_Timestamp_Subtract(
4638c: 45f9 0004 9bbc lea 49bbc <_Timespec_Subtract>,%a2
)
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
46392: 286b 0040 moveal %a3@(64),%a4
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
46396: 2f02 movel %d2,%sp@- 46398: 4eb9 0004 7b18 jsr 47b18 <_TOD_Get_uptime>
_Timestamp_Subtract(
4639e: 2f2e 000c movel %fp@(12),%sp@- 463a2: 2f02 movel %d2,%sp@- 463a4: 486b 004c pea %a3@(76) 463a8: 4e92 jsr %a2@
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
463aa: 4fef 0010 lea %sp@(16),%sp
#endif
/*
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
463ae: 202c 0082 movel %a4@(130),%d0 463b2: 222c 0086 movel %a4@(134),%d1 463b6: 2d40 fff0 movel %d0,%fp@(-16) 463ba: 2d41 fff4 movel %d1,%fp@(-12)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
463be: b9f9 0006 0a4c cmpal 60a4c <_Per_CPU_Information+0xc>,%a4
463c4: 6644 bnes 4640a <_Rate_monotonic_Get_status+0x8e><== NEVER TAKEN
Thread_CPU_usage_t ran;
/* How much time time since last context switch */
_Timestamp_Subtract(
463c6: 260e movel %fp,%d3 463c8: 0683 ffff ffe8 addil #-24,%d3
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
463ce: 47eb 0044 lea %a3@(68),%a3
if (owning_thread == _Thread_Executing) {
Thread_CPU_usage_t ran;
/* How much time time since last context switch */
_Timestamp_Subtract(
463d2: 2f03 movel %d3,%sp@- 463d4: 2f02 movel %d2,%sp@- 463d6: 4879 0006 068e pea 6068e <_Thread_Time_of_last_context_switch>
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
/* cpu usage += ran */
_Timestamp_Add_to( &used, &ran );
463dc: 5182 subql #8,%d2
if (owning_thread == _Thread_Executing) {
Thread_CPU_usage_t ran;
/* How much time time since last context switch */
_Timestamp_Subtract(
463de: 4e92 jsr %a2@
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
/* cpu usage += ran */
_Timestamp_Add_to( &used, &ran );
463e0: 2f03 movel %d3,%sp@- 463e2: 2f02 movel %d2,%sp@- 463e4: 4eb9 0004 9a94 jsr 49a94 <_Timespec_Add_to>
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
463ea: 2f0b movel %a3,%sp@- 463ec: 2f02 movel %d2,%sp@- 463ee: 4eb9 0004 9b8c jsr 49b8c <_Timespec_Less_than> 463f4: 4fef 001c lea %sp@(28),%sp 463f8: 4a00 tstb %d0
463fa: 6612 bnes 4640e <_Rate_monotonic_Get_status+0x92>
return false;
/* used = current cpu usage - cpu usage at start of period */
_Timestamp_Subtract(
463fc: 2f2e 0010 movel %fp@(16),%sp@- 46400: 2f02 movel %d2,%sp@- 46402: 2f0b movel %a3,%sp@- 46404: 4e92 jsr %a2@ 46406: 4fef 000c lea %sp@(12),%sp
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
4640a: 7001 moveq #1,%d0 4640c: 6002 bras 46410 <_Rate_monotonic_Get_status+0x94>
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
return false;
4640e: 4200 clrb %d0
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
46410: 4cee 1c0c ffd4 moveml %fp@(-44),%d2-%d3/%a2-%a4
46416: 4e5e unlk %fp <== NOT EXECUTED
000582d8 <_Region_Process_queue>:
*/
void _Region_Process_queue(
Region_Control *the_region
)
{
582d8: 4e56 ffe4 linkw %fp,#-28
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
582dc: 2039 0007 751c movel 7751c <_Thread_Dispatch_disable_level>,%d0 582e2: 5280 addql #1,%d0 582e4: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@ 582e8: 266e 0008 moveal %fp@(8),%a3 582ec: 23c0 0007 751c movel %d0,7751c <_Thread_Dispatch_disable_level>
* 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();
582f2: 2f39 0007 75bc movel 775bc <_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 );
582f8: 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 );
582fa: 260b movel %a3,%d3 582fc: 0682 0000 0010 addil #16,%d2 58302: 0683 0000 0068 addil #104,%d3 58308: 4bf9 0005 375c lea 5375c <_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 );
5830e: 49f9 0005 8968 lea 58968 <_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();
58314: 4eb9 0005 2cf0 jsr 52cf0 <_API_Mutex_Unlock> 5831a: 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 );
5831c: 283c 0005 8a6c movel #363116,%d4 58322: 2f02 movel %d2,%sp@- 58324: 2044 moveal %d4,%a0 58326: 4e90 jsr %a0@
if ( the_thread == NULL )
58328: 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 );
5832a: 2440 moveal %d0,%a2
if ( the_thread == NULL )
5832c: 4a80 tstl %d0
5832e: 672c beqs 5835c <_Region_Process_queue+0x84>
58330: 42a7 clrl %sp@- 58332: 42a7 clrl %sp@- 58334: 2f2a 0024 movel %a2@(36),%sp@- 58338: 2f03 movel %d3,%sp@- 5833a: 4e95 jsr %a5@
the_segment = (void **) _Region_Allocate_segment(
the_region,
the_thread->Wait.count
);
if ( the_segment == NULL )
5833c: 4fef 0010 lea %sp@(16),%sp 58340: 4a80 tstl %d0
58342: 6718 beqs 5835c <_Region_Process_queue+0x84>
break;
*(void **)the_thread->Wait.return_argument = the_segment;
58344: 206a 0028 moveal %a2@(40),%a0 58348: 2080 movel %d0,%a0@
the_region->number_of_used_blocks += 1;
5834a: 52ab 0064 addql #1,%a3@(100)
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
5834e: 2f0a movel %a2,%sp@- 58350: 2f02 movel %d2,%sp@- 58352: 4e94 jsr %a4@
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
}
58354: 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;
58356: 42aa 0034 clrl %a2@(52)
}
5835a: 60c6 bras 58322 <_Region_Process_queue+0x4a>
_Thread_Enable_dispatch(); }
5835c: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5 58362: 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();
58364: 4ef9 0005 526e jmp 5526e <_Thread_Enable_dispatch>
...
00047244 <_Scheduler_Handler_initialization>:
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
47244: 4e56 0000 linkw %fp,#0
(*_Scheduler.Operations.initialize)(); }
47248: 4e5e unlk %fp
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
(*_Scheduler.Operations.initialize)();
4724a: 2279 0005 d004 moveal 5d004 <_Scheduler+0x4>,%a1 47250: 4ed1 jmp %a1@
...
00047270 <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
47270: 4e56 0000 linkw %fp,#0 47274: 226e 0008 moveal %fp@(8),%a1 47278: 2f0a movel %a2,%sp@-
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
4727a: 2469 008a moveal %a1@(138),%a2
ready = sched_info->ready_chain;
4727e: 2052 moveal %a2@,%a0
if ( _Chain_Has_only_one_node( ready ) ) {
47280: 2028 0008 movel %a0@(8),%d0 47284: b090 cmpl %a0@,%d0
47286: 6632 bnes 472ba <_Scheduler_priority_Block+0x4a> Chain_Node *tail = _Chain_Tail( the_chain );
47288: 2008 movel %a0,%d0 4728a: 5880 addql #4,%d0
head->next = tail;
head->previous = NULL;
4728c: 42a8 0004 clrl %a0@(4)
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 );
47290: 2080 movel %d0,%a0@
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
47292: 302a 000e movew %a2@(14),%d0
head->next = tail;
head->previous = NULL;
tail->previous = head;
47296: 2148 0008 movel %a0,%a0@(8) 4729a: 206a 0004 moveal %a2@(4),%a0 4729e: 3210 movew %a0@,%d1 472a0: c081 andl %d1,%d0 472a2: 3080 movew %d0,%a0@
if ( *the_priority_map->minor == 0 )
472a4: 6620 bnes 472c6 <_Scheduler_priority_Block+0x56>
_Priority_Major_bit_map &= the_priority_map->block_major;
472a6: 3039 0005 ee40 movew 5ee40 <_Priority_Major_bit_map>,%d0 472ac: 322a 000c movew %a2@(12),%d1 472b0: c081 andl %d1,%d0 472b2: 33c0 0005 ee40 movew %d0,5ee40 <_Priority_Major_bit_map> 472b8: 600c bras 472c6 <_Scheduler_priority_Block+0x56>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
472ba: 2451 moveal %a1@,%a2
previous = the_node->previous;
472bc: 2069 0004 moveal %a1@(4),%a0
next->previous = previous;
472c0: 2548 0004 movel %a0,%a2@(4)
previous->next = next;
472c4: 208a movel %a2,%a0@
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
472c6: b3f9 0005 ee36 cmpal 5ee36 <_Per_CPU_Information+0x10>,%a1
472cc: 6646 bnes 47314 <_Scheduler_priority_Block+0xa4>
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
472ce: 3039 0005 ee40 movew 5ee40 <_Priority_Major_bit_map>,%d0 472d4: 4840 swap %d0 472d6: 04c0 ff1 %d0
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
472d8: 41f9 0005 ee44 lea 5ee44 <_Priority_Bit_map>,%a0 472de: 0280 0000 ffff andil #65535,%d0 472e4: 3230 0a00 movew %a0@(00000000,%d0:l:2),%d1 472e8: 4841 swap %d1 472ea: 04c1 ff1 %d1
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
472ec: 2079 0005 d000 moveal 5d000 <_Scheduler>,%a0
return (_Priority_Bits_index( major ) << 4) +
472f2: 0281 0000 ffff andil #65535,%d1 472f8: e988 lsll #4,%d0 472fa: d081 addl %d1,%d0
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
472fc: 2200 movel %d0,%d1 472fe: e988 lsll #4,%d0 47300: e589 lsll #2,%d1 47302: 9081 subl %d1,%d0 47304: d1c0 addal %d0,%a0 47306: 2018 movel %a0@+,%d0 47308: b1c0 cmpal %d0,%a0
4730a: 6602 bnes 4730e <_Scheduler_priority_Block+0x9e> <== ALWAYS TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
4730c: 4280 clrl %d0 <== NOT EXECUTED
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
4730e: 23c0 0005 ee36 movel %d0,5ee36 <_Per_CPU_Information+0x10>
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
47314: b3f9 0005 ee32 cmpal 5ee32 <_Per_CPU_Information+0xc>,%a1
4731a: 6608 bnes 47324 <_Scheduler_priority_Block+0xb4>
_Thread_Dispatch_necessary = true;
4731c: 7001 moveq #1,%d0 4731e: 13c0 0005 ee3e moveb %d0,5ee3e <_Per_CPU_Information+0x18>
}
47324: 245f moveal %sp@+,%a2 47326: 4e5e unlk %fp
...
0004741c <_Scheduler_priority_Free>:
#include <rtems/score/wkspace.h>
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
4741c: 4e56 0000 linkw %fp,#0
_Workspace_Free( the_thread->scheduler_info );
47420: 206e 0008 moveal %fp@(8),%a0 47424: 2d68 008a 0008 movel %a0@(138),%fp@(8)
}
4742a: 4e5e unlk %fp
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
4742c: 4ef9 0004 89f4 jmp 489f4 <_Workspace_Free>
...
0004749c <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
4749c: 4e56 0000 linkw %fp,#0
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
474a0: 3039 0005 ee40 movew 5ee40 <_Priority_Major_bit_map>,%d0 474a6: 4840 swap %d0 474a8: 04c0 ff1 %d0
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
474aa: 41f9 0005 ee44 lea 5ee44 <_Priority_Bit_map>,%a0 474b0: 0280 0000 ffff andil #65535,%d0 474b6: 3230 0a00 movew %a0@(00000000,%d0:l:2),%d1 474ba: 4841 swap %d1 474bc: 04c1 ff1 %d1
_Scheduler_priority_Schedule_body(); }
474be: 2079 0005 d000 moveal 5d000 <_Scheduler>,%a0
return (_Priority_Bits_index( major ) << 4) +
474c4: 0281 0000 ffff andil #65535,%d1 474ca: e988 lsll #4,%d0 474cc: d081 addl %d1,%d0
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
474ce: 2200 movel %d0,%d1 474d0: e988 lsll #4,%d0 474d2: e589 lsll #2,%d1 474d4: 9081 subl %d1,%d0 474d6: d1c0 addal %d0,%a0 474d8: 2018 movel %a0@+,%d0 474da: b1c0 cmpal %d0,%a0
474dc: 6602 bnes 474e0 <_Scheduler_priority_Schedule+0x44><== ALWAYS TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
474de: 4280 clrl %d0 <== NOT EXECUTED
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
474e0: 23c0 0005 ee36 movel %d0,5ee36 <_Per_CPU_Information+0x10> 474e6: 4e5e unlk %fp
...
0004627c <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
4627c: 4e56 0000 linkw %fp,#0 46280: 206e 0008 moveal %fp@(8),%a0 46284: 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();
46286: 2039 0005 f180 movel 5f180 <Configuration+0xc>,%d0
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
4628c: 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) ||
4628e: 4a88 tstl %a0
46290: 6762 beqs 462f4 <_TOD_Validate+0x78> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
46292: 243c 000f 4240 movel #1000000,%d2 46298: 4c40 2002 remul %d0,%d2,%d2
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
4629c: b4a8 0018 cmpl %a0@(24),%d2
462a0: 6352 blss 462f4 <_TOD_Validate+0x78>
(the_tod->ticks >= ticks_per_second) ||
462a2: 763b moveq #59,%d3 462a4: b6a8 0014 cmpl %a0@(20),%d3
462a8: 654a bcss 462f4 <_TOD_Validate+0x78>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
462aa: b6a8 0010 cmpl %a0@(16),%d3
462ae: 6544 bcss 462f4 <_TOD_Validate+0x78>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
462b0: 7017 moveq #23,%d0 462b2: b0a8 000c cmpl %a0@(12),%d0
462b6: 653c bcss 462f4 <_TOD_Validate+0x78>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
462b8: 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) ||
462bc: 6736 beqs 462f4 <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->month == 0) ||
462be: 720c moveq #12,%d1 462c0: b280 cmpl %d0,%d1
462c2: 6530 bcss 462f4 <_TOD_Validate+0x78>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
462c4: 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) ||
462c6: 0c82 0000 07c3 cmpil #1987,%d2
462cc: 6326 blss 462f4 <_TOD_Validate+0x78>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
462ce: 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) ||
462d2: 6720 beqs 462f4 <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
462d4: 163c 0003 moveb #3,%d3 462d8: 41f9 0005 e136 lea 5e136 <_TOD_Days_per_month>,%a0 462de: c483 andl %d3,%d2
462e0: 6606 bnes 462e8 <_TOD_Validate+0x6c>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
462e2: 2030 0c34 movel %a0@(00000034,%d0:l:4),%d0 462e6: 6004 bras 462ec <_TOD_Validate+0x70>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
462e8: 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(
462ec: b081 cmpl %d1,%d0 462ee: 54c0 scc %d0 462f0: 4480 negl %d0 462f2: 6002 bras 462f6 <_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;
462f4: 4200 clrb %d0
if ( the_tod->day > days_in_month )
return false;
return true;
}
462f6: 241f movel %sp@+,%d2 462f8: 261f movel %sp@+,%d3 462fa: 4e5e unlk %fp
...
000476a4 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
476a4: 4e56 fff0 linkw %fp,#-16 476a8: 48d7 041c moveml %d2-%d4/%a2,%sp@ 476ac: 246e 0008 moveal %fp@(8),%a2
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
476b0: 282a 0010 movel %a2@(16),%d4
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
476b4: 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 );
476b8: 2f0a movel %a2,%sp@-
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
476ba: 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 );
476be: 4eb9 0004 8298 jsr 48298 <_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 )
476c4: 588f addql #4,%sp 476c6: b4aa 0014 cmpl %a2@(20),%d2
476ca: 670c beqs 476d8 <_Thread_Change_priority+0x34>
_Thread_Set_priority( the_thread, new_priority );
476cc: 2f02 movel %d2,%sp@- 476ce: 2f0a movel %a2,%sp@- 476d0: 4eb9 0004 823c jsr 4823c <_Thread_Set_priority> 476d6: 508f addql #8,%sp
_ISR_Disable( level );
476d8: 203c 0000 0700 movel #1792,%d0 476de: 40c2 movew %sr,%d2 476e0: 8082 orl %d2,%d0 476e2: 46c0 movew %d0,%sr 476e4: 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;
476e6: 202a 0010 movel %a2@(16),%d0 476ea: c284 andl %d4,%d1
if ( state != STATES_TRANSIENT ) {
476ec: 7804 moveq #4,%d4 476ee: b880 cmpl %d0,%d4
476f0: 672e beqs 47720 <_Thread_Change_priority+0x7c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
476f2: 4a81 tstl %d1
476f4: 6608 bnes 476fe <_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);
476f6: 72fb moveq #-5,%d1 476f8: c280 andl %d0,%d1 476fa: 2541 0010 movel %d1,%a2@(16)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
476fe: 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);
47700: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
47706: 676c beqs 47774 <_Thread_Change_priority+0xd0>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
47708: 2d4a 000c movel %a2,%fp@(12) 4770c: 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 );
}
47712: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 47718: 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 );
4771a: 4ef9 0004 81a0 jmp 481a0 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
47720: 4a81 tstl %d1
47722: 661e bnes 47742 <_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 );
47724: 42aa 0010 clrl %a2@(16)
if ( prepend_it )
47728: 4a03 tstb %d3
4772a: 670a beqs 47736 <_Thread_Change_priority+0x92>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
4772c: 2f0a movel %a2,%sp@- 4772e: 2079 0005 d028 moveal 5d028 <_Scheduler+0x28>,%a0 47734: 6008 bras 4773e <_Thread_Change_priority+0x9a>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
47736: 2079 0005 d024 moveal 5d024 <_Scheduler+0x24>,%a0 4773c: 2f0a movel %a2,%sp@- 4773e: 4e90 jsr %a0@ 47740: 588f addql #4,%sp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
47742: 203c 0000 0700 movel #1792,%d0 47748: 46c2 movew %d2,%sr 4774a: 8082 orl %d2,%d0 4774c: 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();
4774e: 2079 0005 d008 moveal 5d008 <_Scheduler+0x8>,%a0 47754: 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 );
47756: 2079 0005 ee32 moveal 5ee32 <_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() &&
4775c: b1f9 0005 ee36 cmpal 5ee36 <_Per_CPU_Information+0x10>,%a0
47762: 670e beqs 47772 <_Thread_Change_priority+0xce>
47764: 4a28 0074 tstb %a0@(116)
47768: 6708 beqs 47772 <_Thread_Change_priority+0xce>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
4776a: 7801 moveq #1,%d4 4776c: 13c4 0005 ee3e moveb %d4,5ee3e <_Per_CPU_Information+0x18>
_ISR_Enable( level );
47772: 46c2 movew %d2,%sr
}
47774: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 4777a: 4e5e unlk %fp
...
00047948 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
47948: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4794c: 486e fffc pea %fp@(-4) 47950: 2f2e 0008 movel %fp@(8),%sp@- 47954: 4eb9 0004 7ae8 jsr 47ae8 <_Thread_Get>
switch ( location ) {
4795a: 508f addql #8,%sp 4795c: 4aae fffc tstl %fp@(-4)
47960: 661e bnes 47980 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
47962: 2f3c 1000 0018 movel #268435480,%sp@- 47968: 2f00 movel %d0,%sp@- 4796a: 4eb9 0004 7780 jsr 47780 <_Thread_Clear_state> 47970: 508f addql #8,%sp 47972: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0 47978: 5380 subql #1,%d0 4797a: 23c0 0005 e9c8 movel %d0,5e9c8 <_Thread_Dispatch_disable_level>
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
47980: 4e5e unlk %fp <== NOT EXECUTED
00047984 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
47984: 4e56 ffc8 linkw %fp,#-56 47988: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
4798c: 283c 0000 0700 movel #1792,%d4 47992: 2204 movel %d4,%d1
{
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
47994: 2479 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
4799a: 40c0 movew %sr,%d0 4799c: 8280 orl %d0,%d1 4799e: 46c1 movew %d1,%sr
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
479a0: 260e movel %fp,%d3
_Timestamp_Subtract(
479a2: 240e movel %fp,%d2
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
479a4: 5183 subql #8,%d3
_Timestamp_Subtract(
479a6: 0682 ffff fff0 addil #-16,%d2
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
479ac: 2e3c 0004 846c movel #296044,%d7
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
479b2: 2c3c 0004 8720 movel #296736,%d6
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
479b8: 2a3c 0004 8a44 movel #297540,%d5
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
_Context_Restore_fp( &executing->fp_context );
479be: 4bf9 0004 8bac lea 48bac <_CPU_Context_restore_fp>,%a5
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
479c4: 49f9 0004 8b8a lea 48b8a <_CPU_Context_save_fp>,%a4
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
479ca: 6000 00d4 braw 47aa0 <_Thread_Dispatch+0x11c>
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
479ce: 7201 moveq #1,%d1 479d0: 23c1 0005 e9c8 movel %d1,5e9c8 <_Thread_Dispatch_disable_level>
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
479d6: 2679 0005 ee36 moveal 5ee36 <_Per_CPU_Information+0x10>,%a3
_Thread_Dispatch_disable_level = 1;
_Thread_Dispatch_necessary = false;
479dc: 4201 clrb %d1
_Thread_Executing = heir;
479de: 23cb 0005 ee32 movel %a3,5ee32 <_Per_CPU_Information+0xc>
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
_Thread_Dispatch_necessary = false;
479e4: 13c1 0005 ee3e moveb %d1,5ee3e <_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 )
479ea: b5cb cmpal %a3,%a2 479ec: 6700 00bc beqw 47aaa <_Thread_Dispatch+0x126>
*/
#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 )
479f0: 7201 moveq #1,%d1 479f2: b2ab 007a cmpl %a3@(122),%d1
479f6: 660a bnes 47a02 <_Thread_Dispatch+0x7e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
479f8: 41f9 0005 e980 lea 5e980 <_Thread_Ticks_per_timeslice>,%a0 479fe: 2750 0076 movel %a0@,%a3@(118)
_ISR_Enable( level );
47a02: 46c0 movew %d0,%sr
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47a04: 2f03 movel %d3,%sp@- 47a06: 4eb9 0004 ad48 jsr 4ad48 <_TOD_Get_uptime>
_Timestamp_Subtract(
47a0c: 2f02 movel %d2,%sp@- 47a0e: 2f03 movel %d3,%sp@- 47a10: 4879 0005 ea74 pea 5ea74 <_Thread_Time_of_last_context_switch> 47a16: 4eb9 0004 84a4 jsr 484a4 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47a1c: 2047 moveal %d7,%a0 47a1e: 2f02 movel %d2,%sp@- 47a20: 486a 0082 pea %a2@(130) 47a24: 4e90 jsr %a0@
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
47a26: 2079 0005 ea4e moveal 5ea4e <_Thread_libc_reent>,%a0 47a2c: 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;
47a30: 202e fff8 movel %fp@(-8),%d0 47a34: 222e fffc movel %fp@(-4),%d1 47a38: 23c0 0005 ea74 movel %d0,5ea74 <_Thread_Time_of_last_context_switch> 47a3e: 23c1 0005 ea78 movel %d1,5ea78 <_Thread_Time_of_last_context_switch+0x4>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
47a44: 4a88 tstl %a0
47a46: 6708 beqs 47a50 <_Thread_Dispatch+0xcc> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
47a48: 2550 00fa movel %a0@,%a2@(250)
*_Thread_libc_reent = heir->libc_reent;
47a4c: 20ab 00fa movel %a3@(250),%a0@
}
_User_extensions_Thread_switch( executing, heir );
47a50: 2f0b movel %a3,%sp@- 47a52: 2046 moveal %d6,%a0 47a54: 2f0a movel %a2,%sp@- 47a56: 4e90 jsr %a0@
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
47a58: 486b 00c2 pea %a3@(194) 47a5c: 2045 moveal %d5,%a0 47a5e: 486a 00c2 pea %a2@(194) 47a62: 4e90 jsr %a0@
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
47a64: 4fef 0010 lea %sp@(16),%sp 47a68: 4aaa 00f6 tstl %a2@(246)
47a6c: 6724 beqs 47a92 <_Thread_Dispatch+0x10e>
#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 );
47a6e: 2079 0005 ea4a moveal 5ea4a <_Thread_Allocated_fp>,%a0 47a74: b1ca cmpal %a2,%a0
47a76: 671a beqs 47a92 <_Thread_Dispatch+0x10e>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
47a78: 4a88 tstl %a0
47a7a: 6708 beqs 47a84 <_Thread_Dispatch+0x100>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
47a7c: 4868 00f6 pea %a0@(246) 47a80: 4e94 jsr %a4@ 47a82: 588f addql #4,%sp
_Context_Restore_fp( &executing->fp_context );
47a84: 486a 00f6 pea %a2@(246) 47a88: 4e95 jsr %a5@
_Thread_Allocated_fp = executing;
47a8a: 588f addql #4,%sp 47a8c: 23ca 0005 ea4a movel %a2,5ea4a <_Thread_Allocated_fp>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
47a92: 2479 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
47a98: 2204 movel %d4,%d1 47a9a: 40c0 movew %sr,%d0 47a9c: 8280 orl %d0,%d1 47a9e: 46c1 movew %d1,%sr
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
47aa0: 1239 0005 ee3e moveb 5ee3e <_Per_CPU_Information+0x18>,%d1 47aa6: 6600 ff26 bnew 479ce <_Thread_Dispatch+0x4a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
47aaa: 42b9 0005 e9c8 clrl 5e9c8 <_Thread_Dispatch_disable_level>
_ISR_Enable( level );
47ab0: 46c0 movew %d0,%sr
_API_extensions_Run_postswitch();
47ab2: 4eb9 0004 60e0 jsr 460e0 <_API_extensions_Run_postswitch>
}
47ab8: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
47abe: 4e5e unlk %fp <== NOT EXECUTED
0004c8e8 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4c8e8: 4e56 0000 linkw %fp,#0 4c8ec: 2f0a movel %a2,%sp@-
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
4c8ee: 2479 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a2
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4c8f4: 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;
4c8f6: 222a 00a8 movel %a2@(168),%d1
_ISR_Set_level(level);
4c8fa: 40c0 movew %sr,%d0 4c8fc: e189 lsll #8,%d1 4c8fe: 0280 0000 f8ff andil #63743,%d0 4c904: 8081 orl %d1,%d0 4c906: 46c0 movew %d0,%sr
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
doneConstructors = 1;
4c908: 7001 moveq #1,%d0
level = executing->Start.isr_level;
_ISR_Set_level(level);
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
4c90a: 1439 0005 e188 moveb 5e188 <doneConstructors.3362>,%d2
doneConstructors = 1;
4c910: 13c0 0005 e188 moveb %d0,5e188 <doneConstructors.3362>
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
4c916: 4aaa 00f6 tstl %a2@(246)
4c91a: 6720 beqs 4c93c <_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 );
4c91c: 2079 0005 ea4a moveal 5ea4a <_Thread_Allocated_fp>,%a0 4c922: b1ca cmpal %a2,%a0
4c924: 6716 beqs 4c93c <_Thread_Handler+0x54>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
4c926: 4a88 tstl %a0
4c928: 670c beqs 4c936 <_Thread_Handler+0x4e>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
4c92a: 4868 00f6 pea %a0@(246) 4c92e: 4eb9 0004 8b8a jsr 48b8a <_CPU_Context_save_fp> 4c934: 588f addql #4,%sp
_Thread_Allocated_fp = executing;
4c936: 23ca 0005 ea4a movel %a2,5ea4a <_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 );
4c93c: 2f0a movel %a2,%sp@- 4c93e: 4eb9 0004 859c jsr 4859c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4c944: 4eb9 0004 7ac2 jsr 47ac2 <_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 (!doneCons) /* && (volatile void *)_init) */ {
4c94a: 588f addql #4,%sp 4c94c: 4a02 tstb %d2
4c94e: 6606 bnes 4c956 <_Thread_Handler+0x6e>
INIT_NAME ();
4c950: 4eb9 0005 b294 jsr 5b294 <_init>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4c956: 202a 0092 movel %a2@(146),%d0
4c95a: 6606 bnes 4c962 <_Thread_Handler+0x7a>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
4c95c: 2f2a 009a movel %a2@(154),%sp@- 4c960: 600a bras 4c96c <_Thread_Handler+0x84>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
4c962: 7201 moveq #1,%d1 4c964: b280 cmpl %d0,%d1
4c966: 6610 bnes 4c978 <_Thread_Handler+0x90> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
4c968: 2f2a 0096 movel %a2@(150),%sp@- 4c96c: 206a 008e moveal %a2@(142),%a0 4c970: 4e90 jsr %a0@
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
4c972: 588f addql #4,%sp 4c974: 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 );
4c978: 2f0a movel %a2,%sp@- 4c97a: 4eb9 0004 85d4 jsr 485d4 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
4c980: 4878 0005 pea 5 <COMPARE> 4c984: 4878 0001 pea 1 <ADD> 4c988: 42a7 clrl %sp@- 4c98a: 4eb9 0004 6a08 jsr 46a08 <_Internal_error_Occurred>
000489f4 <_Thread_Restart>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
489f4: 7001 moveq #1,%d0
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
489f6: 4e56 0000 linkw %fp,#0 489fa: 2f0a movel %a2,%sp@- 489fc: 246e 0008 moveal %fp@(8),%a2 48a00: c0aa 0010 andl %a2@(16),%d0
if ( !_States_Is_dormant( the_thread->current_state ) ) {
48a04: 6664 bnes 48a6a <_Thread_Restart+0x76>
_Thread_Set_transient( the_thread );
48a06: 2f0a movel %a2,%sp@- 48a08: 4eb9 0004 8ad4 jsr 48ad4 <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
48a0e: 2f2e 0010 movel %fp@(16),%sp@- 48a12: 2f2e 000c movel %fp@(12),%sp@- 48a16: 2f0a movel %a2,%sp@- 48a18: 4eb9 0004 bc04 jsr 4bc04 <_Thread_Reset>
_Thread_Load_environment( the_thread );
48a1e: 2f0a movel %a2,%sp@- 48a20: 4eb9 0004 b93c jsr 4b93c <_Thread_Load_environment>
_Thread_Ready( the_thread );
48a26: 2f0a movel %a2,%sp@- 48a28: 4eb9 0004 bbd4 jsr 4bbd4 <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
48a2e: 2f0a movel %a2,%sp@- 48a30: 4eb9 0004 8f1c jsr 48f1c <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
48a36: 4fef 001c lea %sp@(28),%sp 48a3a: b5f9 0005 f95a cmpal 5f95a <_Per_CPU_Information+0xc>,%a2
48a40: 662c bnes 48a6e <_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 )
48a42: 4aaa 00f6 tstl %a2@(246)
48a46: 670c beqs 48a54 <_Thread_Restart+0x60>
_Context_Restore_fp( &_Thread_Executing->fp_context );
48a48: 486a 00f6 pea %a2@(246) 48a4c: 4eb9 0004 9428 jsr 49428 <_CPU_Context_restore_fp> 48a52: 588f addql #4,%sp
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
48a54: 2079 0005 f95a moveal 5f95a <_Per_CPU_Information+0xc>,%a0 48a5a: 41e8 00c2 lea %a0@(194),%a0 48a5e: 2f08 movel %a0,%sp@- 48a60: 4eb9 0004 92d6 jsr 492d6 <_CPU_Context_Restart_self>
48a66: 588f addql #4,%sp <== NOT EXECUTED 48a68: 6004 bras 48a6e <_Thread_Restart+0x7a> <== NOT EXECUTED
_Thread_Restart_self();
return true;
}
return false;
48a6a: 4200 clrb %d0 48a6c: 6002 bras 48a70 <_Thread_Restart+0x7c>
_User_extensions_Thread_restart( the_thread );
if ( _Thread_Is_executing ( the_thread ) )
_Thread_Restart_self();
return true;
48a6e: 7001 moveq #1,%d0
}
return false;
}
48a70: 246e fffc moveal %fp@(-4),%a2
48a74: 4e5e unlk %fp <== NOT EXECUTED
000483f8 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
483f8: 4e56 0000 linkw %fp,#0 483fc: 2f0a movel %a2,%sp@-
Thread_Control *executing;
executing = _Thread_Executing;
483fe: 2479 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a2
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
48404: 4a2a 0074 tstb %a2@(116)
48408: 6758 beqs 48462 <_Thread_Tickle_timeslice+0x6a>
return;
if ( !_States_Is_ready( executing->current_state ) )
4840a: 4aaa 0010 tstl %a2@(16)
4840e: 6652 bnes 48462 <_Thread_Tickle_timeslice+0x6a>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
48410: 202a 007a movel %a2@(122),%d0 48414: 7201 moveq #1,%d1 48416: b280 cmpl %d0,%d1
48418: 6248 bhis 48462 <_Thread_Tickle_timeslice+0x6a>
4841a: 123c 0002 moveb #2,%d1 4841e: b280 cmpl %d0,%d1
48420: 640a bccs 4842c <_Thread_Tickle_timeslice+0x34>
48422: 123c 0003 moveb #3,%d1 48426: b280 cmpl %d0,%d1
48428: 6638 bnes 48462 <_Thread_Tickle_timeslice+0x6a> <== NEVER TAKEN
4842a: 6020 bras 4844c <_Thread_Tickle_timeslice+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 ) {
4842c: 202a 0076 movel %a2@(118),%d0 48430: 5380 subql #1,%d0 48432: 2540 0076 movel %d0,%a2@(118)
48436: 6e2a bgts 48462 <_Thread_Tickle_timeslice+0x6a>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
48438: 2079 0005 d00c moveal 5d00c <_Scheduler+0xc>,%a0 4843e: 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;
48440: 41f9 0005 e980 lea 5e980 <_Thread_Ticks_per_timeslice>,%a0 48446: 2550 0076 movel %a0@,%a2@(118) 4844a: 6016 bras 48462 <_Thread_Tickle_timeslice+0x6a>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
4844c: 202a 0076 movel %a2@(118),%d0 48450: 5380 subql #1,%d0 48452: 2540 0076 movel %d0,%a2@(118)
48456: 660a bnes 48462 <_Thread_Tickle_timeslice+0x6a> (*executing->budget_callout)( executing );
48458: 2f0a movel %a2,%sp@- 4845a: 206a 007e moveal %a2@(126),%a0 4845e: 4e90 jsr %a0@ 48460: 588f addql #4,%sp
break;
#endif
}
}
48462: 246e fffc moveal %fp@(-4),%a2 48466: 4e5e unlk %fp
...
00047654 <_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 ) ) {
47654: 7202 moveq #2,%d1
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
47656: 4e56 0000 linkw %fp,#0 4765a: 202e 0010 movel %fp@(16),%d0 4765e: 2f0a movel %a2,%sp@- 47660: 246e 000c moveal %fp@(12),%a2
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
47664: 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 ) ) {
47668: b2aa 0050 cmpl %a2@(80),%d1
4766c: 6618 bnes 47686 <_Thread_blocking_operation_Cancel+0x32>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
4766e: 123c 0003 moveb #3,%d1 47672: 2541 0050 movel %d1,%a2@(80)
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
47676: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
47678: 486a 0048 pea %a2@(72) 4767c: 4eb9 0004 8880 jsr 48880 <_Watchdog_Remove> 47682: 588f addql #4,%sp 47684: 6002 bras 47688 <_Thread_blocking_operation_Cancel+0x34>
} else
_ISR_Enable( level );
47686: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
47688: 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
}
4768c: 246e fffc moveal %fp@(-4),%a2 47690: 203c 1003 fff8 movel #268697592,%d0 47696: 2d40 000c movel %d0,%fp@(12) 4769a: 4e5e unlk %fp 4769c: 4ef9 0004 7780 jmp 47780 <_Thread_Clear_state>
...
0004c990 <_Thread_queue_Extract_fifo>:
Thread_Control *the_thread
)
{
ISR_Level level;
_ISR_Disable( level );
4c990: 223c 0000 0700 movel #1792,%d1
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4c996: 4e56 0000 linkw %fp,#0 4c99a: 2f0a movel %a2,%sp@- 4c99c: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
_ISR_Disable( level );
4c9a0: 40c0 movew %sr,%d0 4c9a2: 8280 orl %d0,%d1 4c9a4: 46c1 movew %d1,%sr 4c9a6: 222a 0010 movel %a2@(16),%d1 4c9aa: 0281 0003 bee0 andil #245472,%d1
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4c9b0: 660a bnes 4c9bc <_Thread_queue_Extract_fifo+0x2c>
_ISR_Enable( level );
4c9b2: 46c0 movew %d0,%sr
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
4c9b4: 246e fffc moveal %fp@(-4),%a2 4c9b8: 4e5e unlk %fp 4c9ba: 4e75 rts
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4c9bc: 2252 moveal %a2@,%a1
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4c9be: 7202 moveq #2,%d1
previous = the_node->previous;
4c9c0: 206a 0004 moveal %a2@(4),%a0
next->previous = previous;
4c9c4: 2348 0004 movel %a0,%a1@(4)
previous->next = next;
4c9c8: 2089 movel %a1,%a0@
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
4c9ca: 42aa 0044 clrl %a2@(68)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4c9ce: b2aa 0050 cmpl %a2@(80),%d1
4c9d2: 6704 beqs 4c9d8 <_Thread_queue_Extract_fifo+0x48>
_ISR_Enable( level );
4c9d4: 46c0 movew %d0,%sr 4c9d6: 6014 bras 4c9ec <_Thread_queue_Extract_fifo+0x5c> 4c9d8: 7203 moveq #3,%d1 4c9da: 2541 0050 movel %d1,%a2@(80)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4c9de: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
4c9e0: 486a 0048 pea %a2@(72) 4c9e4: 4eb9 0004 8880 jsr 48880 <_Watchdog_Remove> 4c9ea: 588f addql #4,%sp
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4c9ec: 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
}
4c9f0: 246e fffc moveal %fp@(-4),%a2 4c9f4: 203c 1003 fff8 movel #268697592,%d0 4c9fa: 2d40 000c movel %d0,%fp@(12) 4c9fe: 4e5e unlk %fp 4ca00: 4ef9 0004 7780 jmp 47780 <_Thread_Clear_state>
...
0004b314 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
4b314: 4e56 0000 linkw %fp,#0 4b318: 226e 0008 moveal %fp@(8),%a1
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
4b31c: 2069 0044 moveal %a1@(68),%a0
* 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.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
4b320: 2028 0030 movel %a0@(48),%d0
4b324: 671c beqs 4b342 <_Thread_queue_Process_timeout+0x2e>
4b326: b3f9 0005 ee32 cmpal 5ee32 <_Per_CPU_Information+0xc>,%a1
4b32c: 6614 bnes 4b342 <_Thread_queue_Process_timeout+0x2e><== NEVER TAKEN
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
4b32e: 7203 moveq #3,%d1 4b330: b280 cmpl %d0,%d1
4b332: 6720 beqs 4b354 <_Thread_queue_Process_timeout+0x40>
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
4b334: 7002 moveq #2,%d0
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
4b336: 2368 003c 0034 movel %a0@(60),%a1@(52)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
4b33c: 2140 0030 movel %d0,%a0@(48) 4b340: 6012 bras 4b354 <_Thread_queue_Process_timeout+0x40>
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
4b342: 2368 003c 0034 movel %a0@(60),%a1@(52)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
4b348: 2f09 movel %a1,%sp@- 4b34a: 2f08 movel %a0,%sp@- 4b34c: 4eb9 0004 b210 jsr 4b210 <_Thread_queue_Extract> 4b352: 508f addql #8,%sp
} }
4b354: 4e5e unlk %fp <== NOT EXECUTED
000481a0 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
481a0: 4e56 fff0 linkw %fp,#-16 481a4: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 481a8: 246e 0008 moveal %fp@(8),%a2 481ac: 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 )
481b0: 4a8a tstl %a2
481b2: 6746 beqs 481fa <_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 ) {
481b4: 7001 moveq #1,%d0 481b6: b0aa 0034 cmpl %a2@(52),%d0
481ba: 663e bnes 481fa <_Thread_queue_Requeue+0x5a> <== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
481bc: 303c 0700 movew #1792,%d0 481c0: 40c2 movew %sr,%d2 481c2: 8082 orl %d2,%d0 481c4: 46c0 movew %d0,%sr 481c6: 202b 0010 movel %a3@(16),%d0 481ca: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
481d0: 6726 beqs 481f8 <_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;
481d2: 7001 moveq #1,%d0 481d4: 2540 0030 movel %d0,%a2@(48)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
481d8: 4878 0001 pea 1 <ADD> 481dc: 2f0b movel %a3,%sp@- 481de: 2f0a movel %a2,%sp@- 481e0: 4eb9 0004 b248 jsr 4b248 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
481e6: 486e fffc pea %fp@(-4) 481ea: 2f0b movel %a3,%sp@- 481ec: 2f0a movel %a2,%sp@- 481ee: 4eb9 0004 7f88 jsr 47f88 <_Thread_queue_Enqueue_priority> 481f4: 4fef 0018 lea %sp@(24),%sp
}
_ISR_Enable( level );
481f8: 46c2 movew %d2,%sr
} }
481fa: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
48200: 4e5e unlk %fp <== NOT EXECUTED
00048204 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
48204: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
48208: 486e fffc pea %fp@(-4) 4820c: 2f2e 0008 movel %fp@(8),%sp@- 48210: 4eb9 0004 7ae8 jsr 47ae8 <_Thread_Get>
switch ( location ) {
48216: 508f addql #8,%sp 48218: 4aae fffc tstl %fp@(-4)
4821c: 6618 bnes 48236 <_Thread_queue_Timeout+0x32> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4821e: 2f00 movel %d0,%sp@- 48220: 4eb9 0004 b314 jsr 4b314 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
48226: 588f addql #4,%sp 48228: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0 4822e: 5380 subql #1,%d0 48230: 23c0 0005 e9c8 movel %d0,5e9c8 <_Thread_Dispatch_disable_level>
_Thread_Unnest_dispatch();
break;
}
}
48236: 4e5e unlk %fp
...
00052292 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
52292: 4e56 ffb4 linkw %fp,#-76
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
52296: 41ee ffec lea %fp@(-20),%a0 5229a: 200e movel %fp,%d0 5229c: 220e movel %fp,%d1 5229e: 5181 subql #8,%d1 522a0: 0680 ffff fff4 addil #-12,%d0 522a6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 522aa: 246e 0008 moveal %fp@(8),%a2 522ae: 260e movel %fp,%d3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
522b0: 2808 movel %a0,%d4
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
522b2: 2c0a movel %a2,%d6
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
522b4: 0683 ffff ffe8 addil #-24,%d3 522ba: 0686 0000 0040 addil #64,%d6
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
522c0: 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 );
522c2: 240a movel %a2,%d2
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
522c4: 0685 0000 0030 addil #48,%d5 522ca: 47f9 0005 60a8 lea 560a8 <_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 );
522d0: 0682 0000 0068 addil #104,%d2 522d6: 4bf9 0005 6028 lea 56028 <_Watchdog_Adjust>,%a5
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
522dc: 2e01 movel %d1,%d7
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
522de: 2d48 ffe8 movel %a0,%fp@(-24)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
522e2: 41ea 0008 lea %a2@(8),%a0 522e6: 2d41 fff4 movel %d1,%fp@(-12)
head->previous = NULL;
522ea: 42ae fff8 clrl %fp@(-8)
tail->previous = head;
522ee: 2d40 fffc movel %d0,%fp@(-4)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
522f2: 42ae ffec clrl %fp@(-20)
tail->previous = head;
522f6: 2d43 fff0 movel %d3,%fp@(-16) 522fa: 2d48 ffe4 movel %a0,%fp@(-28)
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
522fe: 2d46 ffe0 movel %d6,%fp@(-32)
{
/*
* 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;
52302: 41ee fff4 lea %fp@(-12),%a0
)
{
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 );
52306: 49f9 0005 6138 lea 56138 <_Watchdog_Insert>,%a4
{
/*
* 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;
5230c: 2548 0078 movel %a0,%a2@(120)
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
52310: 2039 0007 7626 movel 77626 <_Watchdog_Ticks_since_boot>,%d0
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
52316: 222a 003c movel %a2@(60),%d1
watchdogs->last_snapshot = snapshot;
5231a: 2540 003c movel %d0,%a2@(60)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
5231e: 9081 subl %d1,%d0 52320: 2f03 movel %d3,%sp@- 52322: 2f00 movel %d0,%sp@- 52324: 2f05 movel %d5,%sp@- 52326: 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();
52328: 2039 0007 75a6 movel 775a6 <_TOD_Now>,%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 ) {
5232e: 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;
52332: 222a 0074 movel %a2@(116),%d1
/*
* 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 ) {
52336: b280 cmpl %d0,%d1
52338: 6412 bccs 5234c <_Timer_server_Body+0xba>
/*
* 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 );
5233a: 2f03 movel %d3,%sp@- 5233c: 2c00 movel %d0,%d6 5233e: 9c81 subl %d1,%d6 52340: 2f06 movel %d6,%sp@- 52342: 2d40 ffdc movel %d0,%fp@(-36) 52346: 2f02 movel %d2,%sp@- 52348: 4e93 jsr %a3@ 5234a: 6014 bras 52360 <_Timer_server_Body+0xce>
} else if ( snapshot < last_snapshot ) {
5234c: b280 cmpl %d0,%d1
5234e: 6318 blss 52368 <_Timer_server_Body+0xd6>
/*
* 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 );
52350: 9280 subl %d0,%d1 52352: 2f01 movel %d1,%sp@- 52354: 4878 0001 pea 1 <ADD> 52358: 2d40 ffdc movel %d0,%fp@(-36) 5235c: 2f02 movel %d2,%sp@- 5235e: 4e95 jsr %a5@ 52360: 202e ffdc movel %fp@(-36),%d0 52364: 4fef 000c lea %sp@(12),%sp
}
watchdogs->last_snapshot = snapshot;
52368: 2540 0074 movel %d0,%a2@(116)
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
5236c: 202a 0078 movel %a2@(120),%d0 52370: 2f00 movel %d0,%sp@- 52372: 4eb9 0005 2d84 jsr 52d84 <_Chain_Get>
if ( timer == NULL ) {
52378: 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 );
5237a: 2040 moveal %d0,%a0
if ( timer == NULL ) {
5237c: 4a80 tstl %d0
5237e: 6724 beqs 523a4 <_Timer_server_Body+0x112>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
52380: 2028 0038 movel %a0@(56),%d0 52384: 7201 moveq #1,%d1 52386: b280 cmpl %d0,%d1
52388: 6608 bnes 52392 <_Timer_server_Body+0x100>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
5238a: 4868 0010 pea %a0@(16) 5238e: 2f05 movel %d5,%sp@- 52390: 600c bras 5239e <_Timer_server_Body+0x10c>
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
52392: 7c03 moveq #3,%d6 52394: bc80 cmpl %d0,%d6
52396: 66d4 bnes 5236c <_Timer_server_Body+0xda> <== NEVER TAKEN
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
52398: 4868 0010 pea %a0@(16) 5239c: 2f02 movel %d2,%sp@- 5239e: 4e94 jsr %a4@ 523a0: 508f addql #8,%sp 523a2: 60c8 bras 5236c <_Timer_server_Body+0xda>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
523a4: 203c 0000 0700 movel #1792,%d0 523aa: 40c1 movew %sr,%d1 523ac: 8081 orl %d1,%d0 523ae: 46c0 movew %d0,%sr
if ( _Chain_Is_empty( insert_chain ) ) {
523b0: beae fff4 cmpl %fp@(-12),%d7
523b4: 6614 bnes 523ca <_Timer_server_Body+0x138> <== NEVER TAKEN
ts->insert_chain = NULL;
523b6: 42aa 0078 clrl %a2@(120)
_ISR_Enable( level );
523ba: 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 );
523bc: 2c3c 0000 0700 movel #1792,%d6
_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 ) ) {
523c2: b8ae ffe8 cmpl %fp@(-24),%d4
523c6: 6608 bnes 523d0 <_Timer_server_Body+0x13e>
523c8: 6042 bras 5240c <_Timer_server_Body+0x17a>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
523ca: 46c1 movew %d1,%sr <== NOT EXECUTED 523cc: 6000 ff42 braw 52310 <_Timer_server_Body+0x7e> <== 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 );
523d0: 2006 movel %d6,%d0 523d2: 40c1 movew %sr,%d1 523d4: 8081 orl %d1,%d0 523d6: 46c0 movew %d0,%sr
initialized = false;
}
#endif
return status;
}
523d8: 206e ffe8 moveal %fp@(-24),%a0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
523dc: b888 cmpl %a0,%d4
523de: 6726 beqs 52406 <_Timer_server_Body+0x174>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
523e0: 2250 moveal %a0@,%a1
head->next = new_first;
523e2: 2d49 ffe8 movel %a1,%fp@(-24)
new_first->previous = head;
523e6: 2343 0004 movel %d3,%a1@(4)
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
523ea: 4a88 tstl %a0
523ec: 6718 beqs 52406 <_Timer_server_Body+0x174> <== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
523ee: 42a8 0008 clrl %a0@(8)
_ISR_Enable( level );
523f2: 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 );
523f4: 2f28 0024 movel %a0@(36),%sp@- 523f8: 2f28 0020 movel %a0@(32),%sp@- 523fc: 2068 001c moveal %a0@(28),%a0 52400: 4e90 jsr %a0@
}
52402: 508f addql #8,%sp 52404: 60ca bras 523d0 <_Timer_server_Body+0x13e>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
52406: 46c1 movew %d1,%sr 52408: 6000 fef8 braw 52302 <_Timer_server_Body+0x70>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
5240c: 49f9 0005 6260 lea 56260 <_Watchdog_Remove>,%a4
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
52412: 4200 clrb %d0 52414: 1540 007c moveb %d0,%a2@(124)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
52418: 4eba fd9e jsr %pc@(521b8 <_Thread_Disable_dispatch>)
_Thread_Set_state( ts->thread, STATES_DELAYING );
5241c: 4878 0008 pea 8 <DIVIDE_BY_ZERO> 52420: 2f12 movel %a2@,%sp@- 52422: 4eb9 0005 5a84 jsr 55a84 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
52428: 2f0a movel %a2,%sp@- 5242a: 4eba fda2 jsr %pc@(521ce <_Timer_server_Reset_interval_system_watchdog>)
_Timer_server_Reset_tod_system_watchdog( ts );
5242e: 2f0a movel %a2,%sp@- 52430: 4eba fdfc jsr %pc@(5222e <_Timer_server_Reset_tod_system_watchdog>)
_Thread_Enable_dispatch();
52434: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
ts->active = true;
5243a: 7201 moveq #1,%d1 5243c: 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 );
52440: 2f2e ffe4 movel %fp@(-28),%sp@- 52444: 4e94 jsr %a4@
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
52446: 2f2e ffe0 movel %fp@(-32),%sp@- 5244a: 4e94 jsr %a4@ 5244c: 4fef 0018 lea %sp@(24),%sp 52450: 6000 feb0 braw 52302 <_Timer_server_Body+0x70>
00052454 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
52454: 4e56 fff0 linkw %fp,#-16 52458: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 5245c: 246e 0008 moveal %fp@(8),%a2 52460: 266e 000c moveal %fp@(12),%a3
if ( ts->insert_chain == NULL ) {
52464: 202a 0078 movel %a2@(120),%d0 52468: 6600 00ea bnew 52554 <_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();
5246c: 4eba fd4a jsr %pc@(521b8 <_Thread_Disable_dispatch>)
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
52470: 202b 0038 movel %a3@(56),%d0 52474: 7201 moveq #1,%d1 52476: b280 cmpl %d0,%d1
52478: 665c bnes 524d6 <_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 );
5247a: 203c 0000 0700 movel #1792,%d0 52480: 40c2 movew %sr,%d2 52482: 8082 orl %d2,%d0 52484: 46c0 movew %d0,%sr
snapshot = _Watchdog_Ticks_since_boot;
52486: 2039 0007 7626 movel 77626 <_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 );
5248c: 43ea 0034 lea %a2@(52),%a1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
52490: 222a 003c movel %a2@(60),%d1
initialized = false;
}
#endif
return status;
}
52494: 206a 0030 moveal %a2@(48),%a0
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
52498: b3c8 cmpal %a0,%a1
5249a: 6716 beqs 524b2 <_Timer_server_Schedule_operation_method+0x5e>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
5249c: 2240 moveal %d0,%a1 5249e: 93c1 subal %d1,%a1
delta_interval = first_watchdog->delta_interval;
524a0: 2228 0010 movel %a0@(16),%d1
if (delta_interval > delta) {
524a4: b3c1 cmpal %d1,%a1
524a6: 6404 bccs 524ac <_Timer_server_Schedule_operation_method+0x58>
delta_interval -= delta;
524a8: 9289 subl %a1,%d1 524aa: 6002 bras 524ae <_Timer_server_Schedule_operation_method+0x5a>
} else {
delta_interval = 0;
524ac: 4281 clrl %d1
}
first_watchdog->delta_interval = delta_interval;
524ae: 2141 0010 movel %d1,%a0@(16)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
524b2: 2540 003c movel %d0,%a2@(60)
_ISR_Enable( level );
524b6: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
524b8: 486b 0010 pea %a3@(16) 524bc: 486a 0030 pea %a2@(48) 524c0: 4eb9 0005 6138 jsr 56138 <_Watchdog_Insert>
if ( !ts->active ) {
524c6: 508f addql #8,%sp 524c8: 102a 007c moveb %a2@(124),%d0
524cc: 6678 bnes 52546 <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_interval_system_watchdog( ts );
524ce: 2f0a movel %a2,%sp@- 524d0: 4eba fcfc jsr %pc@(521ce <_Timer_server_Reset_interval_system_watchdog>) 524d4: 606e bras 52544 <_Timer_server_Schedule_operation_method+0xf0>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
524d6: 7203 moveq #3,%d1 524d8: b280 cmpl %d0,%d1
524da: 666a bnes 52546 <_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 );
524dc: 203c 0000 0700 movel #1792,%d0 524e2: 40c2 movew %sr,%d2 524e4: 8082 orl %d2,%d0 524e6: 46c0 movew %d0,%sr 524e8: 200a movel %a2,%d0 524ea: 0680 0000 006c addil #108,%d0
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
524f0: 2239 0007 75a6 movel 775a6 <_TOD_Now>,%d1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
524f6: 226a 0074 moveal %a2@(116),%a1
initialized = false;
}
#endif
return status;
}
524fa: 206a 0068 moveal %a2@(104),%a0
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
524fe: b088 cmpl %a0,%d0
52500: 6720 beqs 52522 <_Timer_server_Schedule_operation_method+0xce>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
52502: 2028 0010 movel %a0@(16),%d0
if ( snapshot > last_snapshot ) {
52506: b3c1 cmpal %d1,%a1
52508: 640c bccs 52516 <_Timer_server_Schedule_operation_method+0xc2>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
5250a: 2841 moveal %d1,%a4 5250c: 99c9 subal %a1,%a4
if (delta_interval > delta) {
5250e: b9c0 cmpal %d0,%a4
52510: 640a bccs 5251c <_Timer_server_Schedule_operation_method+0xc8><== NEVER TAKEN
delta_interval -= delta;
52512: 908c subl %a4,%d0 52514: 6008 bras 5251e <_Timer_server_Schedule_operation_method+0xca>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
52516: d089 addl %a1,%d0
delta_interval += delta;
52518: 9081 subl %d1,%d0 5251a: 6002 bras 5251e <_Timer_server_Schedule_operation_method+0xca>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
5251c: 4280 clrl %d0 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
5251e: 2140 0010 movel %d0,%a0@(16)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
52522: 2541 0074 movel %d1,%a2@(116)
_ISR_Enable( level );
52526: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
52528: 486b 0010 pea %a3@(16) 5252c: 486a 0068 pea %a2@(104) 52530: 4eb9 0005 6138 jsr 56138 <_Watchdog_Insert>
if ( !ts->active ) {
52536: 508f addql #8,%sp 52538: 102a 007c moveb %a2@(124),%d0
5253c: 6608 bnes 52546 <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_tod_system_watchdog( ts );
5253e: 2f0a movel %a2,%sp@- 52540: 4eba fcec jsr %pc@(5222e <_Timer_server_Reset_tod_system_watchdog>) 52544: 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 );
}
}
52546: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 5254c: 4e5e unlk %fp
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
5254e: 4ef9 0005 526e jmp 5526e <_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 );
52554: 202a 0078 movel %a2@(120),%d0 52558: 2d4b 000c movel %a3,%fp@(12)
} }
5255c: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
* 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 );
52562: 2d40 0008 movel %d0,%fp@(8)
} }
52566: 4e5e unlk %fp
* 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 );
52568: 4ef9 0005 2d24 jmp 52d24 <_Chain_Append>
0004860e <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
4860e: 4e56 fff0 linkw %fp,#-16 48612: 48d7 041c moveml %d2-%d4/%a2,%sp@
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
48616: 4282 clrl %d2 48618: 142e 000f moveb %fp@(15),%d2
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
4861c: 282e 0008 movel %fp@(8),%d4 48620: 262e 0010 movel %fp@(16),%d3
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
48624: 2479 0005 eb20 moveal 5eb20 <_User_extensions_List+0x8>,%a2
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
4862a: 6018 bras 48644 <_User_extensions_Fatal+0x36>
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
4862c: 206a 0030 moveal %a2@(48),%a0 48630: 4a88 tstl %a0
48632: 670c beqs 48640 <_User_extensions_Fatal+0x32>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
48634: 2f03 movel %d3,%sp@- 48636: 2f02 movel %d2,%sp@- 48638: 2f04 movel %d4,%sp@- 4863a: 4e90 jsr %a0@
4863c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
48640: 246a 0004 moveal %a2@(4),%a2
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
48644: b5fc 0005 eb18 cmpal #387864,%a2
4864a: 66e0 bnes 4862c <_User_extensions_Fatal+0x1e> <== ALWAYS TAKEN
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
4864c: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 <== NOT EXECUTED 48652: 4e5e unlk %fp <== NOT EXECUTED
...
000484e8 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
484e8: 4e56 ffe8 linkw %fp,#-24
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
484ec: 203c 0005 eb1c movel #387868,%d0 484f2: 23c0 0005 eb18 movel %d0,5eb18 <_User_extensions_List>
head->previous = NULL; tail->previous = head;
484f8: 203c 0005 eb18 movel #387864,%d0 484fe: 23c0 0005 eb20 movel %d0,5eb20 <_User_extensions_List+0x8>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48504: 203c 0005 e9d0 movel #387536,%d0 4850a: 23c0 0005 e9cc movel %d0,5e9cc <_User_extensions_Switches_list>
head->previous = NULL; tail->previous = head;
48510: 203c 0005 e9cc movel #387532,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
48516: 42b9 0005 eb1c clrl 5eb1c <_User_extensions_List+0x4> 4851c: 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;
48520: 2839 0005 d10a movel 5d10a <Configuration+0x36>,%d4
initial_extensions = Configuration.User_extension_table;
48526: 2639 0005 d10e movel 5d10e <Configuration+0x3a>,%d3 4852c: 42b9 0005 e9d0 clrl 5e9d0 <_User_extensions_Switches_list+0x4>
tail->previous = head;
48532: 23c0 0005 e9d4 movel %d0,5e9d4 <_User_extensions_Switches_list+0x8>
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
48538: 4a83 tstl %d3
4853a: 6754 beqs 48590 <_User_extensions_Handler_initialization+0xa8><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
4853c: 7434 moveq #52,%d2 4853e: 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;
48542: 49f9 0004 d37c lea 4d37c <memcpy>,%a4
_User_extensions_Add_set( extension );
48548: 47f9 0004 b3d8 lea 4b3d8 <_User_extensions_Add_set>,%a3 4854e: 2f02 movel %d2,%sp@- 48550: 4eb9 0004 8a0e jsr 48a0e <_Workspace_Allocate_or_fatal_error> 48556: 2440 moveal %d0,%a2
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
48558: 2f02 movel %d2,%sp@-
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
4855a: 4282 clrl %d2
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
4855c: 42a7 clrl %sp@- 4855e: 2f00 movel %d0,%sp@- 48560: 4eb9 0004 d3ec jsr 4d3ec <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
48566: 4fef 0010 lea %sp@(16),%sp 4856a: 6020 bras 4858c <_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;
4856c: 4878 0020 pea 20 <OPER2+0xc> 48570: 5282 addql #1,%d2 48572: 2f03 movel %d3,%sp@- 48574: 486a 0014 pea %a2@(20) 48578: 0683 0000 0020 addil #32,%d3 4857e: 4e94 jsr %a4@
_User_extensions_Add_set( extension );
48580: 2f0a movel %a2,%sp@-
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
48582: 45ea 0034 lea %a2@(52),%a2 48586: 4e93 jsr %a3@
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
48588: 4fef 0010 lea %sp@(16),%sp 4858c: b882 cmpl %d2,%d4
4858e: 62dc bhis 4856c <_User_extensions_Handler_initialization+0x84>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
48590: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 48596: 4e5e unlk %fp
...
00049c38 <_Watchdog_Adjust>:
Watchdog_Interval units
)
{
ISR_Level level;
_ISR_Disable( level );
49c38: 327c 0700 moveaw #1792,%a1 49c3c: 2209 movel %a1,%d1
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
49c3e: 4e56 ffe8 linkw %fp,#-24 49c42: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@ 49c46: 266e 0008 moveal %fp@(8),%a3 49c4a: 262e 000c movel %fp@(12),%d3 49c4e: 242e 0010 movel %fp@(16),%d2
ISR_Level level;
_ISR_Disable( level );
49c52: 40c0 movew %sr,%d0 49c54: 8280 orl %d0,%d1 49c56: 46c1 movew %d1,%sr
}
}
_ISR_Enable( level );
}
49c58: 244b moveal %a3,%a2 49c5a: 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 ) ) {
49c5c: b5c8 cmpal %a0,%a2
49c5e: 674c beqs 49cac <_Watchdog_Adjust+0x74>
switch ( direction ) {
49c60: 4a83 tstl %d3
49c62: 673c beqs 49ca0 <_Watchdog_Adjust+0x68>
49c64: 7201 moveq #1,%d1 49c66: b283 cmpl %d3,%d1
49c68: 6642 bnes 49cac <_Watchdog_Adjust+0x74> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
49c6a: d5a8 0010 addl %d2,%a0@(16)
break;
49c6e: 603c bras 49cac <_Watchdog_Adjust+0x74>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
49c70: 2053 moveal %a3@,%a0
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
49c72: 2628 0010 movel %a0@(16),%d3 49c76: b682 cmpl %d2,%d3
49c78: 6308 blss 49c82 <_Watchdog_Adjust+0x4a>
_Watchdog_First( header )->delta_interval -= units;
49c7a: 9682 subl %d2,%d3 49c7c: 2143 0010 movel %d3,%a0@(16)
break;
49c80: 602a bras 49cac <_Watchdog_Adjust+0x74>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
49c82: 7201 moveq #1,%d1 49c84: 2141 0010 movel %d1,%a0@(16)
_ISR_Enable( level );
49c88: 46c0 movew %d0,%sr
_Watchdog_Tickle( header );
49c8a: 2f0b movel %a3,%sp@- 49c8c: 4e94 jsr %a4@
_ISR_Disable( level );
49c8e: 2204 movel %d4,%d1 49c90: 40c0 movew %sr,%d0 49c92: 8280 orl %d0,%d1 49c94: 46c1 movew %d1,%sr
if ( _Chain_Is_empty( header ) )
49c96: 588f addql #4,%sp 49c98: b5d3 cmpal %a3@,%a2
49c9a: 6710 beqs 49cac <_Watchdog_Adjust+0x74>
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
49c9c: 9483 subl %d3,%d2 49c9e: 6008 bras 49ca8 <_Watchdog_Adjust+0x70>
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
_Watchdog_Tickle( header );
49ca0: 49f9 0004 9e5c lea 49e5c <_Watchdog_Tickle>,%a4
_ISR_Disable( level );
49ca6: 2809 movel %a1,%d4
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
49ca8: 4a82 tstl %d2
49caa: 66c4 bnes 49c70 <_Watchdog_Adjust+0x38> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
49cac: 46c0 movew %d0,%sr
}
49cae: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
49cb4: 4e5e unlk %fp <== NOT EXECUTED
00048880 <_Watchdog_Remove>:
{
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
48880: 203c 0000 0700 movel #1792,%d0
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
48886: 4e56 0000 linkw %fp,#0 4888a: 206e 0008 moveal %fp@(8),%a0 4888e: 2f0a movel %a2,%sp@- 48890: 2f02 movel %d2,%sp@-
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
48892: 40c1 movew %sr,%d1 48894: 8081 orl %d1,%d0 48896: 46c0 movew %d0,%sr
previous_state = the_watchdog->state;
48898: 2028 0008 movel %a0@(8),%d0
switch ( previous_state ) {
4889c: 7401 moveq #1,%d2 4889e: b480 cmpl %d0,%d2
488a0: 670c beqs 488ae <_Watchdog_Remove+0x2e> 488a2: 6242 bhis 488e6 <_Watchdog_Remove+0x66>
488a4: 143c 0003 moveb #3,%d2 488a8: b480 cmpl %d0,%d2
488aa: 653a bcss 488e6 <_Watchdog_Remove+0x66> <== NEVER TAKEN
488ac: 6006 bras 488b4 <_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;
488ae: 42a8 0008 clrl %a0@(8)
break;
488b2: 6032 bras 488e6 <_Watchdog_Remove+0x66>
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
488b4: 2250 moveal %a0@,%a1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
488b6: 42a8 0008 clrl %a0@(8)
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
488ba: 4a91 tstl %a1@
488bc: 6708 beqs 488c6 <_Watchdog_Remove+0x46>
next_watchdog->delta_interval += the_watchdog->delta_interval;
488be: 2428 0010 movel %a0@(16),%d2 488c2: d5a9 0010 addl %d2,%a1@(16)
if ( _Watchdog_Sync_count )
488c6: 2479 0005 eace moveal 5eace <_Watchdog_Sync_count>,%a2 488cc: 4a8a tstl %a2
488ce: 670c beqs 488dc <_Watchdog_Remove+0x5c>
_Watchdog_Sync_level = _ISR_Nest_level;
488d0: 45f9 0005 ee2e lea 5ee2e <_Per_CPU_Information+0x8>,%a2 488d6: 23d2 0005 ea6c movel %a2@,5ea6c <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
488dc: 2468 0004 moveal %a0@(4),%a2
next->previous = previous;
488e0: 234a 0004 movel %a2,%a1@(4)
previous->next = next;
488e4: 2489 movel %a1,%a2@
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
488e6: 2279 0005 ead2 moveal 5ead2 <_Watchdog_Ticks_since_boot>,%a1 488ec: 2149 0018 movel %a1,%a0@(24)
_ISR_Enable( level );
488f0: 46c1 movew %d1,%sr
return( previous_state ); }
488f2: 241f movel %sp@+,%d2 488f4: 245f moveal %sp@+,%a2 488f6: 4e5e unlk %fp
...
00049830 <_Watchdog_Report_chain>:
)
{
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
49830: 203c 0000 0700 movel #1792,%d0
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
49836: 4e56 ffec linkw %fp,#-20 4983a: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 4983e: 242e 0008 movel %fp@(8),%d2 49842: 266e 000c moveal %fp@(12),%a3
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
49846: 40c3 movew %sr,%d3 49848: 8083 orl %d3,%d0 4984a: 46c0 movew %d0,%sr
printk( "Watchdog Chain: %s %p\n", name, header );
4984c: 2f0b movel %a3,%sp@- 4984e: 49f9 0004 404c lea 4404c <printk>,%a4 49854: 2f02 movel %d2,%sp@- 49856: 4879 0005 dd1a pea 5dd1a <_Status_Object_name_errors_to_status+0x14> 4985c: 4e94 jsr %a4@
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
4985e: 245b moveal %a3@+,%a2
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
49860: 4fef 000c lea %sp@(12),%sp 49864: b7ca cmpal %a2,%a3
49866: 6726 beqs 4988e <_Watchdog_Report_chain+0x5e>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
49868: 49f9 0004 98a4 lea 498a4 <_Watchdog_Report>,%a4 4986e: 2f0a movel %a2,%sp@- 49870: 42a7 clrl %sp@- 49872: 4e94 jsr %a4@
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
49874: 2452 moveal %a2@,%a2
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
49876: 508f addql #8,%sp 49878: b7ca cmpal %a2,%a3
4987a: 66f2 bnes 4986e <_Watchdog_Report_chain+0x3e> <== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
4987c: 2f02 movel %d2,%sp@- 4987e: 4879 0005 dd31 pea 5dd31 <_Status_Object_name_errors_to_status+0x2b> 49884: 4eb9 0004 404c jsr 4404c <printk> 4988a: 508f addql #8,%sp 4988c: 600a bras 49898 <_Watchdog_Report_chain+0x68>
} else {
printk( "Chain is empty\n" );
4988e: 4879 0005 dd40 pea 5dd40 <_Status_Object_name_errors_to_status+0x3a> 49894: 4e94 jsr %a4@ 49896: 588f addql #4,%sp
}
_ISR_Enable( level );
49898: 46c3 movew %d3,%sr
}
4989a: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
498a0: 4e5e unlk %fp <== NOT EXECUTED
000488fc <_Watchdog_Tickle>:
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
488fc: 203c 0000 0700 movel #1792,%d0
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
48902: 4e56 ffe8 linkw %fp,#-24 48906: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@ 4890a: 286e 0008 moveal %fp@(8),%a4
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
4890e: 40c2 movew %sr,%d2 48910: 8082 orl %d2,%d0 48912: 46c0 movew %d0,%sr
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
48914: 264c moveal %a4,%a3 48916: 245b moveal %a3@+,%a2
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
48918: b7ca cmpal %a2,%a3
4891a: 674c beqs 48968 <_Watchdog_Tickle+0x6c>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
4891c: 202a 0010 movel %a2@(16),%d0
48920: 6708 beqs 4892a <_Watchdog_Tickle+0x2e>
the_watchdog->delta_interval--;
48922: 5380 subql #1,%d0 48924: 2540 0010 movel %d0,%a2@(16)
if ( the_watchdog->delta_interval != 0 )
48928: 663e bnes 48968 <_Watchdog_Tickle+0x6c>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
4892a: 4bf9 0004 8880 lea 48880 <_Watchdog_Remove>,%a5
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
48930: 263c 0000 0700 movel #1792,%d3
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
48936: 2f0a movel %a2,%sp@- 48938: 4e95 jsr %a5@
_ISR_Enable( level );
4893a: 46c2 movew %d2,%sr
switch( watchdog_state ) {
4893c: 7202 moveq #2,%d1 4893e: 588f addql #4,%sp 48940: b280 cmpl %d0,%d1
48942: 6610 bnes 48954 <_Watchdog_Tickle+0x58> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
48944: 2f2a 0024 movel %a2@(36),%sp@- 48948: 2f2a 0020 movel %a2@(32),%sp@- 4894c: 206a 001c moveal %a2@(28),%a0 48950: 4e90 jsr %a0@
the_watchdog->id,
the_watchdog->user_data
);
break;
48952: 508f addql #8,%sp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
48954: 2003 movel %d3,%d0 48956: 40c2 movew %sr,%d2 48958: 8082 orl %d2,%d0 4895a: 46c0 movew %d0,%sr
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
4895c: 2454 moveal %a4@,%a2
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
4895e: b7ca cmpal %a2,%a3
48960: 6706 beqs 48968 <_Watchdog_Tickle+0x6c>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
48962: 4aaa 0010 tstl %a2@(16)
48966: 67ce beqs 48936 <_Watchdog_Tickle+0x3a>
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
48968: 46c2 movew %d2,%sr
}
4896a: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
48970: 4e5e unlk %fp <== NOT EXECUTED
0005a780 <_calloc_r>:
void *_calloc_r(
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
5a780: 4e56 0000 linkw %fp,#0 5a784: 202e 000c movel %fp@(12),%d0
return calloc( elements, size );
5a788: 2d6e 0010 000c movel %fp@(16),%fp@(12) 5a78e: 2d40 0008 movel %d0,%fp@(8)
}
5a792: 4e5e unlk %fp
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
return calloc( elements, size );
5a794: 4ef9 0004 2654 jmp 42654 <calloc>
...
00043e38 <_chown_helper>:
const char *path,
uid_t owner,
gid_t group,
int follow_link
)
{
43e38: 4e56 ffd8 linkw %fp,#-40 43e3c: 48d7 003c moveml %d2-%d5,%sp@ 43e40: 262e 0008 movel %fp@(8),%d3
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
43e44: 240e movel %fp,%d2 43e46: 0682 ffff ffec addil #-20,%d2 43e4c: 2f03 movel %d3,%sp@-
const char *path,
uid_t owner,
gid_t group,
int follow_link
)
{
43e4e: 382e 000e movew %fp@(14),%d4
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
43e52: 4eb9 0005 0778 jsr 50778 <strlen> 43e58: 2eae 0014 movel %fp@(20),%sp@ 43e5c: 2f02 movel %d2,%sp@-
const char *path,
uid_t owner,
gid_t group,
int follow_link
)
{
43e5e: 3a2e 0012 movew %fp@(18),%d5
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
43e62: 42a7 clrl %sp@- 43e64: 2f00 movel %d0,%sp@- 43e66: 2f03 movel %d3,%sp@- 43e68: 4eb9 0004 413c jsr 4413c <rtems_filesystem_evaluate_path> 43e6e: 4fef 0014 lea %sp@(20),%sp 43e72: 4a80 tstl %d0
43e74: 662a bnes 43ea0 <_chown_helper+0x68> <== NEVER TAKEN
return -1;
result = (*loc.ops->chown_h)( &loc, owner, group );
43e76: 206e fff8 moveal %fp@(-8),%a0 43e7a: 3f05 movew %d5,%sp@- 43e7c: 4267 clrw %sp@- 43e7e: 3f04 movew %d4,%sp@- 43e80: 4267 clrw %sp@- 43e82: 2f02 movel %d2,%sp@- 43e84: 2068 0018 moveal %a0@(24),%a0 43e88: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
43e8a: 2f02 movel %d2,%sp@- 43e8c: 2d40 ffe8 movel %d0,%fp@(-24) 43e90: 4eb9 0004 4208 jsr 44208 <rtems_filesystem_freenode>
return result;
43e96: 202e ffe8 movel %fp@(-24),%d0 43e9a: 4fef 0010 lea %sp@(16),%sp 43e9e: 6002 bras 43ea2 <_chown_helper+0x6a>
{
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
return -1;
43ea0: 70ff moveq #-1,%d0
result = (*loc.ops->chown_h)( &loc, owner, group );
rtems_filesystem_freenode( &loc );
return result;
}
43ea2: 4cee 003c ffd8 moveml %fp@(-40),%d2-%d5
43ea8: 4e5e unlk %fp <== NOT EXECUTED
000499c0 <_close_r>:
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
499c0: 4e56 0000 linkw %fp,#0
return close( fd );
499c4: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
499ca: 4e5e unlk %fp
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return close( fd );
499cc: 4ef9 0004 9950 jmp 49950 <close>
...
000431b8 <_exit>:
extern void FINI_SYMBOL( void );
#endif
void EXIT_SYMBOL(int status)
{
431b8: 4e56 0000 linkw %fp,#0
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
FINI_SYMBOL();
431bc: 4eb9 0005 b2a8 jsr 5b2a8 <_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();
431c2: 4eb9 0004 3154 jsr 43154 <libc_wrapup>
rtems_shutdown_executive(status);
431c8: 2f2e 0008 movel %fp@(8),%sp@- 431cc: 4eb9 0004 5e94 jsr 45e94 <rtems_shutdown_executive>
...
0005a79c <_free_r>:
void _free_r(
struct _reent *ignored __attribute__((unused)),
void *ptr
)
{
5a79c: 4e56 0000 linkw %fp,#0
free( ptr );
5a7a0: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
5a7a6: 4e5e unlk %fp
void _free_r(
struct _reent *ignored __attribute__((unused)),
void *ptr
)
{
free( ptr );
5a7a8: 4ef9 0004 29ec jmp 429ec <free>
...
0005a870 <_isatty_r>:
int _isatty_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
5a870: 4e56 0000 linkw %fp,#0
return isatty( fd );
5a874: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
5a87a: 4e5e unlk %fp
int _isatty_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return isatty( fd );
5a87c: 4ef9 0005 b200 jmp 5b200 <isatty>
...
00045c88 <_link_r>:
int _link_r(
struct _reent *ptr __attribute__((unused)),
const char *existing,
const char *new
)
{
45c88: 4e56 0000 linkw %fp,#0 45c8c: 202e 000c movel %fp@(12),%d0
return link( existing, new );
45c90: 2d6e 0010 000c movel %fp@(16),%fp@(12) 45c96: 2d40 0008 movel %d0,%fp@(8)
}
45c9a: 4e5e unlk %fp
struct _reent *ptr __attribute__((unused)),
const char *existing,
const char *new
)
{
return link( existing, new );
45c9c: 4ef9 0004 5bb0 jmp 45bb0 <link>
...
0005a95c <_lseek_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
off_t offset,
int whence
)
{
5a95c: 4e56 0000 linkw %fp,#0 5a960: 206e 000c moveal %fp@(12),%a0 5a964: 202e 0010 movel %fp@(16),%d0 5a968: 222e 0014 movel %fp@(20),%d1
return lseek( fd, offset, whence );
5a96c: 2d6e 0018 0014 movel %fp@(24),%fp@(20) 5a972: 2d40 000c movel %d0,%fp@(12) 5a976: 2d41 0010 movel %d1,%fp@(16) 5a97a: 2d48 0008 movel %a0,%fp@(8)
}
5a97e: 4e5e unlk %fp
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
5a980: 4ef9 0005 a884 jmp 5a884 <lseek>
...
0005a988 <_malloc_r>:
void *_malloc_r(
struct _reent *ignored __attribute__((unused)),
size_t size
)
{
5a988: 4e56 0000 linkw %fp,#0
return malloc( size );
5a98c: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
5a992: 4e5e unlk %fp
void *_malloc_r(
struct _reent *ignored __attribute__((unused)),
size_t size
)
{
return malloc( size );
5a994: 4ef9 0004 2cd4 jmp 42cd4 <malloc>
...
0005aa38 <_read_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
void *buf,
size_t nbytes
)
{
5aa38: 4e56 0000 linkw %fp,#0 5aa3c: 222e 0010 movel %fp@(16),%d1 5aa40: 202e 000c movel %fp@(12),%d0
return read( fd, buf, nbytes );
5aa44: 2d6e 0014 0010 movel %fp@(20),%fp@(16) 5aa4a: 2d41 000c movel %d1,%fp@(12) 5aa4e: 2d40 0008 movel %d0,%fp@(8)
}
5aa52: 4e5e unlk %fp
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
5aa54: 4ef9 0005 a99c jmp 5a99c <read>
...
0005aa5c <_realloc_r>:
void *_realloc_r(
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
5aa5c: 4e56 0000 linkw %fp,#0 5aa60: 202e 000c movel %fp@(12),%d0
return realloc( ptr, size );
5aa64: 2d6e 0010 000c movel %fp@(16),%fp@(12) 5aa6a: 2d40 0008 movel %d0,%fp@(8)
}
5aa6e: 4e5e unlk %fp
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
5aa70: 4ef9 0005 aabc jmp 5aabc <realloc>
...
000469bc <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
469bc: 4e56 ffa4 linkw %fp,#-92 469c0: 48d7 047c moveml %d2-%d6/%a2,%sp@ 469c4: 262e 000c movel %fp@(12),%d3 469c8: 2c2e 0010 movel %fp@(16),%d6
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
469cc: 2f03 movel %d3,%sp@- 469ce: 4eb9 0004 55b0 jsr 455b0 <rtems_filesystem_dirname>
if ( old_parent_pathlen == 0 )
469d4: 588f addql #4,%sp
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
469d6: 2440 moveal %d0,%a2 469d8: 200e movel %fp,%d0 469da: 0680 ffff ffd0 addil #-48,%d0
if ( old_parent_pathlen == 0 )
469e0: 4a8a tstl %a2
469e2: 6616 bnes 469fa <_rename_r+0x3e>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
469e4: 2f00 movel %d0,%sp@- 469e6: 486e fffc pea %fp@(-4)
rtems_filesystem_location_info_t old_parent_loc; rtems_filesystem_location_info_t new_parent_loc; int i; int result; const char *name; bool free_old_parentloc = false;
469ea: 4204 clrb %d4
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
if ( old_parent_pathlen == 0 )
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
469ec: 2f03 movel %d3,%sp@- 469ee: 4eb9 0004 6d18 jsr 46d18 <rtems_filesystem_get_start_loc> 469f4: 4fef 000c lea %sp@(12),%sp 469f8: 601e bras 46a18 <_rename_r+0x5c>
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
469fa: 42a7 clrl %sp@- 469fc: 2f00 movel %d0,%sp@- 469fe: 4878 0002 pea 2 <DOUBLE_FLOAT> 46a02: 2f0a movel %a2,%sp@- 46a04: 2f03 movel %d3,%sp@- 46a06: 4eb9 0004 5564 jsr 45564 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
46a0c: 4fef 0014 lea %sp@(20),%sp 46a10: 4a80 tstl %d0 46a12: 6600 012e bnew 46b42 <_rename_r+0x186>
return -1;
free_old_parentloc = true;
46a16: 7801 moveq #1,%d4
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
46a18: 4878 0014 pea 14 <OPER2> 46a1c: 240e movel %fp,%d2 46a1e: 0682 ffff ffd0 addil #-48,%d2 46a24: 2a0e movel %fp,%d5 46a26: 0685 ffff ffe4 addil #-28,%d5
name = old + old_parent_pathlen;
46a2c: d68a addl %a2,%d3
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
46a2e: 45f9 0005 3240 lea 53240 <strlen>,%a2
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
46a34: 2f02 movel %d2,%sp@- 46a36: 2f05 movel %d5,%sp@- 46a38: 4eb9 0005 1b5c jsr 51b5c <memcpy>
name = old + old_parent_pathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
46a3e: 2f03 movel %d3,%sp@-
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
46a40: 2d43 fff8 movel %d3,%fp@(-8)
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
46a44: 4e92 jsr %a2@ 46a46: 2e80 movel %d0,%sp@ 46a48: 2f03 movel %d3,%sp@- 46a4a: 4eb9 0004 55f2 jsr 455f2 <rtems_filesystem_prefix_separators> 46a50: d680 addl %d0,%d3
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
46a52: 2f03 movel %d3,%sp@-
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
46a54: 2d43 fff8 movel %d3,%fp@(-8)
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
46a58: 4e92 jsr %a2@ 46a5a: 4297 clrl %sp@ 46a5c: 2f05 movel %d5,%sp@- 46a5e: 42a7 clrl %sp@- 46a60: 2f00 movel %d0,%sp@- 46a62: 2f03 movel %d3,%sp@- 46a64: 4eb9 0004 54f4 jsr 454f4 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
46a6a: 4fef 0028 lea %sp@(40),%sp 46a6e: 4a80 tstl %d0
46a70: 670a beqs 46a7c <_rename_r+0xc0>
if ( free_old_parentloc )
46a72: 4a04 tstb %d4 46a74: 6700 00cc beqw 46b42 <_rename_r+0x186>
rtems_filesystem_freenode( &old_parent_loc );
46a78: 2f02 movel %d2,%sp@- 46a7a: 604e bras 46aca <_rename_r+0x10e>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
46a7c: 260e movel %fp,%d3 46a7e: 0683 ffff ffbc addil #-68,%d3 46a84: 2f03 movel %d3,%sp@- 46a86: 486e fffc pea %fp@(-4) 46a8a: 2f06 movel %d6,%sp@- 46a8c: 4eb9 0004 6d18 jsr 46d18 <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
46a92: 486e fff8 pea %fp@(-8) 46a96: dcae fffc addl %fp@(-4),%d6 46a9a: 2f03 movel %d3,%sp@- 46a9c: 206e ffc8 moveal %fp@(-56),%a0 46aa0: 2f06 movel %d6,%sp@- 46aa2: 2068 0004 moveal %a0@(4),%a0 46aa6: 4e90 jsr %a0@
if ( result != 0 ) {
46aa8: 4fef 0018 lea %sp@(24),%sp 46aac: 4a80 tstl %d0
46aae: 6722 beqs 46ad2 <_rename_r+0x116>
rtems_filesystem_freenode( &new_parent_loc );
46ab0: 2f03 movel %d3,%sp@- 46ab2: 45f9 0004 57b8 lea 457b8 <rtems_filesystem_freenode>,%a2 46ab8: 4e92 jsr %a2@
if ( free_old_parentloc )
46aba: 588f addql #4,%sp 46abc: 4a04 tstb %d4
46abe: 6706 beqs 46ac6 <_rename_r+0x10a> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
46ac0: 2f02 movel %d2,%sp@- 46ac2: 4e92 jsr %a2@ 46ac4: 588f addql #4,%sp
rtems_filesystem_freenode( &old_loc );
46ac6: 486e ffe4 pea %fp@(-28) 46aca: 4eb9 0004 57b8 jsr 457b8 <rtems_filesystem_freenode> 46ad0: 6036 bras 46b08 <_rename_r+0x14c>
/*
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
46ad2: 202e ffcc movel %fp@(-52),%d0 46ad6: 45f9 0004 57b8 lea 457b8 <rtems_filesystem_freenode>,%a2 46adc: b0ae ffe0 cmpl %fp@(-32),%d0
46ae0: 672a beqs 46b0c <_rename_r+0x150>
rtems_filesystem_freenode( &new_parent_loc );
46ae2: 2f03 movel %d3,%sp@- 46ae4: 4e92 jsr %a2@
if ( free_old_parentloc )
46ae6: 588f addql #4,%sp 46ae8: 4a04 tstb %d4
46aea: 6706 beqs 46af2 <_rename_r+0x136>
rtems_filesystem_freenode( &old_parent_loc );
46aec: 2f02 movel %d2,%sp@- 46aee: 4e92 jsr %a2@ 46af0: 588f addql #4,%sp
rtems_filesystem_freenode( &old_loc );
46af2: 486e ffe4 pea %fp@(-28) 46af6: 4eb9 0004 57b8 jsr 457b8 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
46afc: 4eb9 0005 02d0 jsr 502d0 <__errno> 46b02: 2040 moveal %d0,%a0 46b04: 7012 moveq #18,%d0 46b06: 2080 movel %d0,%a0@ 46b08: 588f addql #4,%sp 46b0a: 6036 bras 46b42 <_rename_r+0x186>
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
46b0c: 2f2e fff8 movel %fp@(-8),%sp@- 46b10: 206e ffc8 moveal %fp@(-56),%a0 46b14: 2f03 movel %d3,%sp@- 46b16: 2f05 movel %d5,%sp@- 46b18: 2f02 movel %d2,%sp@- 46b1a: 2068 0040 moveal %a0@(64),%a0 46b1e: 4e90 jsr %a0@ 46b20: 2a00 movel %d0,%d5
rtems_filesystem_freenode( &new_parent_loc );
46b22: 2f03 movel %d3,%sp@- 46b24: 4e92 jsr %a2@
if ( free_old_parentloc )
46b26: 4fef 0014 lea %sp@(20),%sp 46b2a: 4a04 tstb %d4
46b2c: 6706 beqs 46b34 <_rename_r+0x178>
rtems_filesystem_freenode( &old_parent_loc );
46b2e: 2f02 movel %d2,%sp@- 46b30: 4e92 jsr %a2@ 46b32: 588f addql #4,%sp
rtems_filesystem_freenode( &old_loc );
46b34: 486e ffe4 pea %fp@(-28) 46b38: 4eb9 0004 57b8 jsr 457b8 <rtems_filesystem_freenode>
return result;
46b3e: 588f addql #4,%sp 46b40: 6002 bras 46b44 <_rename_r+0x188>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
return -1;
46b42: 7aff moveq #-1,%d5
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
return result;
}
46b44: 2005 movel %d5,%d0 46b46: 4cee 047c ffa4 moveml %fp@(-92),%d2-%d6/%a2
46b4c: 4e5e unlk %fp <== NOT EXECUTED
000435b4 <_stat_r>:
int _STAT_R_NAME(
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
435b4: 4e56 0000 linkw %fp,#0 435b8: 202e 000c movel %fp@(12),%d0
return _STAT_NAME( path, buf );
435bc: 2d6e 0010 000c movel %fp@(16),%fp@(12) 435c2: 2d40 0008 movel %d0,%fp@(8)
}
435c6: 4e5e unlk %fp
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
435c8: 4ef9 0004 352c jmp 4352c <stat>
...
0004521c <_times_r>:
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
4521c: 4e56 0000 linkw %fp,#0
return _times( ptms );
45220: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
45226: 4e5e unlk %fp
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
return _times( ptms );
45228: 4ef9 0004 517c jmp 4517c <_times>
...
00045e78 <_unlink_r>:
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
45e78: 4e56 0000 linkw %fp,#0
return unlink( path );
45e7c: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
45e82: 4e5e unlk %fp
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
return unlink( path );
45e84: 4ef9 0004 5d54 jmp 45d54 <unlink>
...
0005aa78 <_write_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
const void *buf,
size_t nbytes
)
{
5aa78: 4e56 0000 linkw %fp,#0 5aa7c: 222e 0010 movel %fp@(16),%d1 5aa80: 202e 000c movel %fp@(12),%d0
return write( fd, buf, nbytes );
5aa84: 2d6e 0014 0010 movel %fp@(20),%fp@(16) 5aa8a: 2d41 000c movel %d1,%fp@(12) 5aa8e: 2d40 0008 movel %d0,%fp@(8)
}
5aa92: 4e5e unlk %fp
int fd,
const void *buf,
size_t nbytes
)
{
return write( fd, buf, nbytes );
5aa94: 4ef9 0005 ab9c jmp 5ab9c <write>
...
00045f94 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
45f94: 4e56 ffe8 linkw %fp,#-24 45f98: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
45f9c: 4879 0006 1378 pea 61378 <aio_request_queue> 45fa2: 49f9 0004 7078 lea 47078 <pthread_mutex_lock>,%a4
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
45fa8: 242e 0008 movel %fp@(8),%d2 45fac: 266e 000c moveal %fp@(12),%a3
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
45fb0: 4e94 jsr %a4@
if (fcntl (fildes, F_GETFD) < 0) {
45fb2: 4878 0001 pea 1 <ADD> 45fb6: 2f02 movel %d2,%sp@- 45fb8: 4eb9 0004 c2b0 jsr 4c2b0 <fcntl> 45fbe: 4fef 000c lea %sp@(12),%sp 45fc2: 4a80 tstl %d0
45fc4: 6c1c bges 45fe2 <aio_cancel+0x4e>
pthread_mutex_unlock(&aio_request_queue.mutex);
45fc6: 4879 0006 1378 pea 61378 <aio_request_queue> 45fcc: 4eb9 0004 7110 jsr 47110 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
45fd2: 4eb9 0004 f150 jsr 4f150 <__errno> 45fd8: 7209 moveq #9,%d1 45fda: 2040 moveal %d0,%a0 45fdc: 2081 movel %d1,%a0@ 45fde: 6000 00f4 braw 460d4 <aio_cancel+0x140>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
45fe2: 4a8b tstl %a3 45fe4: 6600 00d0 bnew 460b6 <aio_cancel+0x122>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
45fe8: 42a7 clrl %sp@- 45fea: 47f9 0004 634a lea 4634a <rtems_aio_search_fd>,%a3 45ff0: 2f02 movel %d2,%sp@- 45ff2: 4879 0006 13c0 pea 613c0 <aio_request_queue+0x48> 45ff8: 4e93 jsr %a3@
if (r_chain == NULL) {
45ffa: 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);
45ffe: 2440 moveal %d0,%a2
if (r_chain == NULL) {
46000: 4a80 tstl %d0
46002: 667a bnes 4607e <aio_cancel+0xea>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
46004: 203c 0006 13d0 movel #398288,%d0 4600a: b0b9 0006 13cc cmpl 613cc <aio_request_queue+0x54>,%d0 46010: 6700 0136 beqw 46148 <aio_cancel+0x1b4>
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
46014: 42a7 clrl %sp@- 46016: 45f9 0004 7110 lea 47110 <pthread_mutex_unlock>,%a2 4601c: 2f02 movel %d2,%sp@- 4601e: 4879 0006 13cc pea 613cc <aio_request_queue+0x54> 46024: 4e93 jsr %a3@
if (r_chain == NULL) {
46026: 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);
4602a: 2400 movel %d0,%d2
if (r_chain == NULL) {
4602c: 6612 bnes 46040 <aio_cancel+0xac>
pthread_mutex_unlock(&aio_request_queue.mutex);
4602e: 4879 0006 1378 pea 61378 <aio_request_queue>
return AIO_ALLDONE;
46034: 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);
46038: 4e92 jsr %a2@
return AIO_ALLDONE;
4603a: 588f addql #4,%sp 4603c: 6000 014c braw 4618a <aio_cancel+0x1f6>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
46040: 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);
46042: 2602 movel %d2,%d3 46044: 0683 0000 001c addil #28,%d3 4604a: 4eb9 0004 88b8 jsr 488b8 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
46050: 2f02 movel %d2,%sp@- 46052: 4eb9 0004 669e jsr 4669e <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
46058: 2f03 movel %d3,%sp@- 4605a: 4eb9 0004 6e40 jsr 46e40 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
46060: 2f03 movel %d3,%sp@- 46062: 4eb9 0004 6b3c jsr 46b3c <pthread_cond_destroy>
free (r_chain);
46068: 2f02 movel %d2,%sp@- 4606a: 4eb9 0004 3434 jsr 43434 <free>
pthread_mutex_unlock (&aio_request_queue.mutex);
46070: 4879 0006 1378 pea 61378 <aio_request_queue> 46076: 4e92 jsr %a2@
return AIO_CANCELED;
46078: 4fef 0018 lea %sp@(24),%sp 4607c: 6032 bras 460b0 <aio_cancel+0x11c>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
4607e: 2400 movel %d0,%d2 46080: 0682 0000 001c addil #28,%d2 46086: 2f02 movel %d2,%sp@- 46088: 4e94 jsr %a4@ 4608a: 2f0a movel %a2,%sp@- 4608c: 4eb9 0004 88b8 jsr 488b8 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
46092: 2f0a movel %a2,%sp@-
pthread_mutex_unlock (&r_chain->mutex);
46094: 45f9 0004 7110 lea 47110 <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);
4609a: 4eb9 0004 669e jsr 4669e <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
460a0: 2f02 movel %d2,%sp@- 460a2: 4e92 jsr %a2@
pthread_mutex_unlock (&aio_request_queue.mutex);
460a4: 4879 0006 1378 pea 61378 <aio_request_queue> 460aa: 4e92 jsr %a2@
return AIO_CANCELED;
460ac: 4fef 0014 lea %sp@(20),%sp 460b0: 4282 clrl %d2 460b2: 6000 00d6 braw 4618a <aio_cancel+0x1f6>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
460b6: 2613 movel %a3@,%d3 460b8: b483 cmpl %d3,%d2
460ba: 6720 beqs 460dc <aio_cancel+0x148>
pthread_mutex_unlock (&aio_request_queue.mutex);
460bc: 4879 0006 1378 pea 61378 <aio_request_queue> 460c2: 4eb9 0004 7110 jsr 47110 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
460c8: 4eb9 0004 f150 jsr 4f150 <__errno> 460ce: 2040 moveal %d0,%a0 460d0: 7016 moveq #22,%d0 460d2: 2080 movel %d0,%a0@ 460d4: 588f addql #4,%sp 460d6: 74ff moveq #-1,%d2 460d8: 6000 00b0 braw 4618a <aio_cancel+0x1f6>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
460dc: 42a7 clrl %sp@- 460de: 4bf9 0004 634a lea 4634a <rtems_aio_search_fd>,%a5 460e4: 2f03 movel %d3,%sp@- 460e6: 4879 0006 13c0 pea 613c0 <aio_request_queue+0x48> 460ec: 4e95 jsr %a5@
if (r_chain == NULL) {
460ee: 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);
460f2: 2440 moveal %d0,%a2
if (r_chain == NULL) {
460f4: 4a80 tstl %d0
460f6: 6662 bnes 4615a <aio_cancel+0x1c6>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
460f8: 203c 0006 13d0 movel #398288,%d0 460fe: b0b9 0006 13cc cmpl 613cc <aio_request_queue+0x54>,%d0
46104: 6742 beqs 46148 <aio_cancel+0x1b4> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
46106: 42a7 clrl %sp@- 46108: 45f9 0004 7110 lea 47110 <pthread_mutex_unlock>,%a2 4610e: 2f03 movel %d3,%sp@- 46110: 4879 0006 13cc pea 613cc <aio_request_queue+0x54> 46116: 4e95 jsr %a5@
if (r_chain == NULL) {
46118: 4fef 000c lea %sp@(12),%sp 4611c: 4a80 tstl %d0
4611e: 660a bnes 4612a <aio_cancel+0x196>
pthread_mutex_unlock (&aio_request_queue.mutex);
46120: 4879 0006 1378 pea 61378 <aio_request_queue> 46126: 4e92 jsr %a2@ 46128: 609e bras 460c8 <aio_cancel+0x134>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
4612a: 2f0b movel %a3,%sp@- 4612c: 2040 moveal %d0,%a0 4612e: 4868 0008 pea %a0@(8) 46132: 4eb9 0004 66f4 jsr 466f4 <rtems_aio_remove_req>
pthread_mutex_unlock (&aio_request_queue.mutex);
46138: 4879 0006 1378 pea 61378 <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);
4613e: 2400 movel %d0,%d2
pthread_mutex_unlock (&aio_request_queue.mutex);
46140: 4e92 jsr %a2@
return result;
46142: 4fef 000c lea %sp@(12),%sp 46146: 6042 bras 4618a <aio_cancel+0x1f6>
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
46148: 4879 0006 1378 pea 61378 <aio_request_queue> <== NOT EXECUTED
return AIO_ALLDONE;
4614e: 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);
46150: 4eb9 0004 7110 jsr 47110 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
46156: 588f addql #4,%sp <== NOT EXECUTED 46158: 6030 bras 4618a <aio_cancel+0x1f6> <== NOT EXECUTED
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
4615a: 2600 movel %d0,%d3 4615c: 0683 0000 001c addil #28,%d3 46162: 2f03 movel %d3,%sp@- 46164: 4e94 jsr %a4@
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
46166: 2f0b movel %a3,%sp@- 46168: 486a 0008 pea %a2@(8)
pthread_mutex_unlock (&r_chain->mutex);
4616c: 45f9 0004 7110 lea 47110 <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);
46172: 4eb9 0004 66f4 jsr 466f4 <rtems_aio_remove_req> 46178: 2400 movel %d0,%d2
pthread_mutex_unlock (&r_chain->mutex);
4617a: 2f03 movel %d3,%sp@- 4617c: 4e92 jsr %a2@
pthread_mutex_unlock (&aio_request_queue.mutex);
4617e: 4879 0006 1378 pea 61378 <aio_request_queue> 46184: 4e92 jsr %a2@
return result;
46186: 4fef 0014 lea %sp@(20),%sp
} return AIO_ALLDONE; }
4618a: 2002 movel %d2,%d0 4618c: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5 46192: 4e5e unlk %fp
...
000461a8 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
461a8: 203c 0000 2000 movel #8192,%d0
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
461ae: 4e56 0000 linkw %fp,#0 461b2: 2f0a movel %a2,%sp@- 461b4: 246e 000c moveal %fp@(12),%a2
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
461b8: b0ae 0008 cmpl %fp@(8),%d0
461bc: 671a beqs 461d8 <aio_fsync+0x30>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
461be: 7216 moveq #22,%d1 461c0: 70ff moveq #-1,%d0 461c2: 2541 0030 movel %d1,%a2@(48) 461c6: 2540 0034 movel %d0,%a2@(52) 461ca: 4eb9 0004 f150 jsr 4f150 <__errno> 461d0: 2040 moveal %d0,%a0 461d2: 7016 moveq #22,%d0 461d4: 2080 movel %d0,%a0@ 461d6: 607e bras 46256 <aio_fsync+0xae>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
461d8: 4878 0003 pea 3 <DIVIDE> 461dc: 2f12 movel %a2@,%sp@- 461de: 4eb9 0004 c2b0 jsr 4c2b0 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
461e4: 508f addql #8,%sp 461e6: 7203 moveq #3,%d1 461e8: c081 andl %d1,%d0 461ea: 123c 0001 moveb #1,%d1 461ee: 5380 subql #1,%d0 461f0: b280 cmpl %d0,%d1
461f2: 641a bccs 4620e <aio_fsync+0x66>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
461f4: 72ff moveq #-1,%d1 461f6: 7009 moveq #9,%d0 461f8: 2541 0034 movel %d1,%a2@(52) 461fc: 2540 0030 movel %d0,%a2@(48) 46200: 4eb9 0004 f150 jsr 4f150 <__errno> 46206: 7209 moveq #9,%d1 46208: 2040 moveal %d0,%a0 4620a: 2081 movel %d1,%a0@ 4620c: 6048 bras 46256 <aio_fsync+0xae>
req = malloc (sizeof (rtems_aio_request));
4620e: 4878 0018 pea 18 <OPER2+0x4> 46212: 4eb9 0004 395c jsr 4395c <malloc>
if (req == NULL)
46218: 588f addql #4,%sp 4621a: 4a80 tstl %d0
4621c: 661c bnes 4623a <aio_fsync+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
4621e: 103c 000b moveb #11,%d0 <== NOT EXECUTED 46222: 72ff moveq #-1,%d1 <== NOT EXECUTED 46224: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED 46228: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED 4622c: 4eb9 0004 f150 jsr 4f150 <__errno> <== NOT EXECUTED 46232: 2040 moveal %d0,%a0 <== NOT EXECUTED 46234: 700b moveq #11,%d0 <== NOT EXECUTED 46236: 2080 movel %d0,%a0@ <== NOT EXECUTED 46238: 601c bras 46256 <aio_fsync+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
4623a: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_SYNC;
4623c: 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;
4623e: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
46242: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
46246: 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);
4624a: 2d40 0008 movel %d0,%fp@(8)
}
4624e: 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);
46250: 4ef9 0004 6750 jmp 46750 <rtems_aio_enqueue>
}
46256: 246e fffc moveal %fp@(-4),%a2 4625a: 70ff moveq #-1,%d0
4625c: 4e5e unlk %fp <== NOT EXECUTED
00046950 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
46950: 4e56 0000 linkw %fp,#0 46954: 2f0a movel %a2,%sp@-
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
46956: 4878 0003 pea 3 <DIVIDE>
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
4695a: 246e 0008 moveal %fp@(8),%a2
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
4695e: 2f12 movel %a2@,%sp@- 46960: 4eb9 0004 c2b0 jsr 4c2b0 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
46966: 508f addql #8,%sp 46968: 7203 moveq #3,%d1 4696a: c081 andl %d1,%d0
4696c: 6722 beqs 46990 <aio_read+0x40> <== NEVER TAKEN
4696e: 123c 0002 moveb #2,%d1 46972: b280 cmpl %d0,%d1
46974: 671a beqs 46990 <aio_read+0x40>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
46976: 7009 moveq #9,%d0 46978: 72ff moveq #-1,%d1 4697a: 2540 0030 movel %d0,%a2@(48) 4697e: 2541 0034 movel %d1,%a2@(52) 46982: 4eb9 0004 f150 jsr 4f150 <__errno> 46988: 2040 moveal %d0,%a0 4698a: 7009 moveq #9,%d0 4698c: 2080 movel %d0,%a0@ 4698e: 606e bras 469fe <aio_read+0xae>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
46990: 4aaa 0014 tstl %a2@(20)
46994: 6606 bnes 4699c <aio_read+0x4c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
46996: 4aaa 0004 tstl %a2@(4)
4699a: 6a1a bpls 469b6 <aio_read+0x66>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
4699c: 72ff moveq #-1,%d1 4699e: 7016 moveq #22,%d0 469a0: 2541 0034 movel %d1,%a2@(52) 469a4: 2540 0030 movel %d0,%a2@(48) 469a8: 4eb9 0004 f150 jsr 4f150 <__errno> 469ae: 7216 moveq #22,%d1 469b0: 2040 moveal %d0,%a0 469b2: 2081 movel %d1,%a0@ 469b4: 6048 bras 469fe <aio_read+0xae>
req = malloc (sizeof (rtems_aio_request));
469b6: 4878 0018 pea 18 <OPER2+0x4> 469ba: 4eb9 0004 395c jsr 4395c <malloc>
if (req == NULL)
469c0: 588f addql #4,%sp 469c2: 4a80 tstl %d0
469c4: 661c bnes 469e2 <aio_read+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
469c6: 103c 000b moveb #11,%d0 <== NOT EXECUTED 469ca: 72ff moveq #-1,%d1 <== NOT EXECUTED 469cc: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED 469d0: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED 469d4: 4eb9 0004 f150 jsr 4f150 <__errno> <== NOT EXECUTED 469da: 2040 moveal %d0,%a0 <== NOT EXECUTED 469dc: 700b moveq #11,%d0 <== NOT EXECUTED 469de: 2080 movel %d0,%a0@ <== NOT EXECUTED 469e0: 601c bras 469fe <aio_read+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
469e2: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_READ;
469e4: 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;
469e6: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_READ;
469ea: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
469ee: 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);
469f2: 2d40 0008 movel %d0,%fp@(8)
}
469f6: 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);
469f8: 4ef9 0004 6750 jmp 46750 <rtems_aio_enqueue>
}
469fe: 246e fffc moveal %fp@(-4),%a2 46a02: 70ff moveq #-1,%d0
46a04: 4e5e unlk %fp <== NOT EXECUTED
00046a18 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
46a18: 4e56 0000 linkw %fp,#0 46a1c: 2f0a movel %a2,%sp@-
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
46a1e: 4878 0003 pea 3 <DIVIDE>
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
46a22: 246e 0008 moveal %fp@(8),%a2
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
46a26: 2f12 movel %a2@,%sp@- 46a28: 4eb9 0004 c2b0 jsr 4c2b0 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
46a2e: 508f addql #8,%sp 46a30: 7203 moveq #3,%d1 46a32: c081 andl %d1,%d0 46a34: 123c 0001 moveb #1,%d1 46a38: 5380 subql #1,%d0 46a3a: b280 cmpl %d0,%d1
46a3c: 641a bccs 46a58 <aio_write+0x40>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
46a3e: 7009 moveq #9,%d0 46a40: 72ff moveq #-1,%d1 46a42: 2540 0030 movel %d0,%a2@(48) 46a46: 2541 0034 movel %d1,%a2@(52) 46a4a: 4eb9 0004 f150 jsr 4f150 <__errno> 46a50: 2040 moveal %d0,%a0 46a52: 7009 moveq #9,%d0 46a54: 2080 movel %d0,%a0@ 46a56: 606e bras 46ac6 <aio_write+0xae>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
46a58: 4aaa 0014 tstl %a2@(20)
46a5c: 6606 bnes 46a64 <aio_write+0x4c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
46a5e: 4aaa 0004 tstl %a2@(4)
46a62: 6a1a bpls 46a7e <aio_write+0x66>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
46a64: 72ff moveq #-1,%d1 46a66: 7016 moveq #22,%d0 46a68: 2541 0034 movel %d1,%a2@(52) 46a6c: 2540 0030 movel %d0,%a2@(48) 46a70: 4eb9 0004 f150 jsr 4f150 <__errno> 46a76: 7216 moveq #22,%d1 46a78: 2040 moveal %d0,%a0 46a7a: 2081 movel %d1,%a0@ 46a7c: 6048 bras 46ac6 <aio_write+0xae>
req = malloc (sizeof (rtems_aio_request));
46a7e: 4878 0018 pea 18 <OPER2+0x4> 46a82: 4eb9 0004 395c jsr 4395c <malloc>
if (req == NULL)
46a88: 588f addql #4,%sp 46a8a: 4a80 tstl %d0
46a8c: 661c bnes 46aaa <aio_write+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
46a8e: 103c 000b moveb #11,%d0 <== NOT EXECUTED 46a92: 72ff moveq #-1,%d1 <== NOT EXECUTED 46a94: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED 46a98: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED 46a9c: 4eb9 0004 f150 jsr 4f150 <__errno> <== NOT EXECUTED 46aa2: 2040 moveal %d0,%a0 <== NOT EXECUTED 46aa4: 700b moveq #11,%d0 <== NOT EXECUTED 46aa6: 2080 movel %d0,%a0@ <== NOT EXECUTED 46aa8: 601c bras 46ac6 <aio_write+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
46aaa: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_WRITE;
46aac: 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;
46aae: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
46ab2: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
46ab6: 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);
46aba: 2d40 0008 movel %d0,%fp@(8)
}
46abe: 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);
46ac0: 4ef9 0004 6750 jmp 46750 <rtems_aio_enqueue>
}
46ac6: 246e fffc moveal %fp@(-4),%a2 46aca: 70ff moveq #-1,%d0
46acc: 4e5e unlk %fp <== NOT EXECUTED
000429a0 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
429a0: 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) {
429a4: 203c 0005 f0c4 movel #389316,%d0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
429aa: 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) {
429ae: b0b9 0005 da4c cmpl 5da4c <rtems_current_user_env>,%d0
429b4: 6624 bnes 429da <chroot+0x3a> rtems_libio_set_private_env(); /* try to set a new private env*/
429b6: 4eb9 0004 3dac jsr 43dac <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
429bc: 41f9 0005 f0c4 lea 5f0c4 <rtems_global_user_env>,%a0 429c2: b1f9 0005 da4c cmpal 5da4c <rtems_current_user_env>,%a0
429c8: 6610 bnes 429da <chroot+0x3a>
rtems_set_errno_and_return_minus_one( ENOTSUP );
429ca: 4eb9 0004 d27c jsr 4d27c <__errno> 429d0: 2040 moveal %d0,%a0 429d2: 20bc 0000 0086 movel #134,%a0@ 429d8: 6020 bras 429fa <chroot+0x5a>
}
result = chdir(pathname);
429da: 2f2e 0008 movel %fp@(8),%sp@- 429de: 4eb9 0004 a308 jsr 4a308 <chdir>
if (result) {
429e4: 588f addql #4,%sp 429e6: 4a80 tstl %d0
429e8: 6714 beqs 429fe <chroot+0x5e>
rtems_set_errno_and_return_minus_one( errno );
429ea: 45f9 0004 d27c lea 4d27c <__errno>,%a2 429f0: 4e92 jsr %a2@ 429f2: 2640 moveal %d0,%a3 429f4: 4e92 jsr %a2@ 429f6: 2040 moveal %d0,%a0 429f8: 2690 movel %a0@,%a3@ 429fa: 70ff moveq #-1,%d0 429fc: 6056 bras 42a54 <chroot+0xb4>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
429fe: 42a7 clrl %sp@- 42a00: 240e movel %fp,%d2 42a02: 0682 ffff ffec addil #-20,%d2 42a08: 2f02 movel %d2,%sp@- 42a0a: 42a7 clrl %sp@- 42a0c: 4878 0001 pea 1 <ADD> 42a10: 4879 0005 cc12 pea 5cc12 <dotdotname+0x4> 42a16: 4eb9 0004 2d50 jsr 42d50 <rtems_filesystem_evaluate_path> 42a1c: 4fef 0014 lea %sp@(20),%sp 42a20: 4a80 tstl %d0
42a22: 66c6 bnes 429ea <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);
42a24: 2079 0005 da4c moveal 5da4c <rtems_current_user_env>,%a0 42a2a: 41e8 0018 lea %a0@(24),%a0 42a2e: 2f08 movel %a0,%sp@- 42a30: 4eb9 0004 2e1c jsr 42e1c <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
42a36: 4878 0014 pea 14 <OPER2> 42a3a: 2079 0005 da4c moveal 5da4c <rtems_current_user_env>,%a0 42a40: 41e8 0018 lea %a0@(24),%a0 42a44: 2f02 movel %d2,%sp@- 42a46: 2f08 movel %a0,%sp@- 42a48: 4eb9 0004 db28 jsr 4db28 <memcpy>
return 0;
42a4e: 4fef 0010 lea %sp@(16),%sp 42a52: 4280 clrl %d0
}
42a54: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3 42a5a: 4e5e unlk %fp
...
000456cc <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
456cc: 4e56 0000 linkw %fp,#0 456d0: 222e 0008 movel %fp@(8),%d1 456d4: 202e 000c movel %fp@(12),%d0 456d8: 2f02 movel %d2,%sp@-
if ( !tp )
456da: 4a80 tstl %d0
456dc: 6608 bnes 456e6 <clock_gettime+0x1a>
rtems_set_errno_and_return_minus_one( EINVAL );
456de: 4eb9 0004 d94c jsr 4d94c <__errno> 456e4: 6042 bras 45728 <clock_gettime+0x5c>
if ( clock_id == CLOCK_REALTIME ) {
456e6: 7401 moveq #1,%d2 456e8: b481 cmpl %d1,%d2
456ea: 660a bnes 456f6 <clock_gettime+0x2a> <== NEVER TAKEN
_TOD_Get(tp);
456ec: 2f00 movel %d0,%sp@- 456ee: 4eb9 0004 7334 jsr 47334 <_TOD_Get> 456f4: 6014 bras 4570a <clock_gettime+0x3e>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
456f6: 7404 moveq #4,%d2 456f8: b481 cmpl %d1,%d2
456fa: 6706 beqs 45702 <clock_gettime+0x36> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
456fc: 7402 moveq #2,%d2 456fe: b481 cmpl %d1,%d2
45700: 660e bnes 45710 <clock_gettime+0x44>
_TOD_Get_uptime_as_timespec( tp );
45702: 2f00 movel %d0,%sp@- 45704: 4eb9 0004 7398 jsr 47398 <_TOD_Get_uptime_as_timespec>
return 0;
4570a: 588f addql #4,%sp 4570c: 4280 clrl %d0 4570e: 6020 bras 45730 <clock_gettime+0x64> 45710: 41f9 0004 d94c lea 4d94c <__errno>,%a0
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
45716: 7003 moveq #3,%d0 45718: b081 cmpl %d1,%d0
4571a: 660a bnes 45726 <clock_gettime+0x5a>
rtems_set_errno_and_return_minus_one( ENOSYS );
4571c: 4e90 jsr %a0@ 4571e: 7258 moveq #88,%d1 45720: 2040 moveal %d0,%a0 45722: 2081 movel %d1,%a0@ 45724: 6008 bras 4572e <clock_gettime+0x62>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
45726: 4e90 jsr %a0@ 45728: 2040 moveal %d0,%a0 4572a: 7016 moveq #22,%d0 4572c: 2080 movel %d0,%a0@ 4572e: 70ff moveq #-1,%d0
return 0;
}
45730: 242e fffc movel %fp@(-4),%d2
45734: 4e5e unlk %fp <== NOT EXECUTED
00045738 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
45738: 4e56 0000 linkw %fp,#0 4573c: 222e 0008 movel %fp@(8),%d1 45740: 206e 000c moveal %fp@(12),%a0
if ( !tp )
45744: 4a88 tstl %a0
45746: 6710 beqs 45758 <clock_settime+0x20> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
45748: 7001 moveq #1,%d0 4574a: b081 cmpl %d1,%d0
4574c: 6634 bnes 45782 <clock_settime+0x4a>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
4574e: 203c 21da e4ff movel #567993599,%d0 45754: b090 cmpl %a0@,%d0
45756: 6508 bcss 45760 <clock_settime+0x28>
rtems_set_errno_and_return_minus_one( EINVAL );
45758: 4eb9 0004 d94c jsr 4d94c <__errno> 4575e: 6048 bras 457a8 <clock_settime+0x70>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
45760: 2039 0006 0668 movel 60668 <_Thread_Dispatch_disable_level>,%d0 45766: 5280 addql #1,%d0 45768: 23c0 0006 0668 movel %d0,60668 <_Thread_Dispatch_disable_level>
_Thread_Disable_dispatch();
_TOD_Set( tp );
4576e: 2f08 movel %a0,%sp@- 45770: 4eb9 0004 73f0 jsr 473f0 <_TOD_Set>
_Thread_Enable_dispatch();
45776: 4eb9 0004 883a jsr 4883a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
4577c: 588f addql #4,%sp 4577e: 4280 clrl %d0 45780: 602e bras 457b0 <clock_settime+0x78>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
45782: 7002 moveq #2,%d0 45784: b081 cmpl %d1,%d0
45786: 6608 bnes 45790 <clock_settime+0x58>
rtems_set_errno_and_return_minus_one( ENOSYS );
45788: 4eb9 0004 d94c jsr 4d94c <__errno> 4578e: 600e bras 4579e <clock_settime+0x66> 45790: 41f9 0004 d94c lea 4d94c <__errno>,%a0
#endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME )
45796: 7003 moveq #3,%d0 45798: b081 cmpl %d1,%d0
4579a: 660a bnes 457a6 <clock_settime+0x6e>
rtems_set_errno_and_return_minus_one( ENOSYS );
4579c: 4e90 jsr %a0@ 4579e: 2040 moveal %d0,%a0 457a0: 7258 moveq #88,%d1 457a2: 2081 movel %d1,%a0@ 457a4: 6008 bras 457ae <clock_settime+0x76>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
457a6: 4e90 jsr %a0@ 457a8: 2040 moveal %d0,%a0 457aa: 7016 moveq #22,%d0 457ac: 2080 movel %d0,%a0@ 457ae: 70ff moveq #-1,%d0
return 0;
}
457b0: 4e5e unlk %fp <== NOT EXECUTED
0004b218 <devFS_evaluate_path>:
{
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
4b218: 70f8 moveq #-8,%d0
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
4b21a: 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 ) )
4b21e: c0ae 0010 andl %fp@(16),%d0
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
4b222: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@ 4b226: 282e 0008 movel %fp@(8),%d4 4b22a: 262e 000c movel %fp@(12),%d3 4b22e: 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 ) )
4b232: 4a80 tstl %d0
4b234: 670e beqs 4b244 <devFS_evaluate_path+0x2c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
4b236: 4eb9 0004 d814 jsr 4d814 <__errno> <== NOT EXECUTED 4b23c: 7401 moveq #1,%d2 <== NOT EXECUTED 4b23e: 2040 moveal %d0,%a0 <== NOT EXECUTED 4b240: 2082 movel %d2,%a0@ <== NOT EXECUTED 4b242: 607a bras 4b2be <devFS_evaluate_path+0xa6> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
4b244: 2652 moveal %a2@,%a3
if (!device_name_table)
4b246: 4a8b tstl %a3
4b248: 670a beqs 4b254 <devFS_evaluate_path+0x3c>
4b24a: 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)
4b24c: 4bf9 0004 f14c lea 4f14c <strncmp>,%a5 4b252: 6056 bras 4b2aa <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 );
4b254: 4eb9 0004 d814 jsr 4d814 <__errno> 4b25a: 720e moveq #14,%d1 4b25c: 2040 moveal %d0,%a0 4b25e: 2081 movel %d1,%a0@ 4b260: 605c bras 4b2be <devFS_evaluate_path+0xa6>
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
4b262: 2853 moveal %a3@,%a4 4b264: 4a8c tstl %a4
4b266: 673c beqs 4b2a4 <devFS_evaluate_path+0x8c>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
4b268: 2f03 movel %d3,%sp@- 4b26a: 2f0c movel %a4,%sp@- 4b26c: 2f04 movel %d4,%sp@- 4b26e: 4e95 jsr %a5@ 4b270: 4fef 000c lea %sp@(12),%sp 4b274: 4a80 tstl %d0
4b276: 662c bnes 4b2a4 <devFS_evaluate_path+0x8c>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
4b278: 4a34 3800 tstb %a4@(00000000,%d3:l)
4b27c: 6626 bnes 4b2a4 <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;
4b27e: 41f9 0005 c51c lea 5c51c <devFS_ops>,%a0 4b284: 2548 000c movel %a0,%a2@(12)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
4b288: 2079 0005 c6b8 moveal 5c6b8 <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;
4b28e: 203c 0005 c564 movel #378212,%d0
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
4b294: 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;
4b29a: 2540 0008 movel %d0,%a2@(8)
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
4b29e: 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];
4b2a0: 248b movel %a3,%a2@
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
4b2a2: 601c bras 4b2c0 <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++) {
4b2a4: 5282 addql #1,%d2 4b2a6: 47eb 0014 lea %a3@(20),%a3 4b2aa: b4b9 0005 c3e8 cmpl 5c3e8 <rtems_device_table_size>,%d2
4b2b0: 65b0 bcss 4b262 <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 );
4b2b2: 4eb9 0004 d814 jsr 4d814 <__errno> 4b2b8: 2040 moveal %d0,%a0 4b2ba: 7002 moveq #2,%d0 4b2bc: 2080 movel %d0,%a0@ 4b2be: 70ff moveq #-1,%d0
}
4b2c0: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
4b2c6: 4e5e unlk %fp <== NOT EXECUTED
000449d0 <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') &&
449d0: 7264 moveq #100,%d1
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
449d2: 4e56 ffdc linkw %fp,#-36 449d6: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@ 449da: 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') &&
449de: 1012 moveb %a2@,%d0
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
449e0: 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') &&
449e4: 49c0 extbl %d0
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
449e6: 2c2e 0010 movel %fp@(16),%d6 449ea: 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') &&
449ee: b280 cmpl %d0,%d1
449f0: 6624 bnes 44a16 <devFS_mknod+0x46>
449f2: 123c 0065 moveb #101,%d1 449f6: 102a 0001 moveb %a2@(1),%d0 449fa: 49c0 extbl %d0 449fc: b280 cmpl %d0,%d1
449fe: 6616 bnes 44a16 <devFS_mknod+0x46> <== NEVER TAKEN
44a00: 123c 0076 moveb #118,%d1 44a04: 102a 0002 moveb %a2@(2),%d0 44a08: 49c0 extbl %d0 44a0a: b280 cmpl %d0,%d1
44a0c: 6608 bnes 44a16 <devFS_mknod+0x46> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
44a0e: 4a2a 0003 tstb %a2@(3) 44a12: 6700 00c8 beqw 44adc <devFS_mknod+0x10c>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
44a16: 2004 movel %d4,%d0 44a18: 0280 0000 f000 andil #61440,%d0 44a1e: 0c80 0000 6000 cmpil #24576,%d0
44a24: 6716 beqs 44a3c <devFS_mknod+0x6c>
44a26: 0c80 0000 2000 cmpil #8192,%d0
44a2c: 670e beqs 44a3c <devFS_mknod+0x6c>
rtems_set_errno_and_return_minus_one( EINVAL );
44a2e: 4eb9 0004 d814 jsr 4d814 <__errno> 44a34: 7616 moveq #22,%d3 44a36: 2040 moveal %d0,%a0 44a38: 2083 movel %d3,%a0@ 44a3a: 6066 bras 44aa2 <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;
44a3c: 206e 0018 moveal %fp@(24),%a0 44a40: 2650 moveal %a0@,%a3
if (!device_name_table)
44a42: 4a8b tstl %a3
44a44: 670e beqs 44a54 <devFS_mknod+0x84>
44a46: 284b moveal %a3,%a4 44a48: 74ff moveq #-1,%d2 44a4a: 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)
44a4c: 4bf9 0004 ec58 lea 4ec58 <strcmp>,%a5 44a52: 6034 bras 44a88 <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 );
44a54: 4eb9 0004 d814 jsr 4d814 <__errno> 44a5a: 740e moveq #14,%d2 44a5c: 2240 moveal %d0,%a1 44a5e: 2282 movel %d2,%a1@ 44a60: 6040 bras 44aa2 <devFS_mknod+0xd2>
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
44a62: 2014 movel %a4@,%d0
44a64: 671a beqs 44a80 <devFS_mknod+0xb0>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
44a66: 2f00 movel %d0,%sp@- 44a68: 2f0a movel %a2,%sp@- 44a6a: 4e95 jsr %a5@ 44a6c: 508f addql #8,%sp 44a6e: 4a80 tstl %d0
44a70: 6610 bnes 44a82 <devFS_mknod+0xb2>
rtems_set_errno_and_return_minus_one( EEXIST );
44a72: 4eb9 0004 d814 jsr 4d814 <__errno> 44a78: 7211 moveq #17,%d1 44a7a: 2040 moveal %d0,%a0 44a7c: 2081 movel %d1,%a0@ 44a7e: 6022 bras 44aa2 <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;
44a80: 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++){
44a82: 5283 addql #1,%d3 44a84: 49ec 0014 lea %a4@(20),%a4 44a88: b6b9 0005 c3e8 cmpl 5c3e8 <rtems_device_table_size>,%d3
44a8e: 65d2 bcss 44a62 <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)
44a90: 70ff moveq #-1,%d0 44a92: b082 cmpl %d2,%d0
44a94: 6610 bnes 44aa6 <devFS_mknod+0xd6>
rtems_set_errno_and_return_minus_one( ENOMEM );
44a96: 4eb9 0004 d814 jsr 4d814 <__errno> 44a9c: 2040 moveal %d0,%a0 44a9e: 700c moveq #12,%d0 44aa0: 2080 movel %d0,%a0@ 44aa2: 70ff moveq #-1,%d0 44aa4: 6038 bras 44ade <devFS_mknod+0x10e>
_ISR_Disable(level);
44aa6: 203c 0000 0700 movel #1792,%d0 44aac: 40c3 movew %sr,%d3 44aae: 8083 orl %d3,%d0 44ab0: 46c0 movew %d0,%sr
device_name_table[slot].device_name = (char *)path;
44ab2: 2002 movel %d2,%d0 44ab4: e988 lsll #4,%d0 44ab6: 2240 moveal %d0,%a1 44ab8: 41f1 2c00 lea %a1@(00000000,%d2:l:4),%a0 44abc: d7c8 addal %a0,%a3 44abe: 268a movel %a2,%a3@
device_name_table[slot].device_name_length = strlen(path);
44ac0: 2f0a movel %a2,%sp@- 44ac2: 4eb9 0004 f134 jsr 4f134 <strlen> 44ac8: 588f addql #4,%sp 44aca: 2740 0004 movel %d0,%a3@(4)
device_name_table[slot].major = major;
44ace: 2746 0008 movel %d6,%a3@(8)
device_name_table[slot].minor = minor;
44ad2: 2745 000c movel %d5,%a3@(12)
device_name_table[slot].mode = mode;
44ad6: 2744 0010 movel %d4,%a3@(16)
_ISR_Enable(level);
44ada: 46c3 movew %d3,%sr
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
(path[2] == 'v') && (path[3] == '\0'))
return 0;
44adc: 4280 clrl %d0
device_name_table[slot].minor = minor;
device_name_table[slot].mode = mode;
_ISR_Enable(level);
return 0;
}
44ade: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
44ae4: 4e5e unlk %fp <== NOT EXECUTED
000437c0 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
437c0: 4e56 fff4 linkw %fp,#-12 437c4: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 437c8: 246e 0008 moveal %fp@(8),%a2
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
437cc: 4aaa 00b4 tstl %a2@(180)
437d0: 674e beqs 43820 <drainOutput+0x60>
rtems_interrupt_disable (level);
437d2: 243c 0000 0700 movel #1792,%d2 437d8: 2202 movel %d2,%d1 437da: 40c0 movew %sr,%d0 437dc: 8280 orl %d0,%d1 437de: 46c1 movew %d1,%sr
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
437e0: 47f9 0004 5854 lea 45854 <rtems_semaphore_obtain>,%a3
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) {
437e6: 602a bras 43812 <drainOutput+0x52>
tty->rawOutBufState = rob_wait;
437e8: 7202 moveq #2,%d1 437ea: 2541 0094 movel %d1,%a2@(148)
rtems_interrupt_enable (level);
437ee: 46c0 movew %d0,%sr
sc = rtems_semaphore_obtain(
437f0: 42a7 clrl %sp@- 437f2: 42a7 clrl %sp@- 437f4: 2f2a 008c movel %a2@(140),%sp@- 437f8: 4e93 jsr %a3@
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
437fa: 4fef 000c lea %sp@(12),%sp 437fe: 4a80 tstl %d0
43800: 6708 beqs 4380a <drainOutput+0x4a> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
43802: 2f00 movel %d0,%sp@- <== NOT EXECUTED 43804: 4eb9 0004 5efc jsr 45efc <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
4380a: 2202 movel %d2,%d1 4380c: 40c0 movew %sr,%d0 4380e: 8280 orl %d0,%d1 43810: 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) {
43812: 206a 0084 moveal %a2@(132),%a0 43816: 222a 0080 movel %a2@(128),%d1 4381a: b288 cmpl %a0,%d1
4381c: 66ca bnes 437e8 <drainOutput+0x28>
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);
4381e: 46c0 movew %d0,%sr
} }
43820: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
43826: 4e5e unlk %fp <== NOT EXECUTED
000442f4 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
442f4: 4e56 fff0 linkw %fp,#-16 442f8: 48d7 040c moveml %d2-%d3/%a2,%sp@ 442fc: 246e 000c moveal %fp@(12),%a2
if ((tty->termios.c_lflag & ECHOCTL) &&
44300: 202a 003c movel %a2@(60),%d0
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
44304: 242e 0008 movel %fp@(8),%d2
if ((tty->termios.c_lflag & ECHOCTL) &&
44308: 0280 0000 0200 andil #512,%d0
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
4430e: 1202 moveb %d2,%d1
if ((tty->termios.c_lflag & ECHOCTL) &&
44310: 4a80 tstl %d0
44312: 674e beqs 44362 <echo+0x6e> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
44314: 4280 clrl %d0 44316: 1002 moveb %d2,%d0 44318: 2079 0005 d308 moveal 5d308 <__ctype_ptr__>,%a0 4431e: 1630 0801 moveb %a0@(00000001,%d0:l),%d3 44322: 49c3 extbl %d3
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
44324: 0803 0005 btst #5,%d3
44328: 6738 beqs 44362 <echo+0x6e>
iscntrl(c) && (c != '\t') && (c != '\n')) {
4432a: 7609 moveq #9,%d3 4432c: b680 cmpl %d0,%d3
4432e: 6732 beqs 44362 <echo+0x6e>
44330: 163c 000a moveb #10,%d3 44334: b680 cmpl %d0,%d3
44336: 672a beqs 44362 <echo+0x6e>
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
44338: 2f0a movel %a2,%sp@- 4433a: 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;
4433e: 163c 0040 moveb #64,%d3
rtems_termios_puts (echobuf, 2, tty);
44342: 486e fffe pea %fp@(-2)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
44346: 705e moveq #94,%d0
echobuf[1] = c ^ 0x40;
44348: b782 eorl %d3,%d2
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
4434a: 1d40 fffe moveb %d0,%fp@(-2)
echobuf[1] = c ^ 0x40;
4434e: 1d42 ffff moveb %d2,%fp@(-1)
rtems_termios_puts (echobuf, 2, tty);
44352: 4eb9 0004 40b2 jsr 440b2 <rtems_termios_puts>
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
44358: 4fef 000c lea %sp@(12),%sp
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
4435c: 54aa 0028 addql #2,%a2@(40)
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
44360: 6010 bras 44372 <echo+0x7e>
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
44362: 2f0a movel %a2,%sp@- 44364: 0281 0000 00ff andil #255,%d1 4436a: 2f01 movel %d1,%sp@- 4436c: 4eba fe3c jsr %pc@(441aa <oproc>) 44370: 508f addql #8,%sp
} }
44372: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
44378: 4e5e unlk %fp <== NOT EXECUTED
0004381e <endgrent>:
void endgrent(void)
{
4381e: 4e56 0000 linkw %fp,#0
if (group_fp != NULL)
43822: 2039 0005 f990 movel 5f990 <group_fp>,%d0
43828: 670a beqs 43834 <endgrent+0x16> <== NEVER TAKEN
fclose(group_fp);
4382a: 2f00 movel %d0,%sp@- 4382c: 4eb9 0004 d97a jsr 4d97a <fclose> 43832: 588f addql #4,%sp
}
43834: 4e5e unlk %fp <== NOT EXECUTED
000436d8 <endpwent>:
void endpwent(void)
{
436d8: 4e56 0000 linkw %fp,#0
if (passwd_fp != NULL)
436dc: 2039 0005 fa6a movel 5fa6a <passwd_fp>,%d0
436e2: 670a beqs 436ee <endpwent+0x16> <== NEVER TAKEN
fclose(passwd_fp);
436e4: 2f00 movel %d0,%sp@- 436e6: 4eb9 0004 d97a jsr 4d97a <fclose> 436ec: 588f addql #4,%sp
}
436ee: 4e5e unlk %fp <== NOT EXECUTED
0004437c <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)
{
4437c: 4e56 ffe4 linkw %fp,#-28 44380: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@ 44384: 246e 0008 moveal %fp@(8),%a2 44388: 262e 000c movel %fp@(12),%d3
if (tty->ccount == 0)
4438c: 4aaa 0020 tstl %a2@(32) 44390: 6700 0172 beqw 44504 <erase+0x188>
return;
if (lineFlag) {
44394: 4a83 tstl %d3 44396: 6700 015c beqw 444f4 <erase+0x178>
if (!(tty->termios.c_lflag & ECHO)) {
4439a: 202a 003c movel %a2@(60),%d0 4439e: 44c0 movew %d0,%ccr
443a0: 6b08 bmis 443aa <erase+0x2e> <== ALWAYS TAKEN
tty->ccount = 0;
443a2: 42aa 0020 clrl %a2@(32) <== NOT EXECUTED
return;
443a6: 6000 015c braw 44504 <erase+0x188> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
443aa: 0800 0004 btst #4,%d0 443ae: 6600 0144 bnew 444f4 <erase+0x178>
tty->ccount = 0;
443b2: 42aa 0020 clrl %a2@(32) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
443b6: 4280 clrl %d0 <== NOT EXECUTED 443b8: 2f0a movel %a2,%sp@- <== NOT EXECUTED 443ba: 102a 0044 moveb %a2@(68),%d0 <== NOT EXECUTED 443be: 2f00 movel %d0,%sp@- <== NOT EXECUTED 443c0: 4eba ff32 jsr %pc@(442f4 <echo>) <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
443c4: 508f addql #8,%sp <== NOT EXECUTED 443c6: 7020 moveq #32,%d0 <== NOT EXECUTED 443c8: c0aa 003c andl %a2@(60),%d0 <== NOT EXECUTED 443cc: 6700 0136 beqw 44504 <erase+0x188> <== NOT EXECUTED
echo ('\n', tty);
443d0: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED 443d4: 700a moveq #10,%d0 <== NOT EXECUTED 443d6: 602c bras 44404 <erase+0x88> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
443d8: 5388 subql #1,%a0 443da: 286a 001c moveal %a2@(28),%a4
if (tty->termios.c_lflag & ECHO) {
443de: 202a 003c movel %a2@(60),%d0
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
443e2: 2548 0020 movel %a0,%a2@(32) 443e6: 1434 8800 moveb %a4@(00000000,%a0:l),%d2
if (tty->termios.c_lflag & ECHO) {
443ea: 44c0 movew %d0,%ccr 443ec: 6a00 0100 bplw 444ee <erase+0x172>
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
443f0: 4a83 tstl %d3
443f2: 6620 bnes 44414 <erase+0x98>
443f4: 0800 0004 btst #4,%d0
443f8: 661a bnes 44414 <erase+0x98> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
443fa: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED 443fe: 4280 clrl %d0 <== NOT EXECUTED 44400: 102a 0043 moveb %a2@(67),%d0 <== NOT EXECUTED 44404: 2d40 0008 movel %d0,%fp@(8) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
44408: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4 <== NOT EXECUTED 4440e: 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);
44410: 6000 fee2 braw 442f4 <echo> <== NOT EXECUTED
44414: 2279 0005 d308 moveal 5d308 <__ctype_ptr__>,%a1
} else if (c == '\t') {
4441a: 7209 moveq #9,%d1 4441c: 0282 0000 00ff andil #255,%d2 44422: b282 cmpl %d2,%d1
44424: 665a bnes 44480 <erase+0x104>
int col = tty->read_start_column;
44426: 242a 002c movel %a2@(44),%d2
int i = 0;
4442a: 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)
4442c: 0280 0000 0200 andil #512,%d0
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
44432: 6028 bras 4445c <erase+0xe0>
c = tty->cbuf[i++];
if (c == '\t') {
44434: 4284 clrl %d4 44436: 181c moveb %a4@+,%d4
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
44438: 5281 addql #1,%d1
if (c == '\t') {
4443a: 7a09 moveq #9,%d5 4443c: ba84 cmpl %d4,%d5
4443e: 6606 bnes 44446 <erase+0xca>
col = (col | 7) + 1;
44440: 7807 moveq #7,%d4 44442: 8484 orl %d4,%d2 44444: 6014 bras 4445a <erase+0xde>
} else if (iscntrl (c)) {
44446: 1831 4801 moveb %a1@(00000001,%d4:l),%d4 4444a: 49c4 extbl %d4 4444c: 0804 0005 btst #5,%d4
44450: 6708 beqs 4445a <erase+0xde> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
44452: 4a80 tstl %d0 <== NOT EXECUTED 44454: 6706 beqs 4445c <erase+0xe0> <== NOT EXECUTED
col += 2;
44456: 5482 addql #2,%d2 <== NOT EXECUTED 44458: 6002 bras 4445c <erase+0xe0> <== NOT EXECUTED
} else {
col++;
4445a: 5282 addql #1,%d2
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
4445c: b1c1 cmpal %d1,%a0
4445e: 66d4 bnes 44434 <erase+0xb8>
44460: 6016 bras 44478 <erase+0xfc>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
44462: 2f0a movel %a2,%sp@- 44464: 4878 0001 pea 1 <ADD> 44468: 4879 0005 c165 pea 5c165 <rtems_filesystem_default_pathconf+0xb3> 4446e: 4e93 jsr %a3@
tty->column--;
44470: 4fef 000c lea %sp@(12),%sp 44474: 53aa 0028 subql #1,%a2@(40)
}
/*
* Back up over the tab
*/
while (tty->column > col) {
44478: b4aa 0028 cmpl %a2@(40),%d2
4447c: 6de4 blts 44462 <erase+0xe6>
4447e: 606e bras 444ee <erase+0x172>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
44480: 5282 addql #1,%d2 44482: 1231 2800 moveb %a1@(00000000,%d2:l),%d1 44486: 49c1 extbl %d1 44488: 0801 0005 btst #5,%d1
4448c: 6724 beqs 444b2 <erase+0x136> <== ALWAYS TAKEN
4448e: 0800 0009 btst #9,%d0 <== NOT EXECUTED 44492: 671e beqs 444b2 <erase+0x136> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
44494: 2f0a movel %a2,%sp@- <== NOT EXECUTED 44496: 4878 0003 pea 3 <DIVIDE> <== NOT EXECUTED 4449a: 4879 0005 c163 pea 5c163 <rtems_filesystem_default_pathconf+0xb1><== NOT EXECUTED 444a0: 4e93 jsr %a3@ <== NOT EXECUTED
if (tty->column)
444a2: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED 444a6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED 444aa: 6706 beqs 444b2 <erase+0x136> <== NOT EXECUTED
tty->column--;
444ac: 5380 subql #1,%d0 <== NOT EXECUTED 444ae: 2540 0028 movel %d0,%a2@(40) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
444b2: 2079 0005 d308 moveal 5d308 <__ctype_ptr__>,%a0 444b8: 1030 2800 moveb %a0@(00000000,%d2:l),%d0 444bc: 49c0 extbl %d0 444be: 0800 0005 btst #5,%d0
444c2: 670c beqs 444d0 <erase+0x154> <== ALWAYS TAKEN
444c4: 202a 003c movel %a2@(60),%d0 <== NOT EXECUTED 444c8: 0280 0000 0200 andil #512,%d0 <== NOT EXECUTED 444ce: 671e beqs 444ee <erase+0x172> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
444d0: 2f0a movel %a2,%sp@- 444d2: 4878 0003 pea 3 <DIVIDE> 444d6: 4879 0005 c163 pea 5c163 <rtems_filesystem_default_pathconf+0xb1> 444dc: 4e93 jsr %a3@
if (tty->column)
444de: 202a 0028 movel %a2@(40),%d0 444e2: 4fef 000c lea %sp@(12),%sp
444e6: 6706 beqs 444ee <erase+0x172> <== NEVER TAKEN
tty->column--;
444e8: 5380 subql #1,%d0 444ea: 2540 0028 movel %d0,%a2@(40)
}
}
}
if (!lineFlag)
444ee: 4a83 tstl %d3
444f0: 6608 bnes 444fa <erase+0x17e>
444f2: 6010 bras 44504 <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);
444f4: 47f9 0004 40b2 lea 440b2 <rtems_termios_puts>,%a3
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
444fa: 206a 0020 moveal %a2@(32),%a0 444fe: 4a88 tstl %a0 44500: 6600 fed6 bnew 443d8 <erase+0x5c>
}
}
if (!lineFlag)
break;
}
}
44504: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4450a: 4e5e unlk %fp <== NOT EXECUTED
00043314 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
43314: 4e56 fff0 linkw %fp,#-16 43318: 202e 0008 movel %fp@(8),%d0
int ret; va_list ap; va_start( ap, cmd );
4331c: 41ee 0010 lea %fp@(16),%a0
int fcntl(
int fd,
int cmd,
...
)
{
43320: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 43324: 262e 000c movel %fp@(12),%d3
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
43328: 2239 0005 ea54 movel 5ea54 <rtems_libio_number_iops>,%d1 4332e: b280 cmpl %d0,%d1
43330: 631c blss 4334e <fcntl+0x3a> iop = rtems_libio_iop( fd );
43332: 2400 movel %d0,%d2 43334: ed88 lsll #6,%d0 43336: e78a lsll #3,%d2 43338: 2679 0006 02d4 moveal 602d4 <rtems_libio_iops>,%a3 4333e: 9082 subl %d2,%d0 43340: 45f3 0800 lea %a3@(00000000,%d0:l),%a2
rtems_libio_check_is_open(iop);
43344: 202a 0014 movel %a2@(20),%d0 43348: 0800 0008 btst #8,%d0
4334c: 6610 bnes 4335e <fcntl+0x4a>
4334e: 4eb9 0004 da3c jsr 4da3c <__errno> 43354: 7209 moveq #9,%d1 43356: 2040 moveal %d0,%a0 43358: 2081 movel %d1,%a0@ 4335a: 6000 0110 braw 4346c <fcntl+0x158>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
4335e: 7409 moveq #9,%d2 43360: b483 cmpl %d3,%d2 43362: 6500 00d8 bcsw 4343c <fcntl+0x128> 43366: 327b 3a06 moveaw %pc@(4336e <fcntl+0x5a>,%d3:l:2),%a1 4336a: 4efb 9802 jmp %pc@(4336e <fcntl+0x5a>,%a1:l)
4336e: 0014 .short 0x0014 <== NOT EXECUTED 43370: 006c .short 0x006c <== NOT EXECUTED 43372: 0078 .short 0x0078 <== NOT EXECUTED 43374: 008c 009a 00be oril #10092734,%d4 <== NOT EXECUTED 4337a: 00be 00be 00be oril #12452030,%d6 <== NOT EXECUTED 43380: 00be 2410 6710 oril #605054736,%d6 <== NOT EXECUTED
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
43386: b282 cmpl %d2,%d1
43388: 631c blss 433a6 <fcntl+0x92> <== NEVER TAKEN
4338a: 2002 movel %d2,%d0 4338c: ed8a lsll #6,%d2 4338e: e788 lsll #3,%d0 43390: 9480 subl %d0,%d2 43392: d7c2 addal %d2,%a3 43394: 6012 bras 433a8 <fcntl+0x94>
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
43396: 4eb9 0004 3950 jsr 43950 <rtems_libio_allocate> 4339c: 2640 moveal %d0,%a3
if ( diop == 0 ) {
4339e: 4a80 tstl %d0
433a0: 6606 bnes 433a8 <fcntl+0x94> <== ALWAYS TAKEN
433a2: 6000 00c8 braw 4346c <fcntl+0x158> <== NOT EXECUTED
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
433a6: 97cb subal %a3,%a3 <== NOT EXECUTED
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
433a8: 240b movel %a3,%d2
ret = -1;
break;
}
}
diop->flags = iop->flags;
433aa: 276a 0014 0014 movel %a2@(20),%a3@(20)
diop->pathinfo = iop->pathinfo;
433b0: 4878 0014 pea 14 <OPER2> 433b4: 486a 0018 pea %a2@(24) 433b8: 486b 0018 pea %a3@(24) 433bc: 4eb9 0004 ec90 jsr 4ec90 <memcpy>
ret = (int) (diop - rtems_libio_iops);
433c2: 4fef 000c lea %sp@(12),%sp 433c6: 94b9 0006 02d4 subl 602d4 <rtems_libio_iops>,%d2 433cc: 203c b6db 6db7 movel #-1227133513,%d0 433d2: e682 asrl #3,%d2 433d4: 4c00 2800 mulsl %d0,%d2 433d8: 6070 bras 4344a <fcntl+0x136>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
433da: 0800 000b btst #11,%d0 433de: 56c2 sne %d2 433e0: 49c2 extbl %d2 433e2: 4482 negl %d2 433e4: 6068 bras 4344e <fcntl+0x13a>
* 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 ) )
433e6: 4a90 tstl %a0@
433e8: 6706 beqs 433f0 <fcntl+0xdc>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
433ea: 08c0 000b bset #11,%d0 433ee: 6004 bras 433f4 <fcntl+0xe0>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
433f0: 0880 000b bclr #11,%d0 433f4: 2540 0014 movel %d0,%a2@(20) 433f8: 602e bras 43428 <fcntl+0x114>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
433fa: 2f00 movel %d0,%sp@- 433fc: 4eb9 0004 3902 jsr 43902 <rtems_libio_to_fcntl_flags> 43402: 588f addql #4,%sp 43404: 2400 movel %d0,%d2 43406: 6042 bras 4344a <fcntl+0x136>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
43408: 2f10 movel %a0@,%sp@- 4340a: 4eb9 0004 38c2 jsr 438c2 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
43410: 222a 0014 movel %a2@(20),%d1 43414: 588f addql #4,%sp 43416: 0280 0000 0201 andil #513,%d0 4341c: 0281 ffff fdfe andil #-514,%d1 43422: 8081 orl %d1,%d0 43424: 2540 0014 movel %d0,%a2@(20)
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
43428: 4282 clrl %d2 4342a: 6022 bras 4344e <fcntl+0x13a>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
4342c: 4eb9 0004 da3c jsr 4da3c <__errno> 43432: 2040 moveal %d0,%a0 43434: 20bc 0000 0086 movel #134,%a0@ 4343a: 6030 bras 4346c <fcntl+0x158>
ret = -1;
break;
default:
errno = EINVAL;
4343c: 4eb9 0004 da3c jsr 4da3c <__errno> 43442: 2040 moveal %d0,%a0 43444: 7016 moveq #22,%d0 43446: 2080 movel %d0,%a0@ 43448: 6022 bras 4346c <fcntl+0x158>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
4344a: 4a82 tstl %d2
4344c: 6d20 blts 4346e <fcntl+0x15a> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
4344e: 206a 0020 moveal %a2@(32),%a0 43452: 2f0a movel %a2,%sp@- 43454: 2f03 movel %d3,%sp@- 43456: 2068 0030 moveal %a0@(48),%a0 4345a: 4e90 jsr %a0@
if (err) {
4345c: 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 );
4345e: 2600 movel %d0,%d3
if (err) {
43460: 670c beqs 4346e <fcntl+0x15a> <== ALWAYS TAKEN
errno = err;
43462: 4eb9 0004 da3c jsr 4da3c <__errno> <== NOT EXECUTED 43468: 2040 moveal %d0,%a0 <== NOT EXECUTED 4346a: 2083 movel %d3,%a0@ <== NOT EXECUTED
ret = -1;
4346c: 74ff moveq #-1,%d2
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
4346e: 2002 movel %d2,%d0 43470: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
43476: 4e5e unlk %fp <== NOT EXECUTED
0004b582 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b582: 4e56 ffd8 linkw %fp,#-40 4b586: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@ 4b58a: 266e 0008 moveal %fp@(8),%a3 4b58e: 286e 000c moveal %fp@(12),%a4
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
4b592: 4ab9 0006 0538 tstl 60538 <pipe_semaphore>
4b598: 6654 bnes 4b5ee <fifo_open+0x6c>
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 );
4b59a: 42a7 clrl %sp@- 4b59c: 42a7 clrl %sp@- 4b59e: 2f39 0006 0c30 movel 60c30 <rtems_libio_semaphore>,%sp@- 4b5a4: 4eb9 0004 759c jsr 4759c <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
4b5aa: 4fef 000c lea %sp@(12),%sp 4b5ae: 4ab9 0006 0538 tstl 60538 <pipe_semaphore>
4b5b4: 6624 bnes 4b5da <fifo_open+0x58> <== NEVER TAKEN
sc = rtems_semaphore_create(
4b5b6: 4879 0006 0538 pea 60538 <pipe_semaphore> 4b5bc: 42a7 clrl %sp@- 4b5be: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f> 4b5c2: 4878 0001 pea 1 <ADD> 4b5c6: 2f3c 5049 5045 movel #1346981957,%sp@- 4b5cc: 4eb9 0004 7364 jsr 47364 <rtems_semaphore_create> 4b5d2: 4fef 0014 lea %sp@(20),%sp 4b5d6: 2400 movel %d0,%d2 4b5d8: 6002 bras 4b5dc <fifo_open+0x5a>
free(pipe);
}
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
4b5da: 4282 clrl %d2 <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4b5dc: 2f39 0006 0c30 movel 60c30 <rtems_libio_semaphore>,%sp@- 4b5e2: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
4b5e8: 588f addql #4,%sp 4b5ea: 4a82 tstl %d2
4b5ec: 6618 bnes 4b606 <fifo_open+0x84>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4b5ee: 42a7 clrl %sp@- 4b5f0: 42a7 clrl %sp@- 4b5f2: 2f39 0006 0538 movel 60538 <pipe_semaphore>,%sp@- 4b5f8: 4eb9 0004 759c jsr 4759c <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
4b5fe: 4fef 000c lea %sp@(12),%sp 4b602: 4a80 tstl %d0
4b604: 6704 beqs 4b60a <fifo_open+0x88> <== ALWAYS TAKEN
return 0;
} else {
return -ENOMEM;
4b606: 74f4 moveq #-12,%d2 4b608: 6002 bras 4b60c <fifo_open+0x8a>
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
if (sc == RTEMS_SUCCESSFUL) {
return 0;
4b60a: 4282 clrl %d2
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
if (err)
4b60c: 4a82 tstl %d2 4b60e: 6600 0342 bnew 4b952 <fifo_open+0x3d0>
return err;
pipe = *pipep;
4b612: 2453 moveal %a3@,%a2
if (pipe == NULL) {
4b614: 4a8a tstl %a2 4b616: 6600 0166 bnew 4b77e <fifo_open+0x1fc>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4b61a: 4878 0034 pea 34 <OPER2+0x20> 4b61e: 263c 0004 491c movel #280860,%d3 4b624: 2043 moveal %d3,%a0 4b626: 4e90 jsr %a0@
if (pipe == NULL)
4b628: 588f addql #4,%sp
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4b62a: 2440 moveal %d0,%a2 4b62c: 2a40 moveal %d0,%a5
if (pipe == NULL)
4b62e: 4a80 tstl %d0 4b630: 6700 0148 beqw 4b77a <fifo_open+0x1f8>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
4b634: 4878 0034 pea 34 <OPER2+0x20> 4b638: 42a7 clrl %sp@- 4b63a: 2f00 movel %d0,%sp@- 4b63c: 4eb9 0004 fa48 jsr 4fa48 <memset>
pipe->Size = PIPE_BUF;
4b642: 203c 0000 0200 movel #512,%d0
pipe->Buffer = malloc(pipe->Size);
4b648: 2043 moveal %d3,%a0
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
4b64a: 2540 0004 movel %d0,%a2@(4)
pipe->Buffer = malloc(pipe->Size);
4b64e: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb> 4b652: 4e90 jsr %a0@
if (! pipe->Buffer)
4b654: 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);
4b658: 2480 movel %d0,%a2@
if (! pipe->Buffer)
4b65a: 6700 0114 beqw 4b770 <fifo_open+0x1ee>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b65e: 486a 002c pea %a2@(44) 4b662: 263c 0004 ceb0 movel #315056,%d3 4b668: 2043 moveal %d3,%a0
rtems_build_name ('P', 'I', 'r', c),
4b66a: 1039 0005 f5ec moveb 5f5ec <c.6482>,%d0
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b670: 42a7 clrl %sp@-
rtems_build_name ('P', 'I', 'r', c),
4b672: 49c0 extbl %d0
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b674: 42a7 clrl %sp@- 4b676: 0080 5049 7200 oril #1346990592,%d0 4b67c: 2f00 movel %d0,%sp@- 4b67e: 4e90 jsr %a0@ 4b680: 4fef 0010 lea %sp@(16),%sp 4b684: 4a80 tstl %d0 4b686: 6600 00de bnew 4b766 <fifo_open+0x1e4>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4b68a: 486a 0030 pea %a2@(48) 4b68e: 2043 moveal %d3,%a0
rtems_build_name ('P', 'I', 'w', c),
4b690: 1039 0005 f5ec moveb 5f5ec <c.6482>,%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(
4b696: 42a7 clrl %sp@-
rtems_build_name ('P', 'I', 'w', c),
4b698: 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(
4b69a: 42a7 clrl %sp@- 4b69c: 0080 5049 7700 oril #1346991872,%d0 4b6a2: 2f00 movel %d0,%sp@- 4b6a4: 4e90 jsr %a0@ 4b6a6: 4fef 0010 lea %sp@(16),%sp 4b6aa: 4a80 tstl %d0 4b6ac: 6600 00ac bnew 4b75a <fifo_open+0x1d8>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4b6b0: 486a 0028 pea %a2@(40)
rtems_build_name ('P', 'I', 's', c), 1,
4b6b4: 1039 0005 f5ec moveb 5f5ec <c.6482>,%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(
4b6ba: 42a7 clrl %sp@- 4b6bc: 4878 0010 pea 10 <INVALID_OPERATION>
rtems_build_name ('P', 'I', 's', c), 1,
4b6c0: 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(
4b6c2: 4878 0001 pea 1 <ADD> 4b6c6: 0080 5049 7300 oril #1346990848,%d0 4b6cc: 2f00 movel %d0,%sp@- 4b6ce: 4eb9 0004 7364 jsr 47364 <rtems_semaphore_create> 4b6d4: 4fef 0014 lea %sp@(20),%sp 4b6d8: 4a80 tstl %d0
4b6da: 6672 bnes 4b74e <fifo_open+0x1cc>
/* 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
4b6dc: 280e movel %fp,%d4 4b6de: 5184 subql #8,%d4
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
4b6e0: 263c 0004 8c14 movel #298004,%d3 4b6e6: 2043 moveal %d3,%a0
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
_Thread_Enable_dispatch();
4b6e8: 4bf9 0004 977a lea 4977a <_Thread_Enable_dispatch>,%a5 4b6ee: 2f04 movel %d4,%sp@- 4b6f0: 2f2a 002c movel %a2@(44),%sp@- 4b6f4: 4879 0006 15b8 pea 615b8 <_Barrier_Information> 4b6fa: 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;
4b6fc: 223c 1000 0000 movel #268435456,%d1 4b702: 2040 moveal %d0,%a0 4b704: 83a8 004c orl %d1,%a0@(76)
_Thread_Enable_dispatch();
4b708: 4e95 jsr %a5@ 4b70a: 2043 moveal %d3,%a0 4b70c: 2f04 movel %d4,%sp@- 4b70e: 2f2a 0030 movel %a2@(48),%sp@- 4b712: 4879 0006 15b8 pea 615b8 <_Barrier_Information> 4b718: 4e90 jsr %a0@
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
4b71a: 223c 1000 0000 movel #268435456,%d1 4b720: 2040 moveal %d0,%a0 4b722: 83a8 004c orl %d1,%a0@(76)
_Thread_Enable_dispatch();
4b726: 4e95 jsr %a5@
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4b728: 4fef 0018 lea %sp@(24),%sp 4b72c: 1039 0005 f5ec moveb 5f5ec <c.6482>,%d0 4b732: 49c0 extbl %d0 4b734: 2200 movel %d0,%d1 4b736: 5281 addql #1,%d1 4b738: 13c1 0005 f5ec moveb %d1,5f5ec <c.6482> 4b73e: 727a moveq #122,%d1 4b740: b280 cmpl %d0,%d1
4b742: 663a bnes 4b77e <fifo_open+0x1fc>
c = 'a';
4b744: 7061 moveq #97,%d0 4b746: 13c0 0005 f5ec moveb %d0,5f5ec <c.6482> 4b74c: 6030 bras 4b77e <fifo_open+0x1fc>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
4b74e: 2f2a 0030 movel %a2@(48),%sp@- 4b752: 4eb9 0004 cf60 jsr 4cf60 <rtems_barrier_delete> 4b758: 588f addql #4,%sp
err_wbar: rtems_barrier_delete(pipe->readBarrier);
4b75a: 2f2d 002c movel %a5@(44),%sp@- 4b75e: 4eb9 0004 cf60 jsr 4cf60 <rtems_barrier_delete> 4b764: 588f addql #4,%sp
err_rbar: free(pipe->Buffer);
4b766: 2f15 movel %a5@,%sp@- 4b768: 4eb9 0004 421c jsr 4421c <free> 4b76e: 588f addql #4,%sp
err_buf: free(pipe);
4b770: 2f0d movel %a5,%sp@- 4b772: 4eb9 0004 421c jsr 4421c <free> 4b778: 588f addql #4,%sp
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4b77a: 74f4 moveq #-12,%d2 4b77c: 602c bras 4b7aa <fifo_open+0x228>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4b77e: 42a7 clrl %sp@- 4b780: 42a7 clrl %sp@- 4b782: 2f2a 0028 movel %a2@(40),%sp@- 4b786: 4eb9 0004 759c jsr 4759c <rtems_semaphore_obtain> 4b78c: 4fef 000c lea %sp@(12),%sp 4b790: 4a80 tstl %d0
4b792: 6702 beqs 4b796 <fifo_open+0x214> <== ALWAYS TAKEN
err = -EINTR;
4b794: 74fc moveq #-4,%d2 <== NOT EXECUTED
if (*pipep == NULL) {
4b796: 4a93 tstl %a3@
4b798: 6610 bnes 4b7aa <fifo_open+0x228>
if (err)
4b79a: 4a82 tstl %d2
4b79c: 670a beqs 4b7a8 <fifo_open+0x226> <== ALWAYS TAKEN
pipe_free(pipe);
4b79e: 2f0a movel %a2,%sp@- <== NOT EXECUTED 4b7a0: 4eba fd10 jsr %pc@(4b4b2 <pipe_free>) <== NOT EXECUTED 4b7a4: 588f addql #4,%sp <== NOT EXECUTED 4b7a6: 6002 bras 4b7aa <fifo_open+0x228> <== NOT EXECUTED
else
*pipep = pipe;
4b7a8: 268a movel %a2,%a3@
}
out:
pipe_unlock();
4b7aa: 4eba fcf0 jsr %pc@(4b49c <pipe_unlock>)
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
4b7ae: 4a82 tstl %d2 4b7b0: 6600 01a0 bnew 4b952 <fifo_open+0x3d0>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
4b7b4: 7006 moveq #6,%d0 4b7b6: 7204 moveq #4,%d1 4b7b8: c0ac 0014 andl %a4@(20),%d0
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
4b7bc: 2453 moveal %a3@,%a2
switch (LIBIO_ACCMODE(iop)) {
4b7be: b280 cmpl %d0,%d1 4b7c0: 6700 009c beqw 4b85e <fifo_open+0x2dc> 4b7c4: 123c 0006 moveb #6,%d1 4b7c8: b280 cmpl %d0,%d1 4b7ca: 6700 0122 beqw 4b8ee <fifo_open+0x36c> 4b7ce: 123c 0002 moveb #2,%d1 4b7d2: b280 cmpl %d0,%d1 4b7d4: 6600 0160 bnew 4b936 <fifo_open+0x3b4>
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
4b7d8: 202a 0010 movel %a2@(16),%d0 4b7dc: 2040 moveal %d0,%a0 4b7de: 5288 addql #1,%a0
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4b7e0: 52aa 0020 addql #1,%a2@(32)
if (pipe->Readers ++ == 0)
4b7e4: 2548 0010 movel %a0,%a2@(16) 4b7e8: 4a80 tstl %d0
4b7ea: 6610 bnes 4b7fc <fifo_open+0x27a> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
4b7ec: 486e fffc pea %fp@(-4) 4b7f0: 2f2a 0030 movel %a2@(48),%sp@- 4b7f4: 4eb9 0004 cffc jsr 4cffc <rtems_barrier_release> 4b7fa: 508f addql #8,%sp
if (pipe->Writers == 0) {
4b7fc: 4aaa 0014 tstl %a2@(20) 4b800: 6600 0134 bnew 4b936 <fifo_open+0x3b4>
/* Not an error */
if (LIBIO_NODELAY(iop))
4b804: 7001 moveq #1,%d0 4b806: c0ac 0014 andl %a4@(20),%d0 4b80a: 6600 012a bnew 4b936 <fifo_open+0x3b4>
break;
prevCounter = pipe->writerCounter;
4b80e: 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))
4b812: 4bf9 0004 759c lea 4759c <rtems_semaphore_obtain>,%a5
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4b818: 283c 0004 76a4 movel #292516,%d4
if (! PIPE_READWAIT(pipe))
4b81e: 263c 0004 d060 movel #315488,%d3
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4b824: 2f2a 0028 movel %a2@(40),%sp@- 4b828: 2044 moveal %d4,%a0 4b82a: 4e90 jsr %a0@
if (! PIPE_READWAIT(pipe))
4b82c: 2043 moveal %d3,%a0 4b82e: 42a7 clrl %sp@- 4b830: 2f2a 002c movel %a2@(44),%sp@- 4b834: 4e90 jsr %a0@ 4b836: 4fef 000c lea %sp@(12),%sp 4b83a: 4a80 tstl %d0 4b83c: 6600 0106 bnew 4b944 <fifo_open+0x3c2>
goto out_error;
if (! PIPE_LOCK(pipe))
4b840: 42a7 clrl %sp@- 4b842: 42a7 clrl %sp@- 4b844: 2f2a 0028 movel %a2@(40),%sp@- 4b848: 4e95 jsr %a5@ 4b84a: 4fef 000c lea %sp@(12),%sp 4b84e: 4a80 tstl %d0 4b850: 6600 00f2 bnew 4b944 <fifo_open+0x3c2>
goto out_error;
} while (prevCounter == pipe->writerCounter);
4b854: baaa 0024 cmpl %a2@(36),%d5
4b858: 67ca beqs 4b824 <fifo_open+0x2a2> <== NEVER TAKEN
4b85a: 6000 00da braw 4b936 <fifo_open+0x3b4>
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4b85e: 202a 0014 movel %a2@(20),%d0 4b862: 2200 movel %d0,%d1 4b864: 5281 addql #1,%d1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4b866: 52aa 0024 addql #1,%a2@(36)
if (pipe->Writers ++ == 0)
4b86a: 2541 0014 movel %d1,%a2@(20) 4b86e: 4a80 tstl %d0
4b870: 6610 bnes 4b882 <fifo_open+0x300> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4b872: 486e fffc pea %fp@(-4) 4b876: 2f2a 002c movel %a2@(44),%sp@- 4b87a: 4eb9 0004 cffc jsr 4cffc <rtems_barrier_release> 4b880: 508f addql #8,%sp
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4b882: 4aaa 0010 tstl %a2@(16) 4b886: 6600 00ae bnew 4b936 <fifo_open+0x3b4> 4b88a: 7001 moveq #1,%d0 4b88c: c0ac 0014 andl %a4@(20),%d0
4b890: 6712 beqs 4b8a4 <fifo_open+0x322> PIPE_UNLOCK(pipe);
4b892: 2f2a 0028 movel %a2@(40),%sp@-
err = -ENXIO;
4b896: 74fa moveq #-6,%d2
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
4b898: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
4b89e: 588f addql #4,%sp 4b8a0: 6000 00a4 braw 4b946 <fifo_open+0x3c4>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
4b8a4: 2a2a 0020 movel %a2@(32),%d5
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
4b8a8: 4bf9 0004 759c lea 4759c <rtems_semaphore_obtain>,%a5
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4b8ae: 283c 0004 76a4 movel #292516,%d4
if (! PIPE_WRITEWAIT(pipe))
4b8b4: 263c 0004 d060 movel #315488,%d3
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4b8ba: 2f2a 0028 movel %a2@(40),%sp@- 4b8be: 2044 moveal %d4,%a0 4b8c0: 4e90 jsr %a0@
if (! PIPE_WRITEWAIT(pipe))
4b8c2: 2043 moveal %d3,%a0 4b8c4: 42a7 clrl %sp@- 4b8c6: 2f2a 0030 movel %a2@(48),%sp@- 4b8ca: 4e90 jsr %a0@ 4b8cc: 4fef 000c lea %sp@(12),%sp 4b8d0: 4a80 tstl %d0
4b8d2: 6670 bnes 4b944 <fifo_open+0x3c2> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
4b8d4: 42a7 clrl %sp@- 4b8d6: 42a7 clrl %sp@- 4b8d8: 2f2a 0028 movel %a2@(40),%sp@- 4b8dc: 4e95 jsr %a5@ 4b8de: 4fef 000c lea %sp@(12),%sp 4b8e2: 4a80 tstl %d0
4b8e4: 665e bnes 4b944 <fifo_open+0x3c2> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
4b8e6: baaa 0020 cmpl %a2@(32),%d5
4b8ea: 67ce beqs 4b8ba <fifo_open+0x338> <== NEVER TAKEN
4b8ec: 6048 bras 4b936 <fifo_open+0x3b4>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
4b8ee: 202a 0010 movel %a2@(16),%d0 4b8f2: 2200 movel %d0,%d1 4b8f4: 5281 addql #1,%d1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4b8f6: 52aa 0020 addql #1,%a2@(32)
if (pipe->Readers ++ == 0)
4b8fa: 2541 0010 movel %d1,%a2@(16) 4b8fe: 4a80 tstl %d0
4b900: 6610 bnes 4b912 <fifo_open+0x390> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
4b902: 486e fffc pea %fp@(-4) 4b906: 2f2a 0030 movel %a2@(48),%sp@- 4b90a: 4eb9 0004 cffc jsr 4cffc <rtems_barrier_release> 4b910: 508f addql #8,%sp
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4b912: 202a 0014 movel %a2@(20),%d0 4b916: 2040 moveal %d0,%a0 4b918: 5288 addql #1,%a0
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
4b91a: 52aa 0024 addql #1,%a2@(36)
if (pipe->Writers ++ == 0)
4b91e: 2548 0014 movel %a0,%a2@(20) 4b922: 4a80 tstl %d0
4b924: 6610 bnes 4b936 <fifo_open+0x3b4> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4b926: 486e fffc pea %fp@(-4) 4b92a: 2f2a 002c movel %a2@(44),%sp@- 4b92e: 4eb9 0004 cffc jsr 4cffc <rtems_barrier_release> 4b934: 508f addql #8,%sp
break;
}
PIPE_UNLOCK(pipe);
4b936: 2f2a 0028 movel %a2@(40),%sp@- 4b93a: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release>
return 0;
4b940: 588f addql #4,%sp 4b942: 600e bras 4b952 <fifo_open+0x3d0>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
4b944: 74fc moveq #-4,%d2 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
4b946: 2f0c movel %a4,%sp@- 4b948: 2f0b movel %a3,%sp@- 4b94a: 4eb9 0004 b4fa jsr 4b4fa <pipe_release>
return err;
4b950: 508f addql #8,%sp
}
4b952: 2002 movel %d2,%d0 4b954: 4cee 3c3c ffd8 moveml %fp@(-40),%d2-%d5/%a2-%a5
4b95a: 4e5e unlk %fp <== NOT EXECUTED
000434fc <fpathconf>:
long fpathconf(
int fd,
int name
)
{
434fc: 4e56 0000 linkw %fp,#0 43500: 202e 0008 movel %fp@(8),%d0 43504: 222e 000c movel %fp@(12),%d1 43508: 2f02 movel %d2,%sp@-
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
4350a: b0b9 0005 ea54 cmpl 5ea54 <rtems_libio_number_iops>,%d0
43510: 641a bccs 4352c <fpathconf+0x30> iop = rtems_libio_iop(fd);
43512: 2400 movel %d0,%d2 43514: ed88 lsll #6,%d0 43516: e78a lsll #3,%d2 43518: 2079 0006 02d4 moveal 602d4 <rtems_libio_iops>,%a0 4351e: 9082 subl %d2,%d0 43520: d1c0 addal %d0,%a0
rtems_libio_check_is_open(iop);
43522: 2028 0014 movel %a0@(20),%d0 43526: 0800 0008 btst #8,%d0
4352a: 6610 bnes 4353c <fpathconf+0x40> <== ALWAYS TAKEN
4352c: 4eb9 0004 da3c jsr 4da3c <__errno> 43532: 7209 moveq #9,%d1 43534: 2040 moveal %d0,%a0 43536: 2081 movel %d1,%a0@ 43538: 6000 0088 braw 435c2 <fpathconf+0xc6>
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
4353c: 0800 0001 btst #1,%d0
43540: 6774 beqs 435b6 <fpathconf+0xba>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
43542: 2068 0028 moveal %a0@(40),%a0
switch ( name ) {
43546: 700b moveq #11,%d0 43548: b081 cmpl %d1,%d0
4354a: 656a bcss 435b6 <fpathconf+0xba>
4354c: 303b 1a08 movew %pc@(43556 <fpathconf+0x5a>,%d1:l:2),%d0 43550: 48c0 extl %d0 43552: 4efb 0802 jmp %pc@(43556 <fpathconf+0x5a>,%d0:l)
43556: 0018 .short 0x0018 <== NOT EXECUTED 43558: 001e .short 0x001e <== NOT EXECUTED 4355a: 0024 .short 0x0024 <== NOT EXECUTED 4355c: 002a .short 0x002a <== NOT EXECUTED 4355e: 0030 .short 0x0030 <== NOT EXECUTED 43560: 0036 .short 0x0036 <== NOT EXECUTED 43562: 003c .short 0x003c <== NOT EXECUTED 43564: 0042 .short 0x0042 <== NOT EXECUTED 43566: 0048 .short 0x0048 <== NOT EXECUTED 43568: 004e .short 0x004e <== NOT EXECUTED 4356a: 0054 .short 0x0054 <== NOT EXECUTED 4356c: 005a .short 0x005a <== NOT EXECUTED
case _PC_LINK_MAX:
return_value = the_limits->link_max;
4356e: 2028 0038 movel %a0@(56),%d0
break;
43572: 6050 bras 435c4 <fpathconf+0xc8>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
43574: 2028 003c movel %a0@(60),%d0
break;
43578: 604a bras 435c4 <fpathconf+0xc8>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
4357a: 2028 0040 movel %a0@(64),%d0
break;
4357e: 6044 bras 435c4 <fpathconf+0xc8>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
43580: 2028 0044 movel %a0@(68),%d0
break;
43584: 603e bras 435c4 <fpathconf+0xc8>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
43586: 2028 0048 movel %a0@(72),%d0
break;
4358a: 6038 bras 435c4 <fpathconf+0xc8>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
4358c: 2028 004c movel %a0@(76),%d0
break;
43590: 6032 bras 435c4 <fpathconf+0xc8>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
43592: 2028 0054 movel %a0@(84),%d0
break;
43596: 602c bras 435c4 <fpathconf+0xc8>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
43598: 2028 0058 movel %a0@(88),%d0
break;
4359c: 6026 bras 435c4 <fpathconf+0xc8>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
4359e: 2028 0064 movel %a0@(100),%d0
break;
435a2: 6020 bras 435c4 <fpathconf+0xc8>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
435a4: 2028 0050 movel %a0@(80),%d0
break;
435a8: 601a bras 435c4 <fpathconf+0xc8>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
435aa: 2028 005c movel %a0@(92),%d0
break;
435ae: 6014 bras 435c4 <fpathconf+0xc8>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
435b0: 2028 0060 movel %a0@(96),%d0
break;
435b4: 600e bras 435c4 <fpathconf+0xc8>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
435b6: 4eb9 0004 da3c jsr 4da3c <__errno> 435bc: 2040 moveal %d0,%a0 435be: 7016 moveq #22,%d0 435c0: 2080 movel %d0,%a0@ 435c2: 70ff moveq #-1,%d0
break;
}
return return_value;
}
435c4: 242e fffc movel %fp@(-4),%d2
435c8: 4e5e unlk %fp <== NOT EXECUTED
000429ec <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
429ec: 4e56 0000 linkw %fp,#0
MSBUMP(free_calls, 1);
429f0: 52b9 0005 e898 addql #1,5e898 <rtems_malloc_statistics+0xc>
#include <stdlib.h>
void free(
void *ptr
)
{
429f6: 2f02 movel %d2,%sp@- 429f8: 242e 0008 movel %fp@(8),%d2
MSBUMP(free_calls, 1);
if ( !ptr )
429fc: 676c beqs 42a6a <free+0x7e>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
429fe: 7003 moveq #3,%d0 42a00: b0b9 0005 eb14 cmpl 5eb14 <_System_state_Current>,%d0
42a06: 661a bnes 42a22 <free+0x36> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
42a08: 4eb9 0004 2b90 jsr 42b90 <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()) &&
42a0e: 4a00 tstb %d0
42a10: 6610 bnes 42a22 <free+0x36>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
42a12: 2d42 0008 movel %d2,%fp@(8)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
42a16: 242e fffc movel %fp@(-4),%d2 42a1a: 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);
42a1c: 4ef9 0004 2c04 jmp 42c04 <malloc_deferred_free>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
42a22: 2079 0005 d806 moveal 5d806 <rtems_malloc_statistics_helpers>,%a0 42a28: 4a88 tstl %a0
42a2a: 670a beqs 42a36 <free+0x4a>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
42a2c: 2f02 movel %d2,%sp@- 42a2e: 2068 0008 moveal %a0@(8),%a0 42a32: 4e90 jsr %a0@ 42a34: 588f addql #4,%sp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
42a36: 2f02 movel %d2,%sp@- 42a38: 2f39 0005 d030 movel 5d030 <RTEMS_Malloc_Heap>,%sp@- 42a3e: 4eb9 0004 71fc jsr 471fc <_Protected_heap_Free> 42a44: 508f addql #8,%sp 42a46: 4a00 tstb %d0
42a48: 6620 bnes 42a6a <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
42a4a: 2079 0005 d030 moveal 5d030 <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",
42a50: 2f28 001c movel %a0@(28),%sp@- 42a54: 2f28 0018 movel %a0@(24),%sp@- 42a58: 2f02 movel %d2,%sp@- 42a5a: 4879 0005 c07a pea 5c07a <rtems_status_assoc+0x168> 42a60: 4eb9 0004 36ac jsr 436ac <printk> 42a66: 4fef 0010 lea %sp@(16),%sp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
42a6a: 242e fffc movel %fp@(-4),%d2 42a6e: 4e5e unlk %fp
...
00043d64 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
43d64: 4e56 0000 linkw %fp,#0 43d68: 2f0b movel %a3,%sp@- 43d6a: 2f0a movel %a2,%sp@- 43d6c: 246e 0008 moveal %fp@(8),%a2
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
43d70: b5fc 0005 f0c4 cmpal #389316,%a2
43d76: 6728 beqs 43da0 <free_user_env+0x3c> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
43d78: 486a 0004 pea %a2@(4) 43d7c: 47f9 0004 2e1c lea 42e1c <rtems_filesystem_freenode>,%a3 43d82: 4e93 jsr %a3@
rtems_filesystem_freenode( &env->root_directory);
43d84: 486a 0018 pea %a2@(24) 43d88: 4e93 jsr %a3@
free(env);
}
}
43d8a: 266e fffc moveal %fp@(-4),%a3
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
43d8e: 508f addql #8,%sp 43d90: 2d4a 0008 movel %a2,%fp@(8)
} }
43d94: 246e fff8 moveal %fp@(-8),%a2 43d98: 4e5e unlk %fp
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
43d9a: 4ef9 0004 2e30 jmp 42e30 <free>
} }
43da0: 246e fff8 moveal %fp@(-8),%a2 <== NOT EXECUTED 43da4: 266e fffc moveal %fp@(-4),%a3 <== NOT EXECUTED 43da8: 4e5e unlk %fp <== NOT EXECUTED
0005beb0 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
5beb0: 4e56 ffec linkw %fp,#-20 5beb4: 202e 0008 movel %fp@(8),%d0 5beb8: 2f0a movel %a2,%sp@- 5beba: 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 );
5bebc: b0b9 0005 ef84 cmpl 5ef84 <rtems_libio_number_iops>,%d0
5bec2: 6412 bccs 5bed6 <getdents+0x26> <== NEVER TAKEN
5bec4: 2200 movel %d0,%d1 5bec6: ed88 lsll #6,%d0 5bec8: e789 lsll #3,%d1 5beca: 2479 0006 0914 moveal 60914 <rtems_libio_iops>,%a2 5bed0: 9081 subl %d1,%d0 5bed2: d5c0 addal %d0,%a2 5bed4: 6002 bras 5bed8 <getdents+0x28>
5bed6: 95ca subal %a2,%a2 <== NOT EXECUTED
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
5bed8: 4878 0014 pea 14 <OPER2> 5bedc: 240e movel %fp,%d2 5bede: 486a 0018 pea %a2@(24) 5bee2: 0682 ffff ffec addil #-20,%d2 5bee8: 2f02 movel %d2,%sp@- 5beea: 4eb9 0004 e284 jsr 4e284 <memcpy>
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
5bef0: 206e fff8 moveal %fp@(-8),%a0 5bef4: 2f02 movel %d2,%sp@- 5bef6: 2068 0010 moveal %a0@(16),%a0 5befa: 4e90 jsr %a0@ 5befc: 4fef 0010 lea %sp@(16),%sp 5bf00: 7201 moveq #1,%d1 5bf02: b280 cmpl %d0,%d1
5bf04: 6710 beqs 5bf16 <getdents+0x66>
rtems_set_errno_and_return_minus_one( ENOTDIR );
5bf06: 4eb9 0004 d9d8 jsr 4d9d8 <__errno> 5bf0c: 2040 moveal %d0,%a0 5bf0e: 7014 moveq #20,%d0 5bf10: 2080 movel %d0,%a0@ 5bf12: 70ff moveq #-1,%d0 5bf14: 6018 bras 5bf2e <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 );
5bf16: 206a 0020 moveal %a2@(32),%a0 5bf1a: 2f2e 0010 movel %fp@(16),%sp@- 5bf1e: 2f2e 000c movel %fp@(12),%sp@- 5bf22: 2f0a movel %a2,%sp@- 5bf24: 2068 0008 moveal %a0@(8),%a0 5bf28: 4e90 jsr %a0@ 5bf2a: 4fef 000c lea %sp@(12),%sp
}
5bf2e: 242e ffe4 movel %fp@(-28),%d2 5bf32: 246e ffe8 moveal %fp@(-24),%a2 5bf36: 4e5e unlk %fp
...
0004c0ca <imfs_dir_lseek>:
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
switch( whence ) {
4c0ca: 7001 moveq #1,%d0
rtems_off64_t imfs_dir_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
4c0cc: 4e56 ffec linkw %fp,#-20 4c0d0: 48d7 043c moveml %d2-%d5/%a2,%sp@ 4c0d4: 246e 0008 moveal %fp@(8),%a2
switch( whence ) {
4c0d8: b0ae 0014 cmpl %fp@(20),%d0
4c0dc: 654c bcss 4c12a <imfs_dir_lseek+0x60> <== NEVER TAKEN
case SEEK_SET: /* absolute move from the start of the file */
case SEEK_CUR: /* relative move */
iop->offset = (iop->offset/sizeof(struct dirent)) *
4c0de: 4878 0110 pea 110 <DBL_MANT_DIG+0xdb> 4c0e2: 7a1c moveq #28,%d5 4c0e4: 42a7 clrl %sp@- 4c0e6: 2f2a 0010 movel %a2@(16),%sp@- 4c0ea: 2f2a 000c movel %a2@(12),%sp@- 4c0ee: 4eb9 0005 9398 jsr 59398 <__divdi3> 4c0f4: 4fef 0010 lea %sp@(16),%sp 4c0f8: 2600 movel %d0,%d3 4c0fa: 2801 movel %d1,%d4 4c0fc: eaac lsrl %d5,%d4 4c0fe: 2004 movel %d4,%d0 4c100: e98b lsll #4,%d3 4c102: e989 lsll #4,%d1 4c104: 8083 orl %d3,%d0 4c106: 2801 movel %d1,%d4 4c108: eaac lsrl %d5,%d4 4c10a: 2400 movel %d0,%d2 4c10c: 2601 movel %d1,%d3 4c10e: e98a lsll #4,%d2 4c110: e98b lsll #4,%d3 4c112: 8484 orl %d4,%d2 4c114: 2800 movel %d0,%d4 4c116: 2a01 movel %d1,%d5 4c118: da83 addl %d3,%d5 4c11a: d982 addxl %d2,%d4
default:
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return 0;
4c11c: 4281 clrl %d1 4c11e: 4282 clrl %d2
)
{
switch( whence ) {
case SEEK_SET: /* absolute move from the start of the file */
case SEEK_CUR: /* relative move */
iop->offset = (iop->offset/sizeof(struct dirent)) *
4c120: 2544 000c movel %d4,%a2@(12) 4c124: 2545 0010 movel %d5,%a2@(16)
default:
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return 0;
4c128: 6010 bras 4c13a <imfs_dir_lseek+0x70>
break;
case SEEK_END: /* Movement past the end of the directory via lseek */
/* is not a permitted operation */
default:
rtems_set_errno_and_return_minus_one( EINVAL );
4c12a: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4c130: 2040 moveal %d0,%a0 4c132: 7016 moveq #22,%d0 4c134: 72ff moveq #-1,%d1 4c136: 74ff moveq #-1,%d2 4c138: 2080 movel %d0,%a0@
break;
}
return 0;
}
4c13a: 2001 movel %d1,%d0 4c13c: 2202 movel %d2,%d1 4c13e: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
4c144: 4e5e unlk %fp <== NOT EXECUTED
0004bfa8 <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 )
4bfa8: 7001 moveq #1,%d0
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
4bfaa: 4e56 0000 linkw %fp,#0 4bfae: 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 )
4bfb2: 2268 0018 moveal %a0@(24),%a1 4bfb6: b0a9 0048 cmpl %a1@(72),%d0
4bfba: 6610 bnes 4bfcc <imfs_dir_open+0x24> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
4bfbc: 4280 clrl %d0 4bfbe: 4281 clrl %d1 4bfc0: 2140 000c movel %d0,%a0@(12) 4bfc4: 2141 0010 movel %d1,%a0@(16)
return 0;
4bfc8: 4280 clrl %d0 4bfca: 6002 bras 4bfce <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 */
4bfcc: 70ff moveq #-1,%d0 <== NOT EXECUTED
iop->offset = 0;
return 0;
}
4bfce: 4e5e unlk %fp <== NOT EXECUTED
0004c1dc <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
4c1dc: 4e56 0000 linkw %fp,#0 4c1e0: 206e 000c moveal %fp@(12),%a0 4c1e4: 2f0a movel %a2,%sp@-
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
4c1e6: 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 );
4c1e8: 200a movel %a2,%d0 4c1ea: 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 ) )
4c1f0: b0aa 004c cmpl %a2@(76),%d0
4c1f4: 670e beqs 4c204 <imfs_dir_rmnod+0x28>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
4c1f6: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4c1fc: 2040 moveal %d0,%a0 4c1fe: 705a moveq #90,%d0 4c200: 2080 movel %d0,%a0@ 4c202: 6016 bras 4c21a <imfs_dir_rmnod+0x3e>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
4c204: 2068 0010 moveal %a0@(16),%a0 4c208: b5e8 001c cmpal %a0@(28),%a2
4c20c: 6610 bnes 4c21e <imfs_dir_rmnod+0x42>
rtems_set_errno_and_return_minus_one( EBUSY );
4c20e: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4c214: 7210 moveq #16,%d1 4c216: 2040 moveal %d0,%a0 4c218: 2081 movel %d1,%a0@ 4c21a: 70ff moveq #-1,%d0 4c21c: 601a bras 4c238 <imfs_dir_rmnod+0x5c>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
4c21e: 4aaa 0058 tstl %a2@(88)
4c222: 66ea bnes 4c20e <imfs_dir_rmnod+0x32> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
4c224: 2f0a movel %a2,%sp@- 4c226: 4eb9 0004 96bc jsr 496bc <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
4c22c: 2f0a movel %a2,%sp@- 4c22e: 4eb9 0004 9700 jsr 49700 <IMFS_check_node_remove>
return 0;
4c234: 508f addql #8,%sp 4c236: 4280 clrl %d0
}
4c238: 246e fffc moveal %fp@(-4),%a2
4c23c: 4e5e unlk %fp <== NOT EXECUTED
00043354 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
43354: 4e56 0000 linkw %fp,#0 43358: 2f0a movel %a2,%sp@- 4335a: 2f02 movel %d2,%sp@-
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
4335c: 4a39 0005 fb52 tstb 5fb52 <etc_passwd_initted.6408> 43362: 6600 00c4 bnew 43428 <init_etc_passwd_group+0xd4>
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
43366: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
4336a: 45f9 0004 e078 lea 4e078 <fopen>,%a2
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
43370: 4879 0005 d904 pea 5d904 <rtems_status_assoc+0x1a0>
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
43376: 7001 moveq #1,%d0 43378: 13c0 0005 fb52 moveb %d0,5fb52 <etc_passwd_initted.6408>
mkdir("/etc", 0777);
4337e: 4eb9 0004 3b64 jsr 43b64 <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
43384: 4879 0005 e1ed pea 5e1ed <_global_impure_ptr+0xbf> 4338a: 4879 0005 d909 pea 5d909 <rtems_status_assoc+0x1a5> 43390: 4e92 jsr %a2@ 43392: 4fef 0010 lea %sp@(16),%sp 43396: 4a80 tstl %d0
43398: 670c beqs 433a6 <init_etc_passwd_group+0x52>
fclose(fp);
4339a: 2f00 movel %d0,%sp@- 4339c: 4eb9 0004 d97a jsr 4d97a <fclose> 433a2: 588f addql #4,%sp 433a4: 602e bras 433d4 <init_etc_passwd_group+0x80>
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
433a6: 4879 0005 d915 pea 5d915 <rtems_status_assoc+0x1b1> 433ac: 4879 0005 d909 pea 5d909 <rtems_status_assoc+0x1a5> 433b2: 4e92 jsr %a2@ 433b4: 508f addql #8,%sp 433b6: 2400 movel %d0,%d2
433b8: 671a beqs 433d4 <init_etc_passwd_group+0x80> <== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
433ba: 2f00 movel %d0,%sp@- 433bc: 4879 0005 d917 pea 5d917 <rtems_status_assoc+0x1b3> 433c2: 4eb9 0004 e158 jsr 4e158 <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
433c8: 2f02 movel %d2,%sp@- 433ca: 4eb9 0004 d97a jsr 4d97a <fclose> 433d0: 4fef 000c lea %sp@(12),%sp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
433d4: 4879 0005 e1ed pea 5e1ed <_global_impure_ptr+0xbf> 433da: 45f9 0004 e078 lea 4e078 <fopen>,%a2 433e0: 4879 0005 d97e pea 5d97e <rtems_status_assoc+0x21a> 433e6: 4e92 jsr %a2@ 433e8: 508f addql #8,%sp 433ea: 4a80 tstl %d0
433ec: 670c beqs 433fa <init_etc_passwd_group+0xa6>
fclose(fp);
433ee: 2f00 movel %d0,%sp@- 433f0: 4eb9 0004 d97a jsr 4d97a <fclose> 433f6: 588f addql #4,%sp 433f8: 602e bras 43428 <init_etc_passwd_group+0xd4>
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
433fa: 4879 0005 d915 pea 5d915 <rtems_status_assoc+0x1b1> 43400: 4879 0005 d97e pea 5d97e <rtems_status_assoc+0x21a> 43406: 4e92 jsr %a2@ 43408: 508f addql #8,%sp 4340a: 2400 movel %d0,%d2
4340c: 671a beqs 43428 <init_etc_passwd_group+0xd4> <== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
4340e: 2f00 movel %d0,%sp@- 43410: 4879 0005 d989 pea 5d989 <rtems_status_assoc+0x225> 43416: 4eb9 0004 e158 jsr 4e158 <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
4341c: 2f02 movel %d2,%sp@- 4341e: 4eb9 0004 d97a jsr 4d97a <fclose> 43424: 4fef 000c lea %sp@(12),%sp
} }
43428: 242e fff8 movel %fp@(-8),%d2 4342c: 246e fffc moveal %fp@(-4),%a2
43430: 4e5e unlk %fp <== NOT EXECUTED
0004450e <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
4450e: 4e56 fff4 linkw %fp,#-12 44512: 222e 0008 movel %fp@(8),%d1 44516: 48d7 040c moveml %d2-%d3/%a2,%sp@ 4451a: 246e 000c moveal %fp@(12),%a2
if (tty->termios.c_iflag & ISTRIP)
4451e: 202a 0030 movel %a2@(48),%d0
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
44522: 1401 moveb %d1,%d2
if (tty->termios.c_iflag & ISTRIP)
44524: 0800 0005 btst #5,%d0
44528: 6704 beqs 4452e <iproc+0x20> <== ALWAYS TAKEN
c &= 0x7f;
4452a: 747f moveq #127,%d2 <== NOT EXECUTED 4452c: c481 andl %d1,%d2 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
4452e: 0800 0009 btst #9,%d0
44532: 6724 beqs 44558 <iproc+0x4a>
c = tolower (c);
44534: 2079 0005 d308 moveal 5d308 <__ctype_ptr__>,%a0 4453a: 7603 moveq #3,%d3 4453c: 0282 0000 00ff andil #255,%d2 44542: 1230 2801 moveb %a0@(00000001,%d2:l),%d1 44546: 49c1 extbl %d1 44548: c283 andl %d3,%d1 4454a: 163c 0001 moveb #1,%d3 4454e: b681 cmpl %d1,%d3
44550: 6606 bnes 44558 <iproc+0x4a>
44552: 0682 0000 0020 addil #32,%d2
if (c == '\r') {
44558: 4281 clrl %d1 4455a: 1202 moveb %d2,%d1 4455c: 760d moveq #13,%d3 4455e: b681 cmpl %d1,%d3
44560: 6610 bnes 44572 <iproc+0x64>
if (tty->termios.c_iflag & IGNCR)
44562: 4a00 tstb %d0 44564: 6d00 0104 bltw 4466a <iproc+0x15c>
return 0;
if (tty->termios.c_iflag & ICRNL)
44568: 0800 0008 btst #8,%d0
4456c: 671a beqs 44588 <iproc+0x7a> <== NEVER TAKEN
c = '\n';
4456e: 740a moveq #10,%d2 44570: 6016 bras 44588 <iproc+0x7a>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
44572: 760a moveq #10,%d3 44574: b681 cmpl %d1,%d3
44576: 660a bnes 44582 <iproc+0x74>
44578: 0800 0006 btst #6,%d0
4457c: 670a beqs 44588 <iproc+0x7a> <== ALWAYS TAKEN
c = '\r';
4457e: 740d moveq #13,%d2 <== NOT EXECUTED 44580: 6006 bras 44588 <iproc+0x7a> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
44582: 4a02 tstb %d2 44584: 6700 00a8 beqw 4462e <iproc+0x120> 44588: 222a 003c movel %a2@(60),%d1 4458c: 0801 0001 btst #1,%d1 44590: 6700 009c beqw 4462e <iproc+0x120>
if (c == tty->termios.c_cc[VERASE]) {
44594: 4283 clrl %d3 44596: 162a 0043 moveb %a2@(67),%d3 4459a: 4280 clrl %d0 4459c: 1002 moveb %d2,%d0 4459e: b680 cmpl %d0,%d3
445a0: 6604 bnes 445a6 <iproc+0x98>
erase (tty, 0);
445a2: 42a7 clrl %sp@- 445a4: 600e bras 445b4 <iproc+0xa6>
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
445a6: 4283 clrl %d3 445a8: 162a 0044 moveb %a2@(68),%d3 445ac: b680 cmpl %d0,%d3
445ae: 6610 bnes 445c0 <iproc+0xb2>
erase (tty, 1);
445b0: 4878 0001 pea 1 <ADD> 445b4: 2f0a movel %a2,%sp@- 445b6: 4eba fdc4 jsr %pc@(4437c <erase>)
return 0;
445ba: 508f addql #8,%sp 445bc: 6000 00ac braw 4466a <iproc+0x15c>
}
else if (c == tty->termios.c_cc[VEOF]) {
445c0: 4283 clrl %d3 445c2: 162a 0045 moveb %a2@(69),%d3 445c6: b680 cmpl %d0,%d3 445c8: 6700 009c beqw 44666 <iproc+0x158>
return 1;
} else if (c == '\n') {
445cc: 760a moveq #10,%d3 445ce: b680 cmpl %d0,%d3
445d0: 6622 bnes 445f4 <iproc+0xe6>
if (tty->termios.c_lflag & (ECHO | ECHONL))
445d2: 7048 moveq #72,%d0 445d4: c280 andl %d0,%d1
445d6: 670c beqs 445e4 <iproc+0xd6> <== NEVER TAKEN
echo (c, tty);
445d8: 2f0a movel %a2,%sp@- 445da: 4878 000a pea a <LASTO> 445de: 4eba fd14 jsr %pc@(442f4 <echo>) 445e2: 508f addql #8,%sp
tty->cbuf[tty->ccount++] = c;
445e4: 202a 0020 movel %a2@(32),%d0 445e8: 206a 001c moveal %a2@(28),%a0 445ec: 720a moveq #10,%d1 445ee: 1181 0800 moveb %d1,%a0@(00000000,%d0:l) 445f2: 6032 bras 44626 <iproc+0x118>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
445f4: 4283 clrl %d3 445f6: 162a 004c moveb %a2@(76),%d3 445fa: b680 cmpl %d0,%d3
445fc: 670a beqs 44608 <iproc+0xfa> <== NEVER TAKEN
445fe: 4283 clrl %d3 44600: 162a 0051 moveb %a2@(81),%d3 44604: b680 cmpl %d0,%d3
44606: 6626 bnes 4462e <iproc+0x120> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
44608: 44c1 movew %d1,%ccr <== NOT EXECUTED 4460a: 6a0e bpls 4461a <iproc+0x10c> <== NOT EXECUTED
echo (c, tty);
4460c: 2f0a movel %a2,%sp@- <== NOT EXECUTED 4460e: 4280 clrl %d0 <== NOT EXECUTED 44610: 1002 moveb %d2,%d0 <== NOT EXECUTED 44612: 2f00 movel %d0,%sp@- <== NOT EXECUTED 44614: 4eba fcde jsr %pc@(442f4 <echo>) <== NOT EXECUTED 44618: 508f addql #8,%sp <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
4461a: 202a 0020 movel %a2@(32),%d0 <== NOT EXECUTED 4461e: 206a 001c moveal %a2@(28),%a0 <== NOT EXECUTED 44622: 1182 0800 moveb %d2,%a0@(00000000,%d0:l) <== NOT EXECUTED
44626: 5280 addql #1,%d0 44628: 2540 0020 movel %d0,%a2@(32) 4462c: 6038 bras 44666 <iproc+0x158>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
4462e: 2039 0005 d234 movel 5d234 <rtems_termios_cbufsize>,%d0 44634: 5380 subql #1,%d0 44636: b0aa 0020 cmpl %a2@(32),%d0
4463a: 6f2e bles 4466a <iproc+0x15c> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
4463c: 7008 moveq #8,%d0 4463e: c0aa 003c andl %a2@(60),%d0
44642: 670e beqs 44652 <iproc+0x144> <== NEVER TAKEN
echo (c, tty);
44644: 2f0a movel %a2,%sp@- 44646: 4280 clrl %d0 44648: 1002 moveb %d2,%d0 4464a: 2f00 movel %d0,%sp@- 4464c: 4eba fca6 jsr %pc@(442f4 <echo>) 44650: 508f addql #8,%sp
tty->cbuf[tty->ccount++] = c;
44652: 202a 0020 movel %a2@(32),%d0 44656: 206a 001c moveal %a2@(28),%a0 4465a: 1182 0800 moveb %d2,%a0@(00000000,%d0:l) 4465e: 5280 addql #1,%d0 44660: 2540 0020 movel %d0,%a2@(32) 44664: 6004 bras 4466a <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;
44666: 7001 moveq #1,%d0 44668: 6002 bras 4466c <iproc+0x15e>
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
4466a: 4280 clrl %d0
}
4466c: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
44672: 4e5e unlk %fp <== NOT EXECUTED
0005ac38 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
5ac38: 4e56 ffd0 linkw %fp,#-48 5ac3c: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@ 5ac40: 242e 000c movel %fp@(12),%d2 5ac44: 246e 0010 moveal %fp@(16),%a2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
5ac48: 4eb9 0005 a85c jsr 5a85c <getpid> 5ac4e: b0ae 0008 cmpl %fp@(8),%d0
5ac52: 6710 beqs 5ac64 <killinfo+0x2c>
rtems_set_errno_and_return_minus_one( ESRCH );
5ac54: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5ac5a: 7403 moveq #3,%d2 5ac5c: 2040 moveal %d0,%a0 5ac5e: 2082 movel %d2,%a0@ 5ac60: 6000 01ae braw 5ae10 <killinfo+0x1d8>
/*
* Validate the signal passed.
*/
if ( !sig )
5ac64: 4a82 tstl %d2
5ac66: 670a beqs 5ac72 <killinfo+0x3a>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
5ac68: 2202 movel %d2,%d1 5ac6a: 5381 subql #1,%d1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
5ac6c: 701f moveq #31,%d0 5ac6e: b081 cmpl %d1,%d0
5ac70: 6410 bccs 5ac82 <killinfo+0x4a>
rtems_set_errno_and_return_minus_one( EINVAL );
5ac72: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5ac78: 7216 moveq #22,%d1 5ac7a: 2040 moveal %d0,%a0 5ac7c: 2081 movel %d1,%a0@ 5ac7e: 6000 0190 braw 5ae10 <killinfo+0x1d8>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
5ac82: 2602 movel %d2,%d3 5ac84: 2002 movel %d2,%d0 5ac86: e58b lsll #2,%d3 5ac88: e988 lsll #4,%d0 5ac8a: 9083 subl %d3,%d0 5ac8c: 0680 0005 ee6c addil #388716,%d0 5ac92: 7601 moveq #1,%d3 5ac94: 2040 moveal %d0,%a0 5ac96: b690 cmpl %a0@,%d3 5ac98: 6700 01a6 beqw 5ae40 <killinfo+0x208>
/* * 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 ) )
5ac9c: 7008 moveq #8,%d0 5ac9e: b082 cmpl %d2,%d0
5aca0: 6710 beqs 5acb2 <killinfo+0x7a>
5aca2: 163c 0004 moveb #4,%d3 5aca6: b682 cmpl %d2,%d3
5aca8: 6708 beqs 5acb2 <killinfo+0x7a>
5acaa: 103c 000b moveb #11,%d0 5acae: b082 cmpl %d2,%d0
5acb0: 6616 bnes 5acc8 <killinfo+0x90>
return pthread_kill( pthread_self(), sig );
5acb2: 4eb9 0005 b014 jsr 5b014 <pthread_self> 5acb8: 2f02 movel %d2,%sp@- 5acba: 2f00 movel %d0,%sp@- 5acbc: 4eb9 0005 af68 jsr 5af68 <pthread_kill> 5acc2: 508f addql #8,%sp 5acc4: 6000 017c braw 5ae42 <killinfo+0x20a>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
5acc8: 7601 moveq #1,%d3
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
5acca: 7001 moveq #1,%d0 5accc: e3ab lsll %d1,%d3
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
5acce: 2d42 fff4 movel %d2,%fp@(-12)
siginfo->si_code = SI_USER;
5acd2: 2d40 fff8 movel %d0,%fp@(-8)
if ( !value ) {
5acd6: 4a8a tstl %a2
5acd8: 6606 bnes 5ace0 <killinfo+0xa8>
siginfo->si_value.sival_int = 0;
5acda: 42ae fffc clrl %fp@(-4) 5acde: 6004 bras 5ace4 <killinfo+0xac>
} else {
siginfo->si_value = *value;
5ace0: 2d52 fffc movel %a2@,%fp@(-4) 5ace4: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0 5acea: 5280 addql #1,%d0 5acec: 23c0 0005 e9c8 movel %d0,5e9c8 <_Thread_Dispatch_disable_level>
/*
* 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;
5acf2: 2079 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a0
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
5acf8: 2268 0102 moveal %a0@(258),%a1 5acfc: 2029 00d0 movel %a1@(208),%d0 5ad00: 4680 notl %d0 5ad02: c083 andl %d3,%d0 5ad04: 6600 00ae bnew 5adb4 <killinfo+0x17c>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
5ad08: 2279 0005 eff0 moveal 5eff0 <_POSIX_signals_Wait_queue>,%a1
/* 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 );
5ad0e: 601e bras 5ad2e <killinfo+0xf6>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
5ad10: 2003 movel %d3,%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;
5ad12: 2049 moveal %a1,%a0
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
5ad14: c0a9 0030 andl %a1@(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 ];
5ad18: 2469 0102 moveal %a1@(258),%a2
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
5ad1c: 6600 0096 bnew 5adb4 <killinfo+0x17c>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
5ad20: 202a 00d0 movel %a2@(208),%d0 5ad24: 4680 notl %d0 5ad26: c083 andl %d3,%d0 5ad28: 6600 008a bnew 5adb4 <killinfo+0x17c>
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 ) {
5ad2c: 2251 moveal %a1@,%a1
/* 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 );
5ad2e: b3fc 0005 eff4 cmpal #389108,%a1
5ad34: 66da bnes 5ad10 <killinfo+0xd8> * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
5ad36: 4280 clrl %d0 5ad38: 1039 0005 d0d2 moveb 5d0d2 <rtems_maximum_priority>,%d0 5ad3e: 45f9 0005 e98c lea 5e98c <_Objects_Information_table+0x8>,%a2 5ad44: 5280 addql #1,%d0
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
5ad46: 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 ] )
5ad48: 225a moveal %a2@+,%a1 5ad4a: 4a89 tstl %a1
5ad4c: 675a beqs 5ada8 <killinfo+0x170> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
5ad4e: 2269 0004 moveal %a1@(4),%a1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
5ad52: 4287 clrl %d7
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5ad54: 7801 moveq #1,%d4
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
5ad56: 2669 0018 moveal %a1@(24),%a3 5ad5a: 588b addql #4,%a3
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
5ad5c: 3e29 000e movew %a1@(14),%d7
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5ad60: 6042 bras 5ada4 <killinfo+0x16c>
the_thread = (Thread_Control *) object_table[ index ];
5ad62: 225b moveal %a3@+,%a1
if ( !the_thread )
5ad64: 4a89 tstl %a1
5ad66: 673a beqs 5ada2 <killinfo+0x16a>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
5ad68: 2229 0014 movel %a1@(20),%d1 5ad6c: b081 cmpl %d1,%d0
5ad6e: 6532 bcss 5ada2 <killinfo+0x16a>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
5ad70: 2869 0102 moveal %a1@(258),%a4 5ad74: 2a2c 00d0 movel %a4@(208),%d5 5ad78: 4685 notl %d5 5ad7a: ca83 andl %d3,%d5
5ad7c: 6724 beqs 5ada2 <killinfo+0x16a>
*
* 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 ) {
5ad7e: b081 cmpl %d1,%d0
5ad80: 621c bhis 5ad9e <killinfo+0x166>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
5ad82: 4a88 tstl %a0
5ad84: 671c beqs 5ada2 <killinfo+0x16a> <== NEVER TAKEN
5ad86: 2c28 0010 movel %a0@(16),%d6
5ad8a: 6716 beqs 5ada2 <killinfo+0x16a> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
5ad8c: 2a29 0010 movel %a1@(16),%d5
5ad90: 670c beqs 5ad9e <killinfo+0x166>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
5ad92: 0806 001c btst #28,%d6
5ad96: 660a bnes 5ada2 <killinfo+0x16a>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
5ad98: 0805 001c btst #28,%d5
5ad9c: 6704 beqs 5ada2 <killinfo+0x16a>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
5ad9e: 2001 movel %d1,%d0 5ada0: 2049 moveal %a1,%a0
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5ada2: 5284 addql #1,%d4 5ada4: be84 cmpl %d4,%d7
5ada6: 64ba bccs 5ad62 <killinfo+0x12a>
* + 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++) {
5ada8: b5fc 0005 e994 cmpal #387476,%a2
5adae: 6698 bnes 5ad48 <killinfo+0x110>
}
}
}
}
if ( interested ) {
5adb0: 4a88 tstl %a0
5adb2: 6716 beqs 5adca <killinfo+0x192>
/*
* 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 ) ) {
5adb4: 486e fff4 pea %fp@(-12) 5adb8: 2f02 movel %d2,%sp@- 5adba: 2f08 movel %a0,%sp@- 5adbc: 4eb9 0005 ae6c jsr 5ae6c <_POSIX_signals_Unblock_thread> 5adc2: 4fef 000c lea %sp@(12),%sp 5adc6: 4a00 tstb %d0
5adc8: 6670 bnes 5ae3a <killinfo+0x202>
/*
* 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 );
5adca: 2f03 movel %d3,%sp@-
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
5adcc: 7602 moveq #2,%d3
/*
* 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 );
5adce: 4eb9 0005 ae4c jsr 5ae4c <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
5add4: 588f addql #4,%sp 5add6: 2002 movel %d2,%d0 5add8: 41f9 0005 ee64 lea 5ee64 <_POSIX_signals_Vectors>,%a0 5adde: e588 lsll #2,%d0 5ade0: e98a lsll #4,%d2 5ade2: 9480 subl %d0,%d2 5ade4: b6b0 2800 cmpl %a0@(00000000,%d2:l),%d3
5ade8: 6650 bnes 5ae3a <killinfo+0x202>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
5adea: 4879 0005 efe4 pea 5efe4 <_POSIX_signals_Inactive_siginfo> 5adf0: 4eb9 0004 6268 jsr 46268 <_Chain_Get>
if ( !psiginfo ) {
5adf6: 588f addql #4,%sp
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
5adf8: 2440 moveal %d0,%a2
if ( !psiginfo ) {
5adfa: 4a80 tstl %d0
5adfc: 6616 bnes 5ae14 <killinfo+0x1dc>
_Thread_Enable_dispatch();
5adfe: 4eb9 0004 7ac2 jsr 47ac2 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
5ae04: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5ae0a: 2040 moveal %d0,%a0 5ae0c: 700b moveq #11,%d0 5ae0e: 2080 movel %d0,%a0@ 5ae10: 70ff moveq #-1,%d0 5ae12: 602e bras 5ae42 <killinfo+0x20a>
}
psiginfo->Info = *siginfo;
5ae14: 4878 000c pea c <OPER1>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
5ae18: 0682 0005 f05c addil #389212,%d2
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
5ae1e: 486e fff4 pea %fp@(-12) 5ae22: 486a 0008 pea %a2@(8) 5ae26: 4eb9 0004 d37c jsr 4d37c <memcpy>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
5ae2c: 2f0a movel %a2,%sp@- 5ae2e: 2f02 movel %d2,%sp@- 5ae30: 4eb9 0004 6208 jsr 46208 <_Chain_Append> 5ae36: 4fef 0014 lea %sp@(20),%sp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
5ae3a: 4eb9 0004 7ac2 jsr 47ac2 <_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;
5ae40: 4280 clrl %d0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
5ae42: 4cee 1cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a4
5ae48: 4e5e unlk %fp <== NOT EXECUTED
00043154 <libc_wrapup>:
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
43154: 7003 moveq #3,%d0
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
43156: 4e56 0000 linkw %fp,#0 4315a: 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()))
4315c: b0b9 0005 eb14 cmpl 5eb14 <_System_state_Current>,%d0
43162: 664c bnes 431b0 <libc_wrapup+0x5c> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
43164: 2479 0005 c82c moveal 5c82c <_global_impure_ptr>,%a2 4316a: b5f9 0005 d30c cmpal 5d30c <_impure_ptr>,%a2
43170: 6710 beqs 43182 <libc_wrapup+0x2e>
_wrapup_reent(_global_impure_ptr);
43172: 2f0a movel %a2,%sp@- 43174: 4eb9 0004 d67a jsr 4d67a <_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;
4317a: 588f addql #4,%sp 4317c: 23ca 0005 d30c movel %a2,5d30c <_impure_ptr>
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
43182: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0 43188: 45f9 0004 cc1e lea 4cc1e <fclose>,%a2 4318e: 2f28 0004 movel %a0@(4),%sp@- 43192: 4e92 jsr %a2@
fclose (stdout);
43194: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0 4319a: 2f28 0008 movel %a0@(8),%sp@- 4319e: 4e92 jsr %a2@
fclose (stderr);
431a0: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0 431a6: 2f28 000c movel %a0@(12),%sp@- 431aa: 4e92 jsr %a2@ 431ac: 4fef 000c lea %sp@(12),%sp
}
431b0: 246e fffc moveal %fp@(-4),%a2
431b4: 4e5e unlk %fp <== NOT EXECUTED
00042cd4 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
42cd4: 4e56 0000 linkw %fp,#0
void *return_this;
MSBUMP(malloc_calls, 1);
42cd8: 52b9 0005 e890 addql #1,5e890 <rtems_malloc_statistics+0x4>
#include "malloc_p.h"
void *malloc(
size_t size
)
{
42cde: 2f03 movel %d3,%sp@- 42ce0: 2f02 movel %d2,%sp@- 42ce2: 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();
42ce6: 4eb9 0004 2bce jsr 42bce <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
42cec: 4a82 tstl %d2
42cee: 677e beqs 42d6e <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()) &&
42cf0: 7003 moveq #3,%d0 42cf2: b0b9 0005 eb14 cmpl 5eb14 <_System_state_Current>,%d0
42cf8: 660a bnes 42d04 <malloc+0x30>
!malloc_is_system_state_OK() )
42cfa: 4eb9 0004 2b90 jsr 42b90 <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()) &&
42d00: 4a00 tstb %d0
42d02: 676a beqs 42d6e <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 );
42d04: 42a7 clrl %sp@- 42d06: 42a7 clrl %sp@- 42d08: 2f02 movel %d2,%sp@- 42d0a: 2f39 0005 d030 movel 5d030 <RTEMS_Malloc_Heap>,%sp@- 42d10: 4eb9 0004 71bc jsr 471bc <_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 ) {
42d16: 4fef 0010 lea %sp@(16),%sp 42d1a: 4a80 tstl %d0
42d1c: 6626 bnes 42d44 <malloc+0x70>
if (rtems_malloc_sbrk_helpers)
42d1e: 2079 0005 d80a moveal 5d80a <rtems_malloc_sbrk_helpers>,%a0 42d24: 4a88 tstl %a0
42d26: 670e beqs 42d36 <malloc+0x62>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
42d28: 2f02 movel %d2,%sp@- 42d2a: 2068 0004 moveal %a0@(4),%a0 42d2e: 4e90 jsr %a0@
if ( !return_this ) {
42d30: 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 );
42d32: 2600 movel %d0,%d3
if ( !return_this ) {
42d34: 6610 bnes 42d46 <malloc+0x72>
errno = ENOMEM;
42d36: 4eb9 0004 cad0 jsr 4cad0 <__errno> 42d3c: 2040 moveal %d0,%a0 42d3e: 700c moveq #12,%d0 42d40: 2080 movel %d0,%a0@ 42d42: 602a bras 42d6e <malloc+0x9a>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
42d44: 2600 movel %d0,%d3
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
42d46: 2079 0005 d80e moveal 5d80e <rtems_malloc_dirty_helper>,%a0 42d4c: 4a88 tstl %a0
42d4e: 6708 beqs 42d58 <malloc+0x84>
(*rtems_malloc_dirty_helper)( return_this, size );
42d50: 2f02 movel %d2,%sp@- 42d52: 2f03 movel %d3,%sp@- 42d54: 4e90 jsr %a0@ 42d56: 508f addql #8,%sp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
42d58: 2079 0005 d806 moveal 5d806 <rtems_malloc_statistics_helpers>,%a0 42d5e: 4a88 tstl %a0
42d60: 670e beqs 42d70 <malloc+0x9c>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
42d62: 2f03 movel %d3,%sp@- 42d64: 2068 0004 moveal %a0@(4),%a0 42d68: 4e90 jsr %a0@ 42d6a: 588f addql #4,%sp 42d6c: 6002 bras 42d70 <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;
42d6e: 4283 clrl %d3
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
return return_this;
}
42d70: 2003 movel %d3,%d0 42d72: 242e fff8 movel %fp@(-8),%d2 42d76: 262e fffc movel %fp@(-4),%d3 42d7a: 4e5e unlk %fp
...
00043000 <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
43000: 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;
43004: 2039 0005 eef0 movel 5eef0 <RTEMS_Malloc_Sbrk_amount>,%d0
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
4300a: 48d7 040c moveml %d2-%d3/%a2,%sp@ 4300e: 262e 0008 movel %fp@(8),%d3
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
43012: 4a80 tstl %d0
43014: 676a beqs 43080 <malloc_sbrk_extend_and_allocate+0x80><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
43016: 2403 movel %d3,%d2 43018: d480 addl %d0,%d2
starting_address = (void *) sbrk(the_size);
4301a: 45f9 0004 0810 lea 40810 <sbrk>,%a2
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
43020: 4c40 2002 remul %d0,%d2,%d2 43024: 4c00 2800 mulsl %d0,%d2
starting_address = (void *) sbrk(the_size);
43028: 2f02 movel %d2,%sp@- 4302a: 4e92 jsr %a2@
if ( starting_address == (void*) -1 )
4302c: 588f addql #4,%sp 4302e: 72ff moveq #-1,%d1 43030: b280 cmpl %d0,%d1
43032: 674c beqs 43080 <malloc_sbrk_extend_and_allocate+0x80>
return (void *) 0;
if ( !_Protected_heap_Extend(
43034: 2f02 movel %d2,%sp@- 43036: 2f00 movel %d0,%sp@- 43038: 2f39 0005 d530 movel 5d530 <RTEMS_Malloc_Heap>,%sp@- 4303e: 4eb9 0004 749c jsr 4749c <_Protected_heap_Extend> 43044: 4fef 000c lea %sp@(12),%sp 43048: 4a00 tstb %d0
4304a: 6616 bnes 43062 <malloc_sbrk_extend_and_allocate+0x62>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
4304c: 4482 negl %d2 4304e: 2f02 movel %d2,%sp@- 43050: 4e92 jsr %a2@
errno = ENOMEM;
43052: 4eb9 0004 cfc0 jsr 4cfc0 <__errno>
return (void *) 0;
43058: 588f addql #4,%sp
return (void *) 0;
if ( !_Protected_heap_Extend(
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
errno = ENOMEM;
4305a: 2040 moveal %d0,%a0 4305c: 700c moveq #12,%d0 4305e: 2080 movel %d0,%a0@ 43060: 601e bras 43080 <malloc_sbrk_extend_and_allocate+0x80> 43062: 42a7 clrl %sp@-
return (void *) 0;
}
MSBUMP(space_available, the_size);
43064: d5b9 0005 eec4 addl %d2,5eec4 <rtems_malloc_statistics> 4306a: 42a7 clrl %sp@- 4306c: 2f03 movel %d3,%sp@- 4306e: 2f39 0005 d530 movel 5d530 <RTEMS_Malloc_Heap>,%sp@- 43074: 4eb9 0004 745c jsr 4745c <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
4307a: 4fef 0010 lea %sp@(16),%sp 4307e: 6002 bras 43082 <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;
43080: 4280 clrl %d0
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
43082: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
43088: 4e5e unlk %fp <== NOT EXECUTED
0004bcc4 <memfile_lseek>:
{
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
4bcc4: 7006 moveq #6,%d0
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
4bcc6: 4e56 fff0 linkw %fp,#-16 4bcca: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 4bcce: 246e 0008 moveal %fp@(8),%a2
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4bcd2: 266a 0018 moveal %a2@(24),%a3
if (the_jnode->type == IMFS_LINEAR_FILE) {
4bcd6: b0ab 0048 cmpl %a3@(72),%d0
4bcda: 6620 bnes 4bcfc <memfile_lseek+0x38>
if (iop->offset > the_jnode->info.linearfile.size)
4bcdc: 202b 004c movel %a3@(76),%d0 4bce0: 222b 0050 movel %a3@(80),%d1 4bce4: 242a 000c movel %a2@(12),%d2 4bce8: 262a 0010 movel %a2@(16),%d3 4bcec: 9681 subl %d1,%d3 4bcee: 9580 subxl %d0,%d2
4bcf0: 6f44 bles 4bd36 <memfile_lseek+0x72> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
4bcf2: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED 4bcf6: 2541 0010 movel %d1,%a2@(16) <== NOT EXECUTED 4bcfa: 603a bras 4bd36 <memfile_lseek+0x72> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
4bcfc: 2f2a 0010 movel %a2@(16),%sp@- 4bd00: 2f2a 000c movel %a2@(12),%sp@- 4bd04: 2f0b movel %a3,%sp@- 4bd06: 4eb9 0004 b92c jsr 4b92c <IMFS_memfile_extend> 4bd0c: 4fef 000c lea %sp@(12),%sp 4bd10: 4a80 tstl %d0
4bd12: 6712 beqs 4bd26 <memfile_lseek+0x62>
rtems_set_errno_and_return_minus_one( ENOSPC );
4bd14: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4bd1a: 761c moveq #28,%d3 4bd1c: 2040 moveal %d0,%a0 4bd1e: 2083 movel %d3,%a0@ 4bd20: 72ff moveq #-1,%d1 4bd22: 74ff moveq #-1,%d2 4bd24: 6018 bras 4bd3e <memfile_lseek+0x7a>
iop->size = the_jnode->info.file.size;
4bd26: 202b 004c movel %a3@(76),%d0 4bd2a: 222b 0050 movel %a3@(80),%d1 4bd2e: 2540 0004 movel %d0,%a2@(4) 4bd32: 2541 0008 movel %d1,%a2@(8)
} return iop->offset;
4bd36: 222a 000c movel %a2@(12),%d1 4bd3a: 242a 0010 movel %a2@(16),%d2
}
4bd3e: 2001 movel %d1,%d0 4bd40: 2202 movel %d2,%d1 4bd42: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4bd48: 4e5e unlk %fp <== NOT EXECUTED
0004bbb8 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
4bbb8: 4e56 fff0 linkw %fp,#-16 4bbbc: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 4bbc0: 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))
4bbc4: 202b 0014 movel %a3@(20),%d0 4bbc8: 0280 0000 0204 andil #516,%d0
uint32_t mode
)
{
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4bbce: 246b 0018 moveal %a3@(24),%a2
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
4bbd2: 674c beqs 4bc20 <memfile_open+0x68>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
4bbd4: 7006 moveq #6,%d0 4bbd6: b0aa 0048 cmpl %a2@(72),%d0
4bbda: 6644 bnes 4bc20 <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;
4bbdc: 7405 moveq #5,%d2 <== NOT EXECUTED 4bbde: 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;
4bbe2: 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;
4bbe6: 4282 clrl %d2 <== NOT EXECUTED 4bbe8: 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;
4bbea: 222a 0054 movel %a2@(84),%d1 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
4bbee: 2542 004c movel %d2,%a2@(76) <== NOT EXECUTED 4bbf2: 2543 0050 movel %d3,%a2@(80) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
4bbf6: 42aa 0054 clrl %a2@(84) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
4bbfa: 42aa 0058 clrl %a2@(88) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
4bbfe: 42aa 005c clrl %a2@(92) <== NOT EXECUTED
if ((count != 0)
4bc02: 4a80 tstl %d0 <== NOT EXECUTED 4bc04: 671a beqs 4bc20 <memfile_open+0x68> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
4bc06: 2f00 movel %d0,%sp@- <== NOT EXECUTED 4bc08: 76ff moveq #-1,%d3 <== NOT EXECUTED 4bc0a: 2f01 movel %d1,%sp@- <== NOT EXECUTED 4bc0c: 42a7 clrl %sp@- <== NOT EXECUTED 4bc0e: 42a7 clrl %sp@- <== NOT EXECUTED 4bc10: 2f0a movel %a2,%sp@- <== NOT EXECUTED 4bc12: 4eb9 0004 ba10 jsr 4ba10 <IMFS_memfile_write> <== NOT EXECUTED 4bc18: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED 4bc1c: b680 cmpl %d0,%d3 <== NOT EXECUTED 4bc1e: 6730 beqs 4bc50 <memfile_open+0x98> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
4bc20: 202b 0014 movel %a3@(20),%d0 4bc24: 0280 0000 0200 andil #512,%d0
4bc2a: 6710 beqs 4bc3c <memfile_open+0x84>
iop->offset = the_jnode->info.file.size;
4bc2c: 202a 004c movel %a2@(76),%d0 4bc30: 222a 0050 movel %a2@(80),%d1 4bc34: 2740 000c movel %d0,%a3@(12) 4bc38: 2741 0010 movel %d1,%a3@(16)
iop->size = the_jnode->info.file.size;
return 0;
4bc3c: 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;
4bc3e: 222a 004c movel %a2@(76),%d1 4bc42: 242a 0050 movel %a2@(80),%d2 4bc46: 2741 0004 movel %d1,%a3@(4) 4bc4a: 2742 0008 movel %d2,%a3@(8)
return 0;
4bc4e: 6002 bras 4bc52 <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;
4bc50: 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;
}
4bc52: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4bc58: 4e5e unlk %fp <== NOT EXECUTED
00042da0 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
42da0: 4e56 ffd4 linkw %fp,#-44 42da4: 48d7 001c moveml %d2-%d4,%sp@ 42da8: 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)
42dac: 2003 movel %d3,%d0 42dae: 0280 0000 f000 andil #61440,%d0
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
42db4: 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)
42db8: 0c80 0000 4000 cmpil #16384,%d0
42dbe: 6732 beqs 42df2 <mknod+0x52> 42dc0: 6212 bhis 42dd4 <mknod+0x34>
42dc2: 0c80 0000 1000 cmpil #4096,%d0
42dc8: 6728 beqs 42df2 <mknod+0x52>
42dca: 0c80 0000 2000 cmpil #8192,%d0
42dd0: 6612 bnes 42de4 <mknod+0x44>
42dd2: 601e bras 42df2 <mknod+0x52> 42dd4: 0c80 0000 6000 cmpil #24576,%d0
42dda: 6716 beqs 42df2 <mknod+0x52>
42ddc: 0c80 0000 8000 cmpil #32768,%d0
42de2: 670e beqs 42df2 <mknod+0x52> <== ALWAYS TAKEN
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
42de4: 4eb9 0004 cad0 jsr 4cad0 <__errno> 42dea: 2040 moveal %d0,%a0 42dec: 7016 moveq #22,%d0 42dee: 2080 movel %d0,%a0@ 42df0: 6064 bras 42e56 <mknod+0xb6>
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
42df2: 240e movel %fp,%d2 42df4: 0682 ffff ffe4 addil #-28,%d2 42dfa: 2f02 movel %d2,%sp@- 42dfc: 486e fffc pea %fp@(-4) 42e00: 2f04 movel %d4,%sp@- 42e02: 4eb9 0004 36c4 jsr 436c4 <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
42e08: 486e fff8 pea %fp@(-8) 42e0c: d8ae fffc addl %fp@(-4),%d4 42e10: 2f02 movel %d2,%sp@- 42e12: 206e fff0 moveal %fp@(-16),%a0 42e16: 2f04 movel %d4,%sp@- 42e18: 2068 0004 moveal %a0@(4),%a0 42e1c: 4e90 jsr %a0@
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
42e1e: 4fef 0018 lea %sp@(24),%sp 42e22: 4a80 tstl %d0
42e24: 6630 bnes 42e56 <mknod+0xb6>
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
42e26: 2f02 movel %d2,%sp@- 42e28: 2f2e 0014 movel %fp@(20),%sp@- 42e2c: 2f2e 0010 movel %fp@(16),%sp@- 42e30: 206e fff0 moveal %fp@(-16),%a0 42e34: 2f03 movel %d3,%sp@- 42e36: 2f2e fff8 movel %fp@(-8),%sp@- 42e3a: 2068 0014 moveal %a0@(20),%a0 42e3e: 4e90 jsr %a0@
rtems_filesystem_freenode( &temp_loc );
42e40: 2f02 movel %d2,%sp@- 42e42: 2d40 ffe0 movel %d0,%fp@(-32) 42e46: 4eb9 0004 29d8 jsr 429d8 <rtems_filesystem_freenode>
return result;
42e4c: 202e ffe0 movel %fp@(-32),%d0 42e50: 4fef 0018 lea %sp@(24),%sp 42e54: 6002 bras 42e58 <mknod+0xb8>
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
return -1;
42e56: 70ff moveq #-1,%d0
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
42e58: 4cee 001c ffd4 moveml %fp@(-44),%d2-%d4 42e5e: 4e5e unlk %fp
...
00042ef8 <mount>:
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
42ef8: 7001 moveq #1,%d0
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
42efa: 4e56 ffbc linkw %fp,#-68 42efe: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 42f02: 2a2e 0008 movel %fp@(8),%d5 42f06: 262e 000c movel %fp@(12),%d3 42f0a: 266e 0010 moveal %fp@(16),%a3
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
42f0e: b0ae 0014 cmpl %fp@(20),%d0
42f12: 650e bcss 42f22 <mount+0x2a>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
42f14: 2f0b movel %a3,%sp@- 42f16: 4eb9 0004 9dc6 jsr 49dc6 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
42f1c: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
42f1e: 2e00 movel %d0,%d7
if ( !mount_h )
42f20: 6610 bnes 42f32 <mount+0x3a>
rtems_set_errno_and_return_minus_one( EINVAL );
42f22: 4eb9 0004 cad0 jsr 4cad0 <__errno> 42f28: 7816 moveq #22,%d4 42f2a: 2040 moveal %d0,%a0 42f2c: 2084 movel %d4,%a0@ 42f2e: 6000 0218 braw 43148 <mount+0x250>
{
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;
42f32: 4a83 tstl %d3 42f34: 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 : "/";
42f36: 283c 0005 bbfe movel #375806,%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;
42f3c: 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 : "/";
42f3e: 4a02 tstb %d2
42f40: 6702 beqs 42f44 <mount+0x4c>
42f42: 2803 movel %d3,%d4
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
42f44: 2f0b movel %a3,%sp@- 42f46: 45f9 0004 df28 lea 4df28 <strlen>,%a2 42f4c: 4e92 jsr %a2@ 42f4e: 588f addql #4,%sp 42f50: 2a40 moveal %d0,%a5 42f52: 528d addql #1,%a5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
42f54: 4a85 tstl %d5
42f56: 670c beqs 42f64 <mount+0x6c>
42f58: 2f05 movel %d5,%sp@- 42f5a: 4e92 jsr %a2@ 42f5c: 588f addql #4,%sp 42f5e: 2840 moveal %d0,%a4 42f60: 528c addql #1,%a4 42f62: 6002 bras 42f66 <mount+0x6e> 42f64: 99cc subal %a4,%a4
size_t target_size = strlen( target ) + 1;
42f66: 2f04 movel %d4,%sp@- 42f68: 4eb9 0004 df28 jsr 4df28 <strlen> 42f6e: 588f addql #4,%sp
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
42f70: 41f5 c874 lea %a5@(00000074,%a4: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;
42f74: 2d40 ffe4 movel %d0,%fp@(-28) 42f78: 5280 addql #1,%d0
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 );
42f7a: 4870 0800 pea %a0@(00000000,%d0:l) 42f7e: 4878 0001 pea 1 <ADD>
{
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;
42f82: 2d40 ffe8 movel %d0,%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 );
42f86: 4eb9 0004 2654 jsr 42654 <calloc>
if ( mt_entry != NULL ) {
42f8c: 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 );
42f8e: 2440 moveal %d0,%a2
if ( mt_entry != NULL ) {
42f90: 4a80 tstl %d0
42f92: 6766 beqs 42ffa <mount+0x102> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
42f94: 2f0d movel %a5,%sp@-
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 );
42f96: 2c00 movel %d0,%d6 42f98: 0686 0000 0074 addil #116,%d6
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
42f9e: 4bf5 6800 lea %a5@(00000000,%d6:l),%a5
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
42fa2: 2f0b movel %a3,%sp@- 42fa4: 47f9 0004 d37c lea 4d37c <memcpy>,%a3 42faa: 2f06 movel %d6,%sp@- 42fac: 4e93 jsr %a3@
mt_entry->type = str;
42fae: 2546 006c movel %d6,%a2@(108)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
42fb2: 2f0c movel %a4,%sp@- 42fb4: 2f05 movel %d5,%sp@- 42fb6: 2f0d movel %a5,%sp@- 42fb8: 4e93 jsr %a3@
mt_entry->dev = str;
42fba: 254d 0070 movel %a5,%a2@(112)
str += source_size;
memcpy( str, target, target_size );
42fbe: 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;
42fc2: dbcc addal %a4,%a5
memcpy( str, target, target_size );
42fc4: 2f04 movel %d4,%sp@- 42fc6: 2f0d movel %a5,%sp@- 42fc8: 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;
42fca: 202e 0014 movel %fp@(20),%d0
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
42fce: 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;
42fd2: 254d 0068 movel %a5,%a2@(104)
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
42fd6: 254a 002c movel %a2,%a2@(44)
mt_entry->options = options;
42fda: 2540 0030 movel %d0,%a2@(48)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
42fde: 4878 0030 pea 30 <OPER2+0x1c> 42fe2: 4879 0005 c0b2 pea 5c0b2 <rtems_filesystem_default_pathconf> 42fe8: 486a 0038 pea %a2@(56) 42fec: 4e93 jsr %a3@
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
42fee: 4fef 000c lea %sp@(12),%sp 42ff2: 4a02 tstb %d2 42ff4: 6700 00b4 beqw 430aa <mount+0x1b2> 42ff8: 6010 bras 4300a <mount+0x112>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
42ffa: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 43000: 760c moveq #12,%d3 <== NOT EXECUTED 43002: 2040 moveal %d0,%a0 <== NOT EXECUTED 43004: 2083 movel %d3,%a0@ <== NOT EXECUTED 43006: 6000 0140 braw 43148 <mount+0x250> <== 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(
4300a: 4878 0001 pea 1 <ADD> 4300e: 280e movel %fp,%d4 43010: 0684 ffff ffec addil #-20,%d4 43016: 2f04 movel %d4,%sp@- 43018: 4878 0007 pea 7 <TRUNCDFSF> 4301c: 2f2e ffe4 movel %fp@(-28),%sp@- 43020: 2f03 movel %d3,%sp@- 43022: 4eb9 0004 290c jsr 4290c <rtems_filesystem_evaluate_path> 43028: 4fef 0014 lea %sp@(20),%sp 4302c: 72ff moveq #-1,%d1 4302e: b280 cmpl %d0,%d1 43030: 6700 00f2 beqw 43124 <mount+0x22c>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
43034: 206e fff8 moveal %fp@(-8),%a0 43038: 2f04 movel %d4,%sp@- 4303a: 2068 0010 moveal %a0@(16),%a0 4303e: 4e90 jsr %a0@ 43040: 588f addql #4,%sp 43042: 7201 moveq #1,%d1 43044: b280 cmpl %d0,%d1
43046: 6710 beqs 43058 <mount+0x160>
errno = ENOTDIR;
43048: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4304e: 7414 moveq #20,%d2 43050: 2040 moveal %d0,%a0 43052: 2082 movel %d2,%a0@ 43054: 6000 00d2 braw 43128 <mount+0x230>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
43058: 2f2e ffec movel %fp@(-20),%sp@- 4305c: 487a fe06 pea %pc@(42e64 <is_node_fs_root>) 43060: 4eb9 0004 2eae jsr 42eae <rtems_filesystem_mount_iterate> 43066: 508f addql #8,%sp 43068: 4a00 tstb %d0
4306a: 6710 beqs 4307c <mount+0x184>
errno = EBUSY;
4306c: 4eb9 0004 cad0 jsr 4cad0 <__errno> 43072: 7210 moveq #16,%d1 43074: 2040 moveal %d0,%a0 43076: 2081 movel %d1,%a0@ 43078: 6000 00ae braw 43128 <mount+0x230>
* 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;
4307c: 206e fff8 moveal %fp@(-8),%a0
* 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;
43080: 256e ffec 0008 movel %fp@(-20),%a2@(8)
mt_entry->mt_point_node.handlers = loc.handlers;
43086: 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;
4308c: 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;
43092: 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 ) ) {
43096: 2f0a movel %a2,%sp@- 43098: 2068 0020 moveal %a0@(32),%a0 4309c: 4e90 jsr %a0@ 4309e: 588f addql #4,%sp 430a0: 4a80 tstl %d0 430a2: 6600 0084 bnew 43128 <mount+0x230>
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;
430a6: 2604 movel %d4,%d3 430a8: 601e bras 430c8 <mount+0x1d0>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
430aa: 203c 0005 d12c movel #381228,%d0 430b0: b0b9 0005 d128 cmpl 5d128 <mount_chain>,%d0
430b6: 670e beqs 430c6 <mount+0x1ce> <== ALWAYS TAKEN
errno = EINVAL;
430b8: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 430be: 2040 moveal %d0,%a0 <== NOT EXECUTED 430c0: 7016 moveq #22,%d0 <== NOT EXECUTED 430c2: 2080 movel %d0,%a0@ <== NOT EXECUTED 430c4: 605e bras 43124 <mount+0x22c> <== 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;
430c6: 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 ) ) {
430c8: 2f2e 0018 movel %fp@(24),%sp@- 430cc: 2047 moveal %d7,%a0 430ce: 2f0a movel %a2,%sp@- 430d0: 4e90 jsr %a0@ 430d2: 508f addql #8,%sp 430d4: 4a80 tstl %d0
430d6: 6710 beqs 430e8 <mount+0x1f0>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
430d8: 206e fff8 moveal %fp@(-8),%a0 430dc: 2f0a movel %a2,%sp@- 430de: 2068 0028 moveal %a0@(40),%a0 430e2: 4e90 jsr %a0@
goto cleanup_and_bail;
430e4: 588f addql #4,%sp 430e6: 6042 bras 4312a <mount+0x232>
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
430e8: 4eba fd92 jsr %pc@(42e7c <rtems_libio_lock>) 430ec: 2f0a movel %a2,%sp@- 430ee: 4879 0005 d128 pea 5d128 <mount_chain> 430f4: 4eb9 0004 6208 jsr 46208 <_Chain_Append>
rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock();
430fa: 4eba fd9c jsr %pc@(42e98 <rtems_libio_unlock>)
if ( !has_target )
430fe: 508f addql #8,%sp 43100: 4a02 tstb %d2
43102: 6640 bnes 43144 <mount+0x24c>
rtems_filesystem_root = mt_entry->mt_fs_root;
43104: 4878 0014 pea 14 <OPER2> 43108: 486a 001c pea %a2@(28) 4310c: 2079 0005 d244 moveal 5d244 <rtems_current_user_env>,%a0 43112: 41e8 0018 lea %a0@(24),%a0 43116: 2f08 movel %a0,%sp@- 43118: 4eb9 0004 d37c jsr 4d37c <memcpy> 4311e: 4fef 000c lea %sp@(12),%sp 43122: 6020 bras 43144 <mount+0x24c>
)
{
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;
43124: 4283 clrl %d3 <== NOT EXECUTED 43126: 6002 bras 4312a <mount+0x232> <== NOT EXECUTED
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;
43128: 2604 movel %d4,%d3
return 0;
cleanup_and_bail:
free( mt_entry );
4312a: 2f0a movel %a2,%sp@- 4312c: 4eb9 0004 29ec jsr 429ec <free>
if ( loc_to_free )
43132: 588f addql #4,%sp 43134: 4a83 tstl %d3
43136: 6710 beqs 43148 <mount+0x250> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
43138: 2f03 movel %d3,%sp@- 4313a: 4eb9 0004 29d8 jsr 429d8 <rtems_filesystem_freenode> 43140: 588f addql #4,%sp 43142: 6004 bras 43148 <mount+0x250>
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
43144: 4280 clrl %d0 43146: 6002 bras 4314a <mount+0x252>
free( mt_entry );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
43148: 70ff moveq #-1,%d0
}
4314a: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
43150: 4e5e unlk %fp <== NOT EXECUTED
000434c4 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
434c4: 4e56 ffec linkw %fp,#-20 434c8: 48d7 007c moveml %d2-%d6,%sp@ 434cc: 262e 0008 movel %fp@(8),%d3 434d0: 242e 000c movel %fp@(12),%d2 434d4: 282e 0010 movel %fp@(16),%d4 434d8: 2a2e 0014 movel %fp@(20),%d5 434dc: 2c2e 0018 movel %fp@(24),%d6
int rv = -1;
if (target != NULL) {
434e0: 4a82 tstl %d2
434e2: 6734 beqs 43518 <mount_and_make_target_path+0x54>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
434e4: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca> 434e8: 2f02 movel %d2,%sp@- 434ea: 4eb9 0004 3d90 jsr 43d90 <rtems_mkdir>
if (rv == 0) {
434f0: 508f addql #8,%sp 434f2: 4a80 tstl %d0
434f4: 6630 bnes 43526 <mount_and_make_target_path+0x62><== NEVER TAKEN
rv = mount(
434f6: 2d46 0018 movel %d6,%fp@(24) 434fa: 2d45 0014 movel %d5,%fp@(20) 434fe: 2d44 0010 movel %d4,%fp@(16) 43502: 2d42 000c movel %d2,%fp@(12) 43506: 2d43 0008 movel %d3,%fp@(8)
} else {
errno = EINVAL;
}
return rv;
}
4350a: 4cee 007c ffec moveml %fp@(-20),%d2-%d6 43510: 4e5e unlk %fp
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
43512: 4ef9 0004 35c4 jmp 435c4 <mount>
options,
data
);
}
} else {
errno = EINVAL;
43518: 4eb9 0004 d144 jsr 4d144 <__errno> 4351e: 2040 moveal %d0,%a0 43520: 7016 moveq #22,%d0 43522: 2080 movel %d0,%a0@
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
43524: 70ff moveq #-1,%d0
} else {
errno = EINVAL;
}
return rv;
}
43526: 4cee 007c ffec moveml %fp@(-20),%d2-%d6
4352c: 4e5e unlk %fp <== NOT EXECUTED
000433ca <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
433ca: 4e56 fff4 linkw %fp,#-12 433ce: 48d7 040c moveml %d2-%d3/%a2,%sp@ 433d2: 262e 0008 movel %fp@(8),%d3 433d6: 246e 000c moveal %fp@(12),%a2
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
433da: b5c3 cmpal %d3,%a2
433dc: 6608 bnes 433e6 <newlib_delete_hook+0x1c>
ptr = _REENT;
433de: 2439 0005 d30c movel 5d30c <_impure_ptr>,%d2 433e4: 6004 bras 433ea <newlib_delete_hook+0x20>
} else {
ptr = deleted_task->libc_reent;
433e6: 242a 00fa movel %a2@(250),%d2
}
if (ptr && ptr != _global_impure_ptr) {
433ea: 4a82 tstl %d2
433ec: 6722 beqs 43410 <newlib_delete_hook+0x46> <== NEVER TAKEN
433ee: b4b9 0005 c82c cmpl 5c82c <_global_impure_ptr>,%d2
433f4: 671a beqs 43410 <newlib_delete_hook+0x46>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
433f6: 4879 0004 31dc pea 431dc <newlib_free_buffers> 433fc: 2f02 movel %d2,%sp@- 433fe: 4eb9 0004 d284 jsr 4d284 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
43404: 2f02 movel %d2,%sp@- 43406: 4eb9 0004 89f4 jsr 489f4 <_Workspace_Free> 4340c: 4fef 000c lea %sp@(12),%sp
#endif
}
deleted_task->libc_reent = NULL;
43410: 42aa 00fa clrl %a2@(250)
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
43414: b5c3 cmpal %d3,%a2
43416: 6606 bnes 4341e <newlib_delete_hook+0x54>
_REENT = 0;
43418: 42b9 0005 d30c clrl 5d30c <_impure_ptr>
} }
4341e: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
43424: 4e5e unlk %fp <== NOT EXECUTED
000431dc <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
431dc: 4e56 0000 linkw %fp,#0 431e0: 2f0a movel %a2,%sp@- 431e2: 246e 0008 moveal %fp@(8),%a2
switch ( fileno(fp) ) {
431e6: 2f0a movel %a2,%sp@- 431e8: 4eb9 0004 ce70 jsr 4ce70 <fileno> 431ee: 588f addql #4,%sp 431f0: 7202 moveq #2,%d1 431f2: b280 cmpl %d0,%d1
431f4: 6528 bcss 4321e <newlib_free_buffers+0x42> <== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
431f6: 302a 000c movew %a2@(12),%d0 431fa: 48c0 extl %d0 431fc: 4a00 tstb %d0
431fe: 6c28 bges 43228 <newlib_free_buffers+0x4c> <== ALWAYS TAKEN
free( fp->_bf._base );
43200: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 43204: 4eb9 0004 29ec jsr 429ec <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
4320a: 302a 000c movew %a2@(12),%d0 <== NOT EXECUTED 4320e: 0880 0007 bclr #7,%d0 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
43212: 4292 clrl %a2@ <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
43214: 3540 000c movew %d0,%a2@(12) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
43218: 42aa 0010 clrl %a2@(16) <== NOT EXECUTED 4321c: 6008 bras 43226 <newlib_free_buffers+0x4a> <== NOT EXECUTED
}
break;
default:
fclose(fp);
4321e: 2f0a movel %a2,%sp@- <== NOT EXECUTED 43220: 4eb9 0004 cc1e jsr 4cc1e <fclose> <== NOT EXECUTED 43226: 588f addql #4,%sp <== NOT EXECUTED
} return 0; }
43228: 246e fffc moveal %fp@(-4),%a2 4322c: 4280 clrl %d0
4322e: 4e5e unlk %fp <== NOT EXECUTED
00043498 <open>:
int open(
const char *pathname,
int flags,
...
)
{
43498: 4e56 ffc8 linkw %fp,#-56 4349c: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@ 434a0: 242e 000c movel %fp@(12),%d2
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
434a4: 2002 movel %d2,%d0 434a6: 5280 addql #1,%d0
int open(
const char *pathname,
int flags,
...
)
{
434a8: 262e 0008 movel %fp@(8),%d3
/* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; if ( ( status & _FREAD ) == _FREAD )
434ac: 0800 0000 btst #0,%d0
434b0: 6704 beqs 434b6 <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_READ;
434b2: 7804 moveq #4,%d4 434b4: 6002 bras 434b8 <open+0x20>
int eval_flags;
/*
* Set the Evaluation flags
*/
eval_flags = 0;
434b6: 4284 clrl %d4
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
434b8: 0800 0001 btst #1,%d0
434bc: 6704 beqs 434c2 <open+0x2a>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
434be: 7002 moveq #2,%d0 434c0: 8880 orl %d0,%d4
va_start(ap, flags);
mode = va_arg( ap, int );
434c2: 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();
434c6: 4eb9 0004 9b74 jsr 49b74 <rtems_libio_allocate> 434cc: 2440 moveal %d0,%a2
if ( iop == 0 ) {
434ce: 4a80 tstl %d0 434d0: 6700 0158 beqw 4362a <open+0x192>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
434d4: 2f03 movel %d3,%sp@- 434d6: 4bf9 0004 df28 lea 4df28 <strlen>,%a5 434dc: 7a01 moveq #1,%d5 434de: 49f9 0004 290c lea 4290c <rtems_filesystem_evaluate_path>,%a4 434e4: 4e95 jsr %a5@ 434e6: 2e85 movel %d5,%sp@ 434e8: 2a0e movel %fp,%d5 434ea: 0685 ffff ffec addil #-20,%d5 434f0: 2f05 movel %d5,%sp@- 434f2: 2f04 movel %d4,%sp@- 434f4: 2f00 movel %d0,%sp@- 434f6: 2f03 movel %d3,%sp@- 434f8: 4e94 jsr %a4@
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
434fa: 4fef 0014 lea %sp@(20),%sp 434fe: 72ff moveq #-1,%d1 43500: b280 cmpl %d0,%d1
43502: 665e bnes 43562 <open+0xca>
if ( errno != ENOENT ) {
43504: 47f9 0004 cad0 lea 4cad0 <__errno>,%a3 4350a: 4e93 jsr %a3@ 4350c: 7202 moveq #2,%d1 4350e: 2040 moveal %d0,%a0 43510: b290 cmpl %a0@,%d1
43512: 6624 bnes 43538 <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) ) {
43514: 0802 0009 btst #9,%d2 43518: 6700 0114 beqw 4362e <open+0x196>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
4351c: 42a7 clrl %sp@- 4351e: 2006 movel %d6,%d0 43520: 42a7 clrl %sp@- 43522: 08c0 000f bset #15,%d0 43526: 2f00 movel %d0,%sp@- 43528: 2f03 movel %d3,%sp@- 4352a: 4eb9 0004 2da0 jsr 42da0 <mknod>
if ( rc ) {
43530: 4fef 0010 lea %sp@(16),%sp 43534: 4a80 tstl %d0
43536: 670c beqs 43544 <open+0xac> <== ALWAYS TAKEN
rc = errno;
43538: 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;
4353a: 4285 clrl %d5
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
4353c: 2040 moveal %d0,%a0 4353e: 2410 movel %a0@,%d2
goto done;
43540: 6000 00fc braw 4363e <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(
43544: 2f03 movel %d3,%sp@- 43546: 4e95 jsr %a5@ 43548: 7201 moveq #1,%d1 4354a: 2e81 movel %d1,%sp@ 4354c: 2f05 movel %d5,%sp@- 4354e: 42a7 clrl %sp@- 43550: 2f00 movel %d0,%sp@- 43552: 2f03 movel %d3,%sp@- 43554: 4e94 jsr %a4@
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
43556: 4fef 0014 lea %sp@(20),%sp 4355a: 4a80 tstl %d0 4355c: 6600 00d6 bnew 43634 <open+0x19c> 43560: 6012 bras 43574 <open+0xdc>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
43562: 2002 movel %d2,%d0 43564: 0280 0000 0a00 andil #2560,%d0 4356a: 0c80 0000 0a00 cmpil #2560,%d0 43570: 6700 00c8 beqw 4363a <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 );
43574: 282a 0014 movel %a2@(20),%d4
iop->pathinfo = loc;
43578: 2a0e movel %fp,%d5 4357a: 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 );
43580: 2f02 movel %d2,%sp@- 43582: 4eb9 0004 9ae6 jsr 49ae6 <rtems_libio_fcntl_flags> 43588: 8084 orl %d4,%d0 4358a: 2540 0014 movel %d0,%a2@(20)
iop->pathinfo = loc;
4358e: 4878 0014 pea 14 <OPER2> 43592: 2f05 movel %d5,%sp@- 43594: 486a 0018 pea %a2@(24) 43598: 4eb9 0004 d37c jsr 4d37c <memcpy>
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
4359e: 206a 0020 moveal %a2@(32),%a0 435a2: 2f06 movel %d6,%sp@- 435a4: 2f02 movel %d2,%sp@- 435a6: 2f03 movel %d3,%sp@- 435a8: 2f0a movel %a2,%sp@- 435aa: 2050 moveal %a0@,%a0 435ac: 4e90 jsr %a0@
if ( rc ) {
435ae: 4fef 0020 lea %sp@(32),%sp 435b2: 4a80 tstl %d0
435b4: 670c beqs 435c2 <open+0x12a>
rc = errno;
435b6: 4eb9 0004 cad0 jsr 4cad0 <__errno> 435bc: 2040 moveal %d0,%a0 435be: 2410 movel %a0@,%d2
goto done;
435c0: 607c bras 4363e <open+0x1a6>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
435c2: 0802 000a btst #10,%d2 435c6: 6700 00a4 beqw 4366c <open+0x1d4>
rc = ftruncate( iop - rtems_libio_iops, 0 );
435ca: 200a movel %a2,%d0 435cc: 90b9 0005 e874 subl 5e874 <rtems_libio_iops>,%d0 435d2: 223c b6db 6db7 movel #-1227133513,%d1 435d8: e680 asrl #3,%d0 435da: 4c00 1800 mulsl %d0,%d1 435de: 42a7 clrl %sp@- 435e0: 42a7 clrl %sp@- 435e2: 2f01 movel %d1,%sp@- 435e4: 4eb9 0004 99d4 jsr 499d4 <ftruncate>
if ( rc ) {
435ea: 4fef 000c lea %sp@(12),%sp
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
435ee: 2400 movel %d0,%d2
if ( rc ) {
435f0: 677a beqs 4366c <open+0x1d4>
if(errno) rc = errno;
435f2: 47f9 0004 cad0 lea 4cad0 <__errno>,%a3 435f8: 4e93 jsr %a3@ 435fa: 2040 moveal %d0,%a0 435fc: 4a90 tstl %a0@
435fe: 6706 beqs 43606 <open+0x16e> <== NEVER TAKEN
43600: 4e93 jsr %a3@ 43602: 2040 moveal %d0,%a0 43604: 2410 movel %a0@,%d2
close( iop - rtems_libio_iops );
43606: 200a movel %a2,%d0 43608: 90b9 0005 e874 subl 5e874 <rtems_libio_iops>,%d0 4360e: 223c b6db 6db7 movel #-1227133513,%d1 43614: e680 asrl #3,%d0 43616: 4c00 1800 mulsl %d0,%d1
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
4361a: 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;
4361c: 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 );
4361e: 2f01 movel %d1,%sp@- 43620: 4eb9 0004 9950 jsr 49950 <close> 43626: 588f addql #4,%sp 43628: 6014 bras 4363e <open+0x1a6>
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
4362a: 7417 moveq #23,%d2 4362c: 6030 bras 4365e <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;
4362e: 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;
43630: 7402 moveq #2,%d2 43632: 600e bras 43642 <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;
43634: 4285 clrl %d5 <== NOT EXECUTED
* 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;
43636: 740d moveq #13,%d2 <== NOT EXECUTED 43638: 6008 bras 43642 <open+0x1aa> <== NOT EXECUTED
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;
4363a: 7411 moveq #17,%d2 4363c: 6004 bras 43642 <open+0x1aa>
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
4363e: 4a82 tstl %d2
43640: 672a beqs 4366c <open+0x1d4> <== NEVER TAKEN
if ( iop )
43642: 4a8a tstl %a2
43644: 670a beqs 43650 <open+0x1b8>
rtems_libio_free( iop );
43646: 2f0a movel %a2,%sp@- 43648: 4eb9 0004 9c06 jsr 49c06 <rtems_libio_free> 4364e: 588f addql #4,%sp
if ( loc_to_free )
43650: 4a85 tstl %d5
43652: 670a beqs 4365e <open+0x1c6>
rtems_filesystem_freenode( loc_to_free );
43654: 2f05 movel %d5,%sp@- 43656: 4eb9 0004 29d8 jsr 429d8 <rtems_filesystem_freenode> 4365c: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( rc );
4365e: 4eb9 0004 cad0 jsr 4cad0 <__errno> 43664: 2040 moveal %d0,%a0 43666: 70ff moveq #-1,%d0 43668: 2082 movel %d2,%a0@ 4366a: 6014 bras 43680 <open+0x1e8>
}
return iop - rtems_libio_iops;
4366c: 200a movel %a2,%d0 4366e: 90b9 0005 e874 subl 5e874 <rtems_libio_iops>,%d0 43674: 223c b6db 6db7 movel #-1227133513,%d1 4367a: e680 asrl #3,%d0 4367c: 4c01 0800 mulsl %d1,%d0
}
43680: 4cee 3c7c ffc8 moveml %fp@(-56),%d2-%d6/%a2-%a5
43686: 4e5e unlk %fp <== NOT EXECUTED
000441aa <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
441aa: 4e56 fff0 linkw %fp,#-16 441ae: 48d7 040c moveml %d2-%d3/%a2,%sp@ 441b2: 242e 0008 movel %fp@(8),%d2 441b6: 246e 000c moveal %fp@(12),%a2 441ba: 1d42 fffe moveb %d2,%fp@(-2)
int i;
if (tty->termios.c_oflag & OPOST) {
441be: 202a 0034 movel %a2@(52),%d0 441c2: 0800 0000 btst #0,%d0 441c6: 6700 010e beqw 442d6 <oproc+0x12c>
switch (c) {
441ca: 4281 clrl %d1 441cc: 1202 moveb %d2,%d1 441ce: 7609 moveq #9,%d3 441d0: b681 cmpl %d1,%d3
441d2: 6778 beqs 4424c <oproc+0xa2>
441d4: 650e bcss 441e4 <oproc+0x3a> <== ALWAYS TAKEN
441d6: 163c 0008 moveb #8,%d3 <== NOT EXECUTED 441da: b681 cmpl %d1,%d3 <== NOT EXECUTED 441dc: 6600 00b2 bnew 44290 <oproc+0xe6> <== NOT EXECUTED 441e0: 6000 00a0 braw 44282 <oproc+0xd8> <== NOT EXECUTED
441e4: 760a moveq #10,%d3 441e6: b681 cmpl %d1,%d3
441e8: 670c beqs 441f6 <oproc+0x4c>
441ea: 163c 000d moveb #13,%d3 441ee: b681 cmpl %d1,%d3 441f0: 6600 009e bnew 44290 <oproc+0xe6>
441f4: 602e bras 44224 <oproc+0x7a> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
441f6: 0800 0005 btst #5,%d0
441fa: 6704 beqs 44200 <oproc+0x56> <== ALWAYS TAKEN
tty->column = 0;
441fc: 42aa 0028 clrl %a2@(40) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
44200: 44c0 movew %d0,%ccr 44202: 6600 00d2 bnew 442d6 <oproc+0x12c>
rtems_termios_puts ("\r", 1, tty);
44206: 2f0a movel %a2,%sp@- 44208: 4878 0001 pea 1 <ADD> 4420c: 4879 0005 c158 pea 5c158 <rtems_filesystem_default_pathconf+0xa6> 44212: 4eb9 0004 40b2 jsr 440b2 <rtems_termios_puts>
tty->column = 0;
44218: 4fef 000c lea %sp@(12),%sp 4421c: 42aa 0028 clrl %a2@(40) 44220: 6000 00b4 braw 442d6 <oproc+0x12c>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
44224: 0800 0004 btst #4,%d0 <== NOT EXECUTED 44228: 6708 beqs 44232 <oproc+0x88> <== NOT EXECUTED 4422a: 4aaa 0028 tstl %a2@(40) <== NOT EXECUTED 4422e: 6700 00ba beqw 442ea <oproc+0x140> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
44232: 44c0 movew %d0,%ccr <== NOT EXECUTED 44234: 6a0e bpls 44244 <oproc+0x9a> <== NOT EXECUTED
c = '\n';
44236: 720a moveq #10,%d1 <== NOT EXECUTED 44238: 1d41 fffe moveb %d1,%fp@(-2) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
4423c: 0800 0005 btst #5,%d0 <== NOT EXECUTED 44240: 6700 0094 beqw 442d6 <oproc+0x12c> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
44244: 42aa 0028 clrl %a2@(40) <== NOT EXECUTED
break;
44248: 6000 008c braw 442d6 <oproc+0x12c> <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
4424c: 222a 0028 movel %a2@(40),%d1 44250: 7407 moveq #7,%d2 44252: 307c 0008 moveaw #8,%a0 44256: c481 andl %d1,%d2
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
44258: 0280 0000 1800 andil #6144,%d0
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
4425e: 91c2 subal %d2,%a0
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
44260: 0c80 0000 1800 cmpil #6144,%d0
44266: 6612 bnes 4427a <oproc+0xd0> <== NEVER TAKEN
tty->column += i;
44268: d288 addl %a0,%d1 4426a: 2541 0028 movel %d1,%a2@(40)
rtems_termios_puts ( " ", i, tty);
4426e: 2f0a movel %a2,%sp@- 44270: 2f08 movel %a0,%sp@- 44272: 4879 0005 c15a pea 5c15a <rtems_filesystem_default_pathconf+0xa8> 44278: 6066 bras 442e0 <oproc+0x136>
return;
}
tty->column += i;
4427a: d1c1 addal %d1,%a0 <== NOT EXECUTED 4427c: 2548 0028 movel %a0,%a2@(40) <== NOT EXECUTED
break;
44280: 6054 bras 442d6 <oproc+0x12c> <== NOT EXECUTED
case '\b':
if (tty->column > 0)
44282: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED 44286: 6f4e bles 442d6 <oproc+0x12c> <== NOT EXECUTED
tty->column--;
44288: 5380 subql #1,%d0 <== NOT EXECUTED 4428a: 2540 0028 movel %d0,%a2@(40) <== NOT EXECUTED 4428e: 6046 bras 442d6 <oproc+0x12c> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
44290: 0800 0001 btst #1,%d0
44294: 6724 beqs 442ba <oproc+0x110> <== ALWAYS TAKEN
c = toupper(c);
44296: 4280 clrl %d0 <== NOT EXECUTED 44298: 1002 moveb %d2,%d0 <== NOT EXECUTED 4429a: 7403 moveq #3,%d2 <== NOT EXECUTED 4429c: 7602 moveq #2,%d3 <== NOT EXECUTED 4429e: 2079 0005 d308 moveal 5d308 <__ctype_ptr__>,%a0 <== NOT EXECUTED 442a4: 1230 0801 moveb %a0@(00000001,%d0:l),%d1 <== NOT EXECUTED 442a8: 49c1 extbl %d1 <== NOT EXECUTED 442aa: c282 andl %d2,%d1 <== NOT EXECUTED 442ac: b681 cmpl %d1,%d3 <== NOT EXECUTED 442ae: 6606 bnes 442b6 <oproc+0x10c> <== NOT EXECUTED 442b0: 0680 ffff ffe0 addil #-32,%d0 <== NOT EXECUTED 442b6: 1d40 fffe moveb %d0,%fp@(-2) <== NOT EXECUTED
if (!iscntrl(c))
442ba: 4280 clrl %d0 442bc: 102e fffe moveb %fp@(-2),%d0 442c0: 2079 0005 d308 moveal 5d308 <__ctype_ptr__>,%a0 442c6: 1030 0801 moveb %a0@(00000001,%d0:l),%d0 442ca: 49c0 extbl %d0 442cc: 0800 0005 btst #5,%d0
442d0: 6604 bnes 442d6 <oproc+0x12c> <== NEVER TAKEN
tty->column++;
442d2: 52aa 0028 addql #1,%a2@(40)
break;
}
}
rtems_termios_puts (&c, 1, tty);
442d6: 2f0a movel %a2,%sp@- 442d8: 4878 0001 pea 1 <ADD> 442dc: 486e fffe pea %fp@(-2) 442e0: 4eb9 0004 40b2 jsr 440b2 <rtems_termios_puts> 442e6: 4fef 000c lea %sp@(12),%sp
}
442ea: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
442f0: 4e5e unlk %fp <== NOT EXECUTED
0004a7e8 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
4a7e8: 4e56 ffe4 linkw %fp,#-28 4a7ec: 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)
4a7f0: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca> 4a7f4: 4879 0005 d9fe pea 5d9fe <_CPU_m68k_BFFFO_table+0x100>
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
4a7fa: 246e 0008 moveal %fp@(8),%a2
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
4a7fe: 4eb9 0004 bd30 jsr 4bd30 <rtems_mkdir> 4a804: 508f addql #8,%sp 4a806: 4a80 tstl %d0 4a808: 6600 00e8 bnew 4a8f2 <pipe_create+0x10a>
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
4a80c: 4878 000a pea a <LASTO> 4a810: 260e movel %fp,%d3 4a812: 4879 0005 da03 pea 5da03 <_CPU_m68k_BFFFO_table+0x105> 4a818: 0683 ffff fff1 addil #-15,%d3 4a81e: 2f03 movel %d3,%sp@- 4a820: 4eb9 0004 ebf4 jsr 4ebf4 <memcpy>
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4a826: 3039 0005 f738 movew 5f738 <rtems_pipe_no>,%d0 4a82c: 2200 movel %d0,%d1 4a82e: 5281 addql #1,%d1 4a830: 3f00 movew %d0,%sp@- 4a832: 33c1 0005 f738 movew %d1,5f738 <rtems_pipe_no> 4a838: 4267 clrw %sp@- 4a83a: 4879 0005 da0e pea 5da0e <_CPU_m68k_BFFFO_table+0x110> 4a840: 486e fffb pea %fp@(-5) 4a844: 4eb9 0004 f06c jsr 4f06c <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4a84a: 4878 0180 pea 180 <DBL_MANT_DIG+0x14b> 4a84e: 2f03 movel %d3,%sp@- 4a850: 4eb9 0004 baf0 jsr 4baf0 <mkfifo> 4a856: 4fef 0020 lea %sp@(32),%sp 4a85a: 4a80 tstl %d0
4a85c: 670a beqs 4a868 <pipe_create+0x80>
if (errno != EEXIST){
4a85e: 4eb9 0004 e348 jsr 4e348 <__errno> 4a864: 6000 008c braw 4a8f2 <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);
4a868: 4878 4000 pea 4000 <D_MAX_EXP+0x3801> 4a86c: 2f03 movel %d3,%sp@- 4a86e: 4eb9 0004 4660 jsr 44660 <open>
if (filsdes[0] < 0) {
4a874: 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);
4a876: 2480 movel %d0,%a2@
if (filsdes[0] < 0) {
4a878: 6c0e bges 4a888 <pipe_create+0xa0>
err = errno;
4a87a: 4eb9 0004 e348 jsr 4e348 <__errno> 4a880: 2040 moveal %d0,%a0 4a882: 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);
4a884: 2f03 movel %d3,%sp@- 4a886: 6054 bras 4a8dc <pipe_create+0xf4>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
4a888: b0b9 0005 e594 cmpl 5e594 <rtems_libio_number_iops>,%d0
4a88e: 6412 bccs 4a8a2 <pipe_create+0xba> <== NEVER TAKEN
4a890: 2200 movel %d0,%d1 4a892: ed88 lsll #6,%d0 4a894: e789 lsll #3,%d1 4a896: 2079 0005 fe2c moveal 5fe2c <rtems_libio_iops>,%a0 4a89c: 9081 subl %d1,%d0 4a89e: d1c0 addal %d0,%a0 4a8a0: 6002 bras 4a8a4 <pipe_create+0xbc>
4a8a2: 91c8 subal %a0,%a0 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
4a8a4: 70fe moveq #-2,%d0 4a8a6: c1a8 0014 andl %d0,%a0@(20)
filsdes[1] = open(fifopath, O_WRONLY);
4a8aa: 4878 0001 pea 1 <ADD> 4a8ae: 486e fff1 pea %fp@(-15) 4a8b2: 4eb9 0004 4660 jsr 44660 <open>
if (filsdes[1] < 0) {
4a8b8: 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);
4a8ba: 2540 0004 movel %d0,%a2@(4)
if (filsdes[1] < 0) {
4a8be: 6c16 bges 4a8d6 <pipe_create+0xee>
err = errno;
4a8c0: 4eb9 0004 e348 jsr 4e348 <__errno> 4a8c6: 2040 moveal %d0,%a0 4a8c8: 2410 movel %a0@,%d2
close(filsdes[0]);
4a8ca: 2f12 movel %a2@,%sp@- 4a8cc: 4eb9 0004 3560 jsr 43560 <close> 4a8d2: 588f addql #4,%sp 4a8d4: 6002 bras 4a8d8 <pipe_create+0xf0>
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
4a8d6: 4282 clrl %d2
if (filsdes[1] < 0) {
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
4a8d8: 486e fff1 pea %fp@(-15) 4a8dc: 4eb9 0004 6204 jsr 46204 <unlink> 4a8e2: 588f addql #4,%sp
} if(err != 0)
4a8e4: 4a82 tstl %d2
4a8e6: 670e beqs 4a8f6 <pipe_create+0x10e>
rtems_set_errno_and_return_minus_one(err);
4a8e8: 4eb9 0004 e348 jsr 4e348 <__errno> 4a8ee: 2040 moveal %d0,%a0 4a8f0: 2082 movel %d2,%a0@ 4a8f2: 70ff moveq #-1,%d0 4a8f4: 6002 bras 4a8f8 <pipe_create+0x110>
return 0;
4a8f6: 4280 clrl %d0
}
4a8f8: 4cee 040c ffe4 moveml %fp@(-28),%d2-%d3/%a2 4a8fe: 4e5e unlk %fp
...
0004bc4a <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4bc4a: 4e56 0000 linkw %fp,#0
if (cmd == FIONREAD) {
4bc4e: 203c 4004 667f movel #1074030207,%d0
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4bc54: 2f0b movel %a3,%sp@- 4bc56: 266e 0010 moveal %fp@(16),%a3 4bc5a: 2f0a movel %a2,%sp@- 4bc5c: 246e 0008 moveal %fp@(8),%a2
if (cmd == FIONREAD) {
4bc60: b0ae 000c cmpl %fp@(12),%d0
4bc64: 662e bnes 4bc94 <pipe_ioctl+0x4a>
if (buffer == NULL)
4bc66: 4a8b tstl %a3
4bc68: 672e beqs 4bc98 <pipe_ioctl+0x4e>
return -EFAULT;
if (! PIPE_LOCK(pipe))
4bc6a: 42a7 clrl %sp@- 4bc6c: 42a7 clrl %sp@- 4bc6e: 2f2a 0028 movel %a2@(40),%sp@- 4bc72: 4eb9 0004 759c jsr 4759c <rtems_semaphore_obtain> 4bc78: 4fef 000c lea %sp@(12),%sp 4bc7c: 4a80 tstl %d0
4bc7e: 661c bnes 4bc9c <pipe_ioctl+0x52> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4bc80: 26aa 000c movel %a2@(12),%a3@
PIPE_UNLOCK(pipe);
4bc84: 2f2a 0028 movel %a2@(40),%sp@- 4bc88: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release>
return 0;
4bc8e: 588f addql #4,%sp 4bc90: 4280 clrl %d0 4bc92: 600a bras 4bc9e <pipe_ioctl+0x54>
}
return -EINVAL;
4bc94: 70ea moveq #-22,%d0 4bc96: 6006 bras 4bc9e <pipe_ioctl+0x54>
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
4bc98: 70f2 moveq #-14,%d0 4bc9a: 6002 bras 4bc9e <pipe_ioctl+0x54>
if (! PIPE_LOCK(pipe))
return -EINTR;
4bc9c: 70fc moveq #-4,%d0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
4bc9e: 246e fff8 moveal %fp@(-8),%a2 4bca2: 266e fffc moveal %fp@(-4),%a3
4bca6: 4e5e unlk %fp <== NOT EXECUTED
0004b95e <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4b95e: 4e56 ffd4 linkw %fp,#-44 4b962: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4b966: 42a7 clrl %sp@-
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4b968: 246e 0008 moveal %fp@(8),%a2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4b96c: 2e3c 0004 759c movel #292252,%d7 4b972: 2047 moveal %d7,%a0 4b974: 42a7 clrl %sp@- 4b976: 2f2a 0028 movel %a2@(40),%sp@-
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4b97a: 286e 000c moveal %fp@(12),%a4 4b97e: 2a2e 0010 movel %fp@(16),%d5
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4b982: 4e90 jsr %a0@ 4b984: 4fef 000c lea %sp@(12),%sp 4b988: 4a80 tstl %d0 4b98a: 6600 011c bnew 4baa8 <pipe_read+0x14a>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
4b98e: 2c0e movel %fp,%d6
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4b990: 4282 clrl %d2 4b992: 47f9 0004 f90c lea 4f90c <memcpy>,%a3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
4b998: 5986 subql #4,%d6 4b99a: 4bf9 0004 cffc lea 4cffc <rtems_barrier_release>,%a5 4b9a0: 6000 00e2 braw 4ba84 <pipe_read+0x126>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4b9a4: 4aaa 0014 tstl %a2@(20) 4b9a8: 6700 00e0 beqw 4ba8a <pipe_read+0x12c>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4b9ac: 206e 0014 moveal %fp@(20),%a0 4b9b0: 7001 moveq #1,%d0 4b9b2: c0a8 0014 andl %a0@(20),%d0 4b9b6: 6600 00d6 bnew 4ba8e <pipe_read+0x130>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
4b9ba: 52aa 0018 addql #1,%a2@(24)
PIPE_UNLOCK(pipe);
4b9be: 2f2a 0028 movel %a2@(40),%sp@- 4b9c2: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
4b9c8: 42a7 clrl %sp@- 4b9ca: 2f2a 002c movel %a2@(44),%sp@- 4b9ce: 4eb9 0004 d060 jsr 4d060 <rtems_barrier_wait> 4b9d4: 4fef 000c lea %sp@(12),%sp 4b9d8: 4a80 tstl %d0
4b9da: 6604 bnes 4b9e0 <pipe_read+0x82> <== NEVER TAKEN
4b9dc: 4283 clrl %d3 4b9de: 6002 bras 4b9e2 <pipe_read+0x84>
ret = -EINTR;
4b9e0: 76fc moveq #-4,%d3 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
4b9e2: 42a7 clrl %sp@- 4b9e4: 2047 moveal %d7,%a0 4b9e6: 42a7 clrl %sp@- 4b9e8: 2f2a 0028 movel %a2@(40),%sp@- 4b9ec: 4e90 jsr %a0@ 4b9ee: 4fef 000c lea %sp@(12),%sp 4b9f2: 4a80 tstl %d0 4b9f4: 6600 00a8 bnew 4ba9e <pipe_read+0x140>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
4b9f8: 53aa 0018 subql #1,%a2@(24)
if (ret != 0)
4b9fc: 4a83 tstl %d3 4b9fe: 6600 0090 bnew 4ba90 <pipe_read+0x132>
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
4ba02: 262a 000c movel %a2@(12),%d3
4ba06: 679c beqs 4b9a4 <pipe_read+0x46> <== NEVER TAKEN
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
4ba08: 2005 movel %d5,%d0 4ba0a: 9082 subl %d2,%d0 4ba0c: b083 cmpl %d3,%d0
4ba0e: 6402 bccs 4ba12 <pipe_read+0xb4>
4ba10: 2600 movel %d0,%d3
chunk1 = pipe->Size - pipe->Start;
4ba12: 222a 0008 movel %a2@(8),%d1 4ba16: 200c movel %a4,%d0 4ba18: d082 addl %d2,%d0 4ba1a: 282a 0004 movel %a2@(4),%d4 4ba1e: 9881 subl %d1,%d4 4ba20: d292 addl %a2@,%d1
if (chunk > chunk1) {
4ba22: b883 cmpl %d3,%d4
4ba24: 6c20 bges 4ba46 <pipe_read+0xe8>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4ba26: 2f04 movel %d4,%sp@- 4ba28: 2f01 movel %d1,%sp@- 4ba2a: 2f00 movel %d0,%sp@- 4ba2c: 4e93 jsr %a3@
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4ba2e: 2203 movel %d3,%d1 4ba30: 9284 subl %d4,%d1 4ba32: 2002 movel %d2,%d0 4ba34: d084 addl %d4,%d0 4ba36: 2f01 movel %d1,%sp@- 4ba38: 2f12 movel %a2@,%sp@- 4ba3a: 4874 0800 pea %a4@(00000000,%d0:l) 4ba3e: 4e93 jsr %a3@ 4ba40: 4fef 0018 lea %sp@(24),%sp 4ba44: 600c bras 4ba52 <pipe_read+0xf4>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4ba46: 2f03 movel %d3,%sp@- 4ba48: 2f01 movel %d1,%sp@- 4ba4a: 2f00 movel %d0,%sp@- 4ba4c: 4e93 jsr %a3@ 4ba4e: 4fef 000c lea %sp@(12),%sp
pipe->Start += chunk;
4ba52: 2003 movel %d3,%d0 4ba54: d0aa 0008 addl %a2@(8),%d0
pipe->Start %= pipe->Size;
4ba58: 4c6a 0001 0004 remul %a2@(4),%d1,%d0
pipe->Length -= chunk;
4ba5e: 202a 000c movel %a2@(12),%d0 4ba62: 9083 subl %d3,%d0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
4ba64: 2541 0008 movel %d1,%a2@(8)
pipe->Length -= chunk;
4ba68: 2540 000c movel %d0,%a2@(12)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
4ba6c: 6604 bnes 4ba72 <pipe_read+0x114>
pipe->Start = 0;
4ba6e: 42aa 0008 clrl %a2@(8)
if (pipe->waitingWriters > 0)
4ba72: 4aaa 001c tstl %a2@(28)
4ba76: 670a beqs 4ba82 <pipe_read+0x124>
PIPE_WAKEUPWRITERS(pipe);
4ba78: 2f06 movel %d6,%sp@- 4ba7a: 2f2a 0030 movel %a2@(48),%sp@- 4ba7e: 4e95 jsr %a5@ 4ba80: 508f addql #8,%sp
read += chunk;
4ba82: d483 addl %d3,%d2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
4ba84: ba82 cmpl %d2,%d5 4ba86: 6200 ff7a bhiw 4ba02 <pipe_read+0xa4>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4ba8a: 4283 clrl %d3 4ba8c: 6002 bras 4ba90 <pipe_read+0x132>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
4ba8e: 76f5 moveq #-11,%d3
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
4ba90: 2f2a 0028 movel %a2@(40),%sp@- 4ba94: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release> 4ba9a: 588f addql #4,%sp 4ba9c: 6002 bras 4baa0 <pipe_read+0x142>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
4ba9e: 76fc moveq #-4,%d3 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
4baa0: 4a82 tstl %d2
4baa2: 6f08 bles 4baac <pipe_read+0x14e>
4baa4: 2002 movel %d2,%d0 4baa6: 6006 bras 4baae <pipe_read+0x150>
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
4baa8: 70fc moveq #-4,%d0 <== NOT EXECUTED 4baaa: 6002 bras 4baae <pipe_read+0x150> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
return read;
return ret;
4baac: 2003 movel %d3,%d0
}
4baae: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4bab4: 4e5e unlk %fp <== NOT EXECUTED
0004b4fa <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b4fa: 4e56 fff0 linkw %fp,#-16
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b4fe: 206e 000c moveal %fp@(12),%a0
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b502: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 4b506: 266e 0008 moveal %fp@(8),%a3
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b50a: 7406 moveq #6,%d2
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
4b50c: 2453 moveal %a3@,%a2
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b50e: c4a8 0014 andl %a0@(20),%d2
if (mode & LIBIO_FLAGS_READ)
4b512: 0802 0001 btst #1,%d2
4b516: 6704 beqs 4b51c <pipe_release+0x22>
pipe->Readers --;
4b518: 53aa 0010 subql #1,%a2@(16)
if (mode & LIBIO_FLAGS_WRITE)
4b51c: 44c2 movew %d2,%ccr
4b51e: 6604 bnes 4b524 <pipe_release+0x2a>
pipe->Writers --;
4b520: 53aa 0014 subql #1,%a2@(20)
PIPE_UNLOCK(pipe);
4b524: 2f2a 0028 movel %a2@(40),%sp@- 4b528: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
4b52e: 588f addql #4,%sp 4b530: 4aaa 0010 tstl %a2@(16)
4b534: 6622 bnes 4b558 <pipe_release+0x5e>
4b536: 4aaa 0014 tstl %a2@(20)
4b53a: 660c bnes 4b548 <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);
4b53c: 2f0a movel %a2,%sp@- 4b53e: 4eba ff72 jsr %pc@(4b4b2 <pipe_free>)
*pipep = NULL;
4b542: 588f addql #4,%sp 4b544: 4293 clrl %a3@ 4b546: 602c bras 4b574 <pipe_release+0x7a>
} else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4b548: 7004 moveq #4,%d0 4b54a: b082 cmpl %d2,%d0
4b54c: 670a beqs 4b558 <pipe_release+0x5e> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
4b54e: 486e fffc pea %fp@(-4) 4b552: 2f2a 0030 movel %a2@(48),%sp@- 4b556: 6014 bras 4b56c <pipe_release+0x72>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
4b558: 4aaa 0014 tstl %a2@(20)
4b55c: 6616 bnes 4b574 <pipe_release+0x7a> <== NEVER TAKEN
4b55e: 7002 moveq #2,%d0 4b560: b082 cmpl %d2,%d0
4b562: 6710 beqs 4b574 <pipe_release+0x7a> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4b564: 486e fffc pea %fp@(-4) 4b568: 2f2a 002c movel %a2@(44),%sp@- 4b56c: 4eb9 0004 cffc jsr 4cffc <rtems_barrier_release> 4b572: 508f addql #8,%sp
pipe_unlock();
4b574: 4eba ff26 jsr %pc@(4b49c <pipe_unlock>)
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
4b578: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4b57e: 4e5e unlk %fp <== NOT EXECUTED
0004bab8 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4bab8: 4e56 ffd4 linkw %fp,#-44 4babc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4bac0: 246e 0008 moveal %fp@(8),%a2 4bac4: 286e 000c moveal %fp@(12),%a4 4bac8: 282e 0010 movel %fp@(16),%d4
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4bacc: 6700 0168 beqw 4bc36 <pipe_write+0x17e>
return 0;
if (! PIPE_LOCK(pipe))
4bad0: 42a7 clrl %sp@- 4bad2: 42a7 clrl %sp@- 4bad4: 2f2a 0028 movel %a2@(40),%sp@- 4bad8: 4eb9 0004 759c jsr 4759c <rtems_semaphore_obtain> 4bade: 4fef 000c lea %sp@(12),%sp 4bae2: 4a80 tstl %d0 4bae4: 6600 0154 bnew 4bc3a <pipe_write+0x182>
return -EINTR;
if (pipe->Readers == 0) {
4bae8: 4aaa 0010 tstl %a2@(16) 4baec: 6700 010a beqw 4bbf8 <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;
4baf0: b8aa 0004 cmpl %a2@(4),%d4
4baf4: 6204 bhis 4bafa <pipe_write+0x42> <== NEVER TAKEN
4baf6: 2a04 movel %d4,%d5 4baf8: 6002 bras 4bafc <pipe_write+0x44>
4bafa: 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;
4bafc: 4282 clrl %d2
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
4bafe: 2e3c 0004 d060 movel #315488,%d7 4bb04: 47f9 0004 f90c lea 4f90c <memcpy>,%a3
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
4bb0a: 4bf9 0004 cffc lea 4cffc <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)) {
4bb10: 2c3c 0004 759c movel #292252,%d6 4bb16: 6000 00d8 braw 4bbf0 <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)) {
4bb1a: 206e 0014 moveal %fp@(20),%a0 4bb1e: 7001 moveq #1,%d0 4bb20: c0a8 0014 andl %a0@(20),%d0 4bb24: 6600 00d8 bnew 4bbfe <pipe_write+0x146>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
4bb28: 52aa 001c addql #1,%a2@(28)
PIPE_UNLOCK(pipe);
4bb2c: 2f2a 0028 movel %a2@(40),%sp@- 4bb30: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
4bb36: 2047 moveal %d7,%a0 4bb38: 42a7 clrl %sp@- 4bb3a: 2f2a 0030 movel %a2@(48),%sp@- 4bb3e: 4e90 jsr %a0@ 4bb40: 4fef 000c lea %sp@(12),%sp 4bb44: 4a80 tstl %d0
4bb46: 6604 bnes 4bb4c <pipe_write+0x94> <== NEVER TAKEN
4bb48: 4283 clrl %d3 4bb4a: 6002 bras 4bb4e <pipe_write+0x96>
ret = -EINTR;
4bb4c: 76fc moveq #-4,%d3 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
4bb4e: 42a7 clrl %sp@- 4bb50: 2046 moveal %d6,%a0 4bb52: 42a7 clrl %sp@- 4bb54: 2f2a 0028 movel %a2@(40),%sp@- 4bb58: 4e90 jsr %a0@ 4bb5a: 4fef 000c lea %sp@(12),%sp 4bb5e: 4a80 tstl %d0 4bb60: 6600 00ca bnew 4bc2c <pipe_write+0x174>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
4bb64: 53aa 001c subql #1,%a2@(28)
if (ret != 0)
4bb68: 4a83 tstl %d3 4bb6a: 6600 0098 bnew 4bc04 <pipe_write+0x14c>
goto out_locked;
if (pipe->Readers == 0) {
4bb6e: 4aaa 0010 tstl %a2@(16) 4bb72: 6700 008e beqw 4bc02 <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) {
4bb76: 202a 0004 movel %a2@(4),%d0 4bb7a: 2600 movel %d0,%d3 4bb7c: 222a 000c movel %a2@(12),%d1 4bb80: 9681 subl %d1,%d3 4bb82: ba83 cmpl %d3,%d5
4bb84: 6294 bhis 4bb1a <pipe_write+0x62>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
4bb86: 2044 moveal %d4,%a0 4bb88: 91c2 subal %d2,%a0 4bb8a: b1c3 cmpal %d3,%a0
4bb8c: 6402 bccs 4bb90 <pipe_write+0xd8>
4bb8e: 2608 movel %a0,%d3
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4bb90: 2a01 movel %d1,%d5 4bb92: daaa 0008 addl %a2@(8),%d5 4bb96: 4c40 5001 remul %d0,%d1,%d5 4bb9a: 2a00 movel %d0,%d5 4bb9c: 9a81 subl %d1,%d5 4bb9e: 2012 movel %a2@,%d0 4bba0: d081 addl %d1,%d0 4bba2: 220c movel %a4,%d1 4bba4: d282 addl %d2,%d1
if (chunk > chunk1) {
4bba6: ba83 cmpl %d3,%d5
4bba8: 6c20 bges 4bbca <pipe_write+0x112>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4bbaa: 2f05 movel %d5,%sp@- 4bbac: 2f01 movel %d1,%sp@- 4bbae: 2f00 movel %d0,%sp@- 4bbb0: 4e93 jsr %a3@
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4bbb2: 2203 movel %d3,%d1 4bbb4: 9285 subl %d5,%d1 4bbb6: 2005 movel %d5,%d0 4bbb8: d082 addl %d2,%d0 4bbba: 2f01 movel %d1,%sp@- 4bbbc: 4874 0800 pea %a4@(00000000,%d0:l) 4bbc0: 2f12 movel %a2@,%sp@- 4bbc2: 4e93 jsr %a3@ 4bbc4: 4fef 0018 lea %sp@(24),%sp 4bbc8: 600c bras 4bbd6 <pipe_write+0x11e>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4bbca: 2f03 movel %d3,%sp@- 4bbcc: 2f01 movel %d1,%sp@- 4bbce: 2f00 movel %d0,%sp@- 4bbd0: 4e93 jsr %a3@ 4bbd2: 4fef 000c lea %sp@(12),%sp
pipe->Length += chunk;
4bbd6: d7aa 000c addl %d3,%a2@(12)
if (pipe->waitingReaders > 0)
4bbda: 4aaa 0018 tstl %a2@(24)
4bbde: 670c beqs 4bbec <pipe_write+0x134>
PIPE_WAKEUPREADERS(pipe);
4bbe0: 486e fffc pea %fp@(-4) 4bbe4: 2f2a 002c movel %a2@(44),%sp@- 4bbe8: 4e95 jsr %a5@ 4bbea: 508f addql #8,%sp
written += chunk;
4bbec: d483 addl %d3,%d2
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
4bbee: 7a01 moveq #1,%d5
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
4bbf0: b882 cmpl %d2,%d4
4bbf2: 6282 bhis 4bb76 <pipe_write+0xbe>
4bbf4: 4283 clrl %d3 4bbf6: 600c bras 4bc04 <pipe_write+0x14c>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
4bbf8: 76e0 moveq #-32,%d3
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
int chunk, chunk1, written = 0, ret = 0;
4bbfa: 4282 clrl %d2 4bbfc: 6006 bras 4bc04 <pipe_write+0x14c>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
4bbfe: 76f5 moveq #-11,%d3 4bc00: 6002 bras 4bc04 <pipe_write+0x14c>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
4bc02: 76e0 moveq #-32,%d3 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
4bc04: 2f2a 0028 movel %a2@(40),%sp@- 4bc08: 4eb9 0004 76a4 jsr 476a4 <rtems_semaphore_release> 4bc0e: 588f addql #4,%sp
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
4bc10: 70e0 moveq #-32,%d0 4bc12: b083 cmpl %d3,%d0
4bc14: 6618 bnes 4bc2e <pipe_write+0x176>
kill(getpid(), SIGPIPE);
4bc16: 4eb9 0004 c414 jsr 4c414 <getpid> 4bc1c: 4878 000d pea d <OPER1+0x1> 4bc20: 2f00 movel %d0,%sp@- 4bc22: 4eb9 0004 c6b0 jsr 4c6b0 <kill> 4bc28: 508f addql #8,%sp 4bc2a: 6002 bras 4bc2e <pipe_write+0x176>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
4bc2c: 76fc moveq #-4,%d3 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4bc2e: 4a82 tstl %d2
4bc30: 6f0c bles 4bc3e <pipe_write+0x186>
4bc32: 2002 movel %d2,%d0 4bc34: 600a bras 4bc40 <pipe_write+0x188>
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
4bc36: 4280 clrl %d0 <== NOT EXECUTED 4bc38: 6006 bras 4bc40 <pipe_write+0x188> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
4bc3a: 70fc moveq #-4,%d0 <== NOT EXECUTED 4bc3c: 6002 bras 4bc40 <pipe_write+0x188> <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4bc3e: 2003 movel %d3,%d0
return written;
return ret;
}
4bc40: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4bc46: 4e5e unlk %fp <== NOT EXECUTED
00046dcc <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
46dcc: 4e56 0000 linkw %fp,#0 46dd0: 202e 000c movel %fp@(12),%d0
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
46dd4: 2200 movel %d0,%d1 46dd6: 5381 subql #1,%d1
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
46dd8: 52b9 0006 4150 addql #1,64150 <rtems_malloc_statistics+0x8>
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
46dde: c280 andl %d0,%d1
46de0: 6610 bnes 46df2 <posix_memalign+0x26> <== NEVER TAKEN
46de2: 123c 0003 moveb #3,%d1 46de6: b280 cmpl %d0,%d1
46de8: 6408 bccs 46df2 <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 ); }
46dea: 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 );
46dec: 4ef9 0004 6f68 jmp 46f68 <rtems_memalign>
}
46df2: 7016 moveq #22,%d0
46df4: 4e5e unlk %fp <== NOT EXECUTED
0004a56c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
4a56c: 4e56 0000 linkw %fp,#0 4a570: 206e 0008 moveal %fp@(8),%a0 4a574: 222e 000c movel %fp@(12),%d1 4a578: 2f02 movel %d2,%sp@-
if ( !attr || !attr->is_initialized )
4a57a: 4a88 tstl %a0
4a57c: 671e beqs 4a59c <pthread_attr_setschedpolicy+0x30>
4a57e: 4a90 tstl %a0@
4a580: 671a beqs 4a59c <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
4a582: 7004 moveq #4,%d0 4a584: b081 cmpl %d1,%d0
4a586: 6518 bcss 4a5a0 <pthread_attr_setschedpolicy+0x34>
4a588: 103c 0001 moveb #1,%d0 4a58c: 7417 moveq #23,%d2 4a58e: e3a8 lsll %d1,%d0 4a590: c082 andl %d2,%d0
4a592: 670c beqs 4a5a0 <pthread_attr_setschedpolicy+0x34><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
4a594: 2141 0014 movel %d1,%a0@(20)
return 0;
4a598: 4280 clrl %d0 4a59a: 600a bras 4a5a6 <pthread_attr_setschedpolicy+0x3a>
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
4a59c: 7016 moveq #22,%d0 4a59e: 6006 bras 4a5a6 <pthread_attr_setschedpolicy+0x3a>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
4a5a0: 203c 0000 0086 movel #134,%d0
} }
4a5a6: 241f movel %sp@+,%d2
4a5a8: 4e5e unlk %fp <== NOT EXECUTED
00045c0c <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
45c0c: 4e56 ffdc linkw %fp,#-36 45c10: 206e 000c moveal %fp@(12),%a0 45c14: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 45c18: 246e 0008 moveal %fp@(8),%a2 45c1c: 242e 0010 movel %fp@(16),%d2
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
45c20: 4a8a tstl %a2 45c22: 6700 008e beqw 45cb2 <pthread_barrier_init+0xa6>
return EINVAL;
if ( count == 0 )
45c26: 4a82 tstl %d2 45c28: 6700 0088 beqw 45cb2 <pthread_barrier_init+0xa6>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
45c2c: 4a88 tstl %a0
45c2e: 6614 bnes 45c44 <pthread_barrier_init+0x38>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
45c30: 260e movel %fp,%d3 45c32: 0683 ffff fff0 addil #-16,%d3 45c38: 2f03 movel %d3,%sp@- 45c3a: 4eb9 0004 5b50 jsr 45b50 <pthread_barrierattr_init> 45c40: 588f addql #4,%sp
the_attr = &my_attr;
45c42: 2043 moveal %d3,%a0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
45c44: 4a90 tstl %a0@
45c46: 676a beqs 45cb2 <pthread_barrier_init+0xa6>
return EINVAL;
switch ( the_attr->process_shared ) {
45c48: 4aa8 0004 tstl %a0@(4)
45c4c: 6664 bnes 45cb2 <pthread_barrier_init+0xa6> <== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
45c4e: 2039 0005 ffac movel 5ffac <_Thread_Dispatch_disable_level>,%d0 45c54: 5280 addql #1,%d0
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
45c56: 42ae fff8 clrl %fp@(-8)
the_attributes.maximum_count = count;
45c5a: 2d42 fffc movel %d2,%fp@(-4) 45c5e: 23c0 0005 ffac movel %d0,5ffac <_Thread_Dispatch_disable_level>
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
_Objects_Allocate( &_POSIX_Barrier_Information );
45c64: 4879 0006 02aa pea 602aa <_POSIX_Barrier_Information> 45c6a: 49f9 0004 8ab2 lea 48ab2 <_Thread_Enable_dispatch>,%a4 45c70: 4eb9 0004 7b28 jsr 47b28 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
45c76: 588f addql #4,%sp 45c78: 2640 moveal %d0,%a3 45c7a: 4a80 tstl %d0
45c7c: 6606 bnes 45c84 <pthread_barrier_init+0x78>
_Thread_Enable_dispatch();
45c7e: 4e94 jsr %a4@
return EAGAIN;
45c80: 700b moveq #11,%d0 45c82: 6030 bras 45cb4 <pthread_barrier_init+0xa8>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
45c84: 486e fff8 pea %fp@(-8) 45c88: 486b 0010 pea %a3@(16) 45c8c: 4eb9 0004 7230 jsr 47230 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45c92: 202b 0008 movel %a3@(8),%d0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
45c96: 4281 clrl %d1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45c98: 2079 0006 02c2 moveal 602c2 <_POSIX_Barrier_Information+0x18>,%a0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
45c9e: 3200 movew %d0,%d1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45ca0: 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;
45ca4: 42ab 000c clrl %a3@(12)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
45ca8: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
45caa: 4e94 jsr %a4@
return 0;
45cac: 508f addql #8,%sp 45cae: 4280 clrl %d0 45cb0: 6002 bras 45cb4 <pthread_barrier_init+0xa8>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
45cb2: 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; }
45cb4: 4cee 1c0c ffdc moveml %fp@(-36),%d2-%d3/%a2-%a4 45cba: 4e5e unlk %fp
...
00045630 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
45630: 4e56 0000 linkw %fp,#0 45634: 2f03 movel %d3,%sp@- 45636: 262e 000c movel %fp@(12),%d3 4563a: 2f02 movel %d2,%sp@- 4563c: 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 )
45640: 6754 beqs 45696 <pthread_cleanup_push+0x66>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
45642: 2039 0005 f8f2 movel 5f8f2 <_Thread_Dispatch_disable_level>,%d0 45648: 5280 addql #1,%d0 4564a: 23c0 0005 f8f2 movel %d0,5f8f2 <_Thread_Dispatch_disable_level>
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
45650: 4878 0010 pea 10 <INVALID_OPERATION> 45654: 4eb9 0004 94b8 jsr 494b8 <_Workspace_Allocate>
if ( handler ) {
4565a: 588f addql #4,%sp 4565c: 4a80 tstl %d0
4565e: 6726 beqs 45686 <pthread_cleanup_push+0x56> <== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
45660: 2079 0005 fd5c moveal 5fd5c <_Per_CPU_Information+0xc>,%a0
handler_stack = &thread_support->Cancellation_Handlers;
45666: 2228 0102 movel %a0@(258),%d1
handler->routine = routine;
4566a: 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;
4566c: 0681 0000 00e4 addil #228,%d1
handler->routine = routine;
45672: 2142 0008 movel %d2,%a0@(8)
handler->arg = arg;
45676: 2143 000c movel %d3,%a0@(12)
_Chain_Append( handler_stack, &handler->Node );
4567a: 2f00 movel %d0,%sp@- 4567c: 2f01 movel %d1,%sp@- 4567e: 4eb9 0004 6cc8 jsr 46cc8 <_Chain_Append> 45684: 508f addql #8,%sp
} _Thread_Enable_dispatch(); }
45686: 242e fff8 movel %fp@(-8),%d2 4568a: 262e fffc movel %fp@(-4),%d3 4568e: 4e5e unlk %fp
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
45690: 4ef9 0004 850e jmp 4850e <_Thread_Enable_dispatch>
}
45696: 242e fff8 movel %fp@(-8),%d2 4569a: 262e fffc movel %fp@(-4),%d3 4569e: 4e5e unlk %fp
...
00046354 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
46354: 4e56 fff4 linkw %fp,#-12 46358: 48d7 1c00 moveml %a2-%a4,%sp@ 4635c: 246e 000c moveal %fp@(12),%a2
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
46360: 4a8a tstl %a2
46362: 6606 bnes 4636a <pthread_cond_init+0x16> else the_attr = &_POSIX_Condition_variables_Default_attributes;
46364: 45f9 0005 e662 lea 5e662 <_POSIX_Condition_variables_Default_attributes>,%a2
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
4636a: 7001 moveq #1,%d0 4636c: b0aa 0004 cmpl %a2@(4),%d0
46370: 6778 beqs 463ea <pthread_cond_init+0x96> <== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
46372: 4a92 tstl %a2@
46374: 6774 beqs 463ea <pthread_cond_init+0x96>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
46376: 2039 0006 0ed8 movel 60ed8 <_Thread_Dispatch_disable_level>,%d0 4637c: 5280 addql #1,%d0 4637e: 23c0 0006 0ed8 movel %d0,60ed8 <_Thread_Dispatch_disable_level>
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
46384: 4879 0006 1262 pea 61262 <_POSIX_Condition_variables_Information> 4638a: 49f9 0004 96fe lea 496fe <_Thread_Enable_dispatch>,%a4 46390: 4eb9 0004 8774 jsr 48774 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
46396: 588f addql #4,%sp 46398: 2640 moveal %d0,%a3 4639a: 4a80 tstl %d0
4639c: 6606 bnes 463a4 <pthread_cond_init+0x50>
_Thread_Enable_dispatch();
4639e: 4e94 jsr %a4@
return ENOMEM;
463a0: 700c moveq #12,%d0 463a2: 6048 bras 463ec <pthread_cond_init+0x98>
}
the_cond->process_shared = the_attr->process_shared;
463a4: 276a 0004 0010 movel %a2@(4),%a3@(16)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
463aa: 42ab 0014 clrl %a3@(20)
_Thread_queue_Initialize(
463ae: 4878 0074 pea 74 <DBL_MANT_DIG+0x3f> 463b2: 2f3c 1000 0800 movel #268437504,%sp@- 463b8: 42a7 clrl %sp@- 463ba: 486b 0018 pea %a3@(24) 463be: 4eb9 0004 9dd0 jsr 49dd0 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
463c4: 202b 0008 movel %a3@(8),%d0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
463c8: 4281 clrl %d1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
463ca: 2079 0006 127a moveal 6127a <_POSIX_Condition_variables_Information+0x18>,%a0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
463d0: 3200 movew %d0,%d1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
463d2: 218b 1c00 movel %a3,%a0@(00000000,%d1:l:4)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
463d6: 206e 0008 moveal %fp@(8),%a0
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
463da: 42ab 000c clrl %a3@(12) 463de: 2080 movel %d0,%a0@
_Thread_Enable_dispatch();
463e0: 4e94 jsr %a4@
return 0;
463e2: 4fef 0010 lea %sp@(16),%sp 463e6: 4280 clrl %d0 463e8: 6002 bras 463ec <pthread_cond_init+0x98>
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
if ( !the_attr->is_initialized )
return EINVAL;
463ea: 7016 moveq #22,%d0
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
463ec: 4cee 1c00 fff4 moveml %fp@(-12),%a2-%a4 463f2: 4e5e unlk %fp
...
000461f0 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
461f0: 4e56 0000 linkw %fp,#0 461f4: 206e 0008 moveal %fp@(8),%a0
if ( !attr || attr->is_initialized == false )
461f8: 4a88 tstl %a0
461fa: 670a beqs 46206 <pthread_condattr_destroy+0x16>
461fc: 4a90 tstl %a0@
461fe: 6706 beqs 46206 <pthread_condattr_destroy+0x16> <== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
46200: 4290 clrl %a0@
return 0;
46202: 4280 clrl %d0 46204: 6002 bras 46208 <pthread_condattr_destroy+0x18>
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
46206: 7016 moveq #22,%d0
attr->is_initialized = false;
return 0;
}
46208: 4e5e unlk %fp <== NOT EXECUTED
0004c634 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
4c634: 4e56 0000 linkw %fp,#0
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
4c638: 2f2e 0008 movel %fp@(8),%sp@- 4c63c: 2f39 0005 ee32 movel 5ee32 <_Per_CPU_Information+0xc>,%sp@- 4c642: 4eb9 0004 c5c4 jsr 4c5c4 <_POSIX_Thread_Exit>
4c648: 508f addql #8,%sp <== NOT EXECUTED
}
4c64a: 4e5e unlk %fp <== NOT EXECUTED
...
0005af68 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
5af68: 4e56 fff0 linkw %fp,#-16 5af6c: 48d7 040c moveml %d2-%d3/%a2,%sp@ 5af70: 242e 000c movel %fp@(12),%d2
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
5af74: 670a beqs 5af80 <pthread_kill+0x18>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
5af76: 2602 movel %d2,%d3 5af78: 5383 subql #1,%d3
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
5af7a: 701f moveq #31,%d0 5af7c: b083 cmpl %d3,%d0
5af7e: 640e bccs 5af8e <pthread_kill+0x26>
rtems_set_errno_and_return_minus_one( EINVAL );
5af80: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5af86: 7216 moveq #22,%d1 5af88: 2040 moveal %d0,%a0 5af8a: 2081 movel %d1,%a0@ 5af8c: 607a bras 5b008 <pthread_kill+0xa0>
the_thread = _Thread_Get( thread, &location );
5af8e: 486e fffc pea %fp@(-4) 5af92: 2f2e 0008 movel %fp@(8),%sp@- 5af96: 4eb9 0004 7ae8 jsr 47ae8 <_Thread_Get>
switch ( location ) {
5af9c: 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 );
5af9e: 2440 moveal %d0,%a2
switch ( location ) {
5afa0: 4aae fffc tstl %fp@(-4)
5afa4: 6656 bnes 5affc <pthread_kill+0x94> <== NEVER TAKEN
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
5afa6: 2202 movel %d2,%d1 5afa8: 2002 movel %d2,%d0 5afaa: e589 lsll #2,%d1 5afac: e988 lsll #4,%d0
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
5afae: 206a 0102 moveal %a2@(258),%a0
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
5afb2: 9081 subl %d1,%d0 5afb4: 0680 0005 ee6c addil #388716,%d0 5afba: 7201 moveq #1,%d1 5afbc: 2240 moveal %d0,%a1 5afbe: b291 cmpl %a1@,%d1
5afc0: 6730 beqs 5aff2 <pthread_kill+0x8a>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
5afc2: 7001 moveq #1,%d0 5afc4: e7a8 lsll %d3,%d0
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
5afc6: 81a8 00d4 orl %d0,%a0@(212)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
5afca: 42a7 clrl %sp@- 5afcc: 2f02 movel %d2,%sp@- 5afce: 2f0a movel %a2,%sp@- 5afd0: 4eb9 0005 ae6c jsr 5ae6c <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
5afd6: 4fef 000c lea %sp@(12),%sp 5afda: 4ab9 0005 ee2e tstl 5ee2e <_Per_CPU_Information+0x8>
5afe0: 6710 beqs 5aff2 <pthread_kill+0x8a>
5afe2: b5f9 0005 ee32 cmpal 5ee32 <_Per_CPU_Information+0xc>,%a2
5afe8: 6608 bnes 5aff2 <pthread_kill+0x8a> _Thread_Dispatch_necessary = true;
5afea: 7001 moveq #1,%d0 5afec: 13c0 0005 ee3e moveb %d0,5ee3e <_Per_CPU_Information+0x18>
}
_Thread_Enable_dispatch();
5aff2: 4eb9 0004 7ac2 jsr 47ac2 <_Thread_Enable_dispatch>
return 0;
5aff8: 4280 clrl %d0 5affa: 600e bras 5b00a <pthread_kill+0xa2>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
5affc: 4eb9 0004 cad0 jsr 4cad0 <__errno> <== NOT EXECUTED 5b002: 2040 moveal %d0,%a0 <== NOT EXECUTED 5b004: 7003 moveq #3,%d0 <== NOT EXECUTED 5b006: 2080 movel %d0,%a0@ <== NOT EXECUTED
5b008: 70ff moveq #-1,%d0
}
5b00a: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
5b010: 4e5e unlk %fp <== NOT EXECUTED
000475c4 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
475c4: 4e56 fffc linkw %fp,#-4 475c8: 2f03 movel %d3,%sp@- 475ca: 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 );
475cc: 486e fffc pea %fp@(-4) 475d0: 2f2e 000c movel %fp@(12),%sp@- 475d4: 4eb9 0004 76ac jsr 476ac <_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,
475da: 508f addql #8,%sp 475dc: 2400 movel %d0,%d2 475de: 7003 moveq #3,%d0 475e0: b082 cmpl %d2,%d0 475e2: 57c3 seq %d3
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
475e4: 2f2e fffc movel %fp@(-4),%sp@- 475e8: 4483 negl %d3 475ea: 4280 clrl %d0 475ec: 1003 moveb %d3,%d0 475ee: 2f00 movel %d0,%sp@- 475f0: 2f2e 0008 movel %fp@(8),%sp@- 475f4: 4eb9 0004 74cc jsr 474cc <_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) ) {
475fa: 4fef 000c lea %sp@(12),%sp 475fe: 4a03 tstb %d3
47600: 661c bnes 4761e <pthread_mutex_timedlock+0x5a>
47602: 7210 moveq #16,%d1 47604: b280 cmpl %d0,%d1
47606: 6616 bnes 4761e <pthread_mutex_timedlock+0x5a> <== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
47608: 4a82 tstl %d2
4760a: 670c beqs 47618 <pthread_mutex_timedlock+0x54> <== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
4760c: 5382 subql #1,%d2 4760e: 123c 0001 moveb #1,%d1 47612: b282 cmpl %d2,%d1
47614: 6508 bcss 4761e <pthread_mutex_timedlock+0x5a> <== NEVER TAKEN
47616: 6004 bras 4761c <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;
47618: 7016 moveq #22,%d0 <== NOT EXECUTED 4761a: 6002 bras 4761e <pthread_mutex_timedlock+0x5a> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
4761c: 7074 moveq #116,%d0
}
return lock_status;
}
4761e: 242e fff4 movel %fp@(-12),%d2 47622: 262e fff8 movel %fp@(-8),%d3 47626: 4e5e unlk %fp
...
0004547c <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
4547c: 4e56 0000 linkw %fp,#0 45480: 206e 0008 moveal %fp@(8),%a0 45484: 226e 000c moveal %fp@(12),%a1
if ( !attr )
45488: 4a88 tstl %a0
4548a: 6710 beqs 4549c <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !attr->is_initialized )
4548c: 4a90 tstl %a0@
4548e: 670c beqs 4549c <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !type )
45490: 4a89 tstl %a1
45492: 6708 beqs 4549c <pthread_mutexattr_gettype+0x20> <== NEVER TAKEN
return EINVAL;
*type = attr->type;
45494: 22a8 0010 movel %a0@(16),%a1@
return 0;
45498: 4280 clrl %d0 4549a: 6002 bras 4549e <pthread_mutexattr_gettype+0x22>
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
return EINVAL;
4549c: 7016 moveq #22,%d0
*type = attr->type;
return 0;
}
4549e: 4e5e unlk %fp
...
0004720c <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
4720c: 4e56 0000 linkw %fp,#0 47210: 206e 0008 moveal %fp@(8),%a0 47214: 202e 000c movel %fp@(12),%d0
if ( !attr || !attr->is_initialized )
47218: 4a88 tstl %a0
4721a: 6712 beqs 4722e <pthread_mutexattr_setpshared+0x22>
4721c: 4a90 tstl %a0@
4721e: 670e beqs 4722e <pthread_mutexattr_setpshared+0x22>
return EINVAL;
switch ( pshared ) {
47220: 7201 moveq #1,%d1 47222: b280 cmpl %d0,%d1
47224: 6508 bcss 4722e <pthread_mutexattr_setpshared+0x22><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
47226: 2140 0004 movel %d0,%a0@(4)
return 0;
4722a: 4280 clrl %d0 4722c: 6002 bras 47230 <pthread_mutexattr_setpshared+0x24>
default:
return EINVAL;
4722e: 7016 moveq #22,%d0
} }
47230: 4e5e unlk %fp <== NOT EXECUTED
000454d0 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
454d0: 4e56 0000 linkw %fp,#0 454d4: 206e 0008 moveal %fp@(8),%a0 454d8: 202e 000c movel %fp@(12),%d0
if ( !attr || !attr->is_initialized )
454dc: 4a88 tstl %a0
454de: 6712 beqs 454f2 <pthread_mutexattr_settype+0x22>
454e0: 4a90 tstl %a0@
454e2: 670e beqs 454f2 <pthread_mutexattr_settype+0x22> <== NEVER TAKEN
return EINVAL;
switch ( type ) {
454e4: 7203 moveq #3,%d1 454e6: b280 cmpl %d0,%d1
454e8: 6508 bcss 454f2 <pthread_mutexattr_settype+0x22>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
454ea: 2140 0010 movel %d0,%a0@(16)
return 0;
454ee: 4280 clrl %d0 454f0: 6002 bras 454f4 <pthread_mutexattr_settype+0x24>
default:
return EINVAL;
454f2: 7016 moveq #22,%d0
} }
454f4: 4e5e unlk %fp <== NOT EXECUTED
00045f6c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
45f6c: 4e56 fffc linkw %fp,#-4 45f70: 2f0b movel %a3,%sp@- 45f72: 266e 000c moveal %fp@(12),%a3 45f76: 2f0a movel %a2,%sp@- 45f78: 246e 0008 moveal %fp@(8),%a2
if ( !once_control || !init_routine )
45f7c: 4a8a tstl %a2
45f7e: 674a beqs 45fca <pthread_once+0x5e>
45f80: 4a8b tstl %a3
45f82: 6746 beqs 45fca <pthread_once+0x5e>
return EINVAL;
if ( !once_control->init_executed ) {
45f84: 4aaa 0004 tstl %a2@(4)
45f88: 6644 bnes 45fce <pthread_once+0x62>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
45f8a: 486e fffc pea %fp@(-4) 45f8e: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 45f92: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 45f96: 4eb9 0004 6a78 jsr 46a78 <rtems_task_mode>
if ( !once_control->init_executed ) {
45f9c: 4fef 000c lea %sp@(12),%sp 45fa0: 4aaa 0004 tstl %a2@(4)
45fa4: 660c bnes 45fb2 <pthread_once+0x46> <== NEVER TAKEN
once_control->is_initialized = true;
45fa6: 7001 moveq #1,%d0 45fa8: 2480 movel %d0,%a2@
once_control->init_executed = true;
45faa: 7001 moveq #1,%d0 45fac: 2540 0004 movel %d0,%a2@(4)
(*init_routine)();
45fb0: 4e93 jsr %a3@
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
45fb2: 486e fffc pea %fp@(-4) 45fb6: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 45fba: 2f2e fffc movel %fp@(-4),%sp@- 45fbe: 4eb9 0004 6a78 jsr 46a78 <rtems_task_mode> 45fc4: 4fef 000c lea %sp@(12),%sp 45fc8: 6004 bras 45fce <pthread_once+0x62>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
45fca: 7016 moveq #22,%d0 45fcc: 6002 bras 45fd0 <pthread_once+0x64>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
45fce: 4280 clrl %d0
}
45fd0: 246e fff4 moveal %fp@(-12),%a2 45fd4: 266e fff8 moveal %fp@(-8),%a3
45fd8: 4e5e unlk %fp <== NOT EXECUTED
00046748 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
46748: 4e56 ffe4 linkw %fp,#-28 4674c: 206e 000c moveal %fp@(12),%a0 46750: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 46754: 246e 0008 moveal %fp@(8),%a2
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
46758: 4a8a tstl %a2 4675a: 6700 0084 beqw 467e0 <pthread_rwlock_init+0x98>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
4675e: 4a88 tstl %a0
46760: 6614 bnes 46776 <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
46762: 240e movel %fp,%d2 46764: 0682 ffff fff4 addil #-12,%d2 4676a: 2f02 movel %d2,%sp@- 4676c: 4eb9 0004 7064 jsr 47064 <pthread_rwlockattr_init> 46772: 588f addql #4,%sp
the_attr = &default_attr;
46774: 2042 moveal %d2,%a0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
46776: 4a90 tstl %a0@
46778: 6766 beqs 467e0 <pthread_rwlock_init+0x98> <== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
4677a: 4aa8 0004 tstl %a0@(4)
4677e: 6660 bnes 467e0 <pthread_rwlock_init+0x98> <== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
46780: 2039 0006 161c movel 6161c <_Thread_Dispatch_disable_level>,%d0 46786: 5280 addql #1,%d0
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
46788: 42ae fffc clrl %fp@(-4) 4678c: 23c0 0006 161c movel %d0,6161c <_Thread_Dispatch_disable_level>
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
_Objects_Allocate( &_POSIX_RWLock_Information );
46792: 4879 0006 1784 pea 61784 <_POSIX_RWLock_Information> 46798: 49f9 0004 9b12 lea 49b12 <_Thread_Enable_dispatch>,%a4 4679e: 4eb9 0004 8b88 jsr 48b88 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
467a4: 588f addql #4,%sp 467a6: 2640 moveal %d0,%a3 467a8: 4a80 tstl %d0
467aa: 6606 bnes 467b2 <pthread_rwlock_init+0x6a>
_Thread_Enable_dispatch();
467ac: 4e94 jsr %a4@
return EAGAIN;
467ae: 700b moveq #11,%d0 467b0: 6030 bras 467e2 <pthread_rwlock_init+0x9a>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
467b2: 486e fffc pea %fp@(-4) 467b6: 486b 0010 pea %a3@(16) 467ba: 4eb9 0004 837c jsr 4837c <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
467c0: 202b 0008 movel %a3@(8),%d0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
467c4: 4281 clrl %d1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
467c6: 2079 0006 179c moveal 6179c <_POSIX_RWLock_Information+0x18>,%a0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
467cc: 3200 movew %d0,%d1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
467ce: 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;
467d2: 42ab 000c clrl %a3@(12)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
467d6: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
467d8: 4e94 jsr %a4@
return 0;
467da: 508f addql #8,%sp 467dc: 4280 clrl %d0 467de: 6002 bras 467e2 <pthread_rwlock_init+0x9a>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
467e0: 7016 moveq #22,%d0
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
467e2: 4cee 1c04 ffe4 moveml %fp@(-28),%d2/%a2-%a4
467e8: 4e5e unlk %fp <== NOT EXECUTED
000467ec <pthread_rwlock_rdlock>:
*/
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
467ec: 4e56 fffc linkw %fp,#-4 467f0: 2f0a movel %a2,%sp@- 467f2: 246e 0008 moveal %fp@(8),%a2
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
467f6: 4a8a tstl %a2
467f8: 674e beqs 46848 <pthread_rwlock_rdlock+0x5c> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
467fa: 486e fffc pea %fp@(-4) 467fe: 2f12 movel %a2@,%sp@- 46800: 4879 0006 1784 pea 61784 <_POSIX_RWLock_Information> 46806: 4eb9 0004 8fdc jsr 48fdc <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
4680c: 4fef 000c lea %sp@(12),%sp 46810: 4aae fffc tstl %fp@(-4)
46814: 6632 bnes 46848 <pthread_rwlock_rdlock+0x5c>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
46816: 42a7 clrl %sp@- 46818: 2040 moveal %d0,%a0 4681a: 42a7 clrl %sp@- 4681c: 4878 0001 pea 1 <ADD> 46820: 2f12 movel %a2@,%sp@- 46822: 4868 0010 pea %a0@(16) 46826: 4eb9 0004 83b0 jsr 483b0 <_CORE_RWLock_Obtain_for_reading>
true, /* we are willing to wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
4682c: 4eb9 0004 9b12 jsr 49b12 <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
46832: 2079 0006 1a86 moveal 61a86 <_Per_CPU_Information+0xc>,%a0
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
46838: 2f28 0034 movel %a0@(52),%sp@- 4683c: 4eb9 0004 69ac jsr 469ac <_POSIX_RWLock_Translate_core_RWLock_return_code> 46842: 4fef 0018 lea %sp@(24),%sp 46846: 6002 bras 4684a <pthread_rwlock_rdlock+0x5e>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
46848: 7016 moveq #22,%d0
}
4684a: 246e fff8 moveal %fp@(-8),%a2 4684e: 4e5e unlk %fp
...
00046854 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
46854: 4e56 ffec linkw %fp,#-20 46858: 48d7 040c moveml %d2-%d3/%a2,%sp@ 4685c: 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 )
46860: 4a8a tstl %a2 46862: 6700 008c beqw 468f0 <pthread_rwlock_timedrdlock+0x9c>
* * 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 );
46866: 486e fff8 pea %fp@(-8) 4686a: 2f2e 000c movel %fp@(12),%sp@- 4686e: 4eb9 0004 c430 jsr 4c430 <_POSIX_Absolute_timeout_to_ticks> 46874: 486e fffc pea %fp@(-4) 46878: 2400 movel %d0,%d2 4687a: 2f12 movel %a2@,%sp@- 4687c: 4879 0006 1784 pea 61784 <_POSIX_RWLock_Information> 46882: 4eb9 0004 8fdc jsr 48fdc <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
46888: 4fef 0014 lea %sp@(20),%sp 4688c: 4aae fffc tstl %fp@(-4)
46890: 665e bnes 468f0 <pthread_rwlock_timedrdlock+0x9c> 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,
46892: 7203 moveq #3,%d1 46894: b282 cmpl %d2,%d1 46896: 57c3 seq %d3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
46898: 42a7 clrl %sp@- 4689a: 2f2e fff8 movel %fp@(-8),%sp@- 4689e: 4483 negl %d3 468a0: 4281 clrl %d1 468a2: 1203 moveb %d3,%d1 468a4: 2040 moveal %d0,%a0 468a6: 2f01 movel %d1,%sp@- 468a8: 2f12 movel %a2@,%sp@- 468aa: 4868 0010 pea %a0@(16) 468ae: 4eb9 0004 83b0 jsr 483b0 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
468b4: 4eb9 0004 9b12 jsr 49b12 <_Thread_Enable_dispatch>
if ( !do_wait ) {
468ba: 4fef 0014 lea %sp@(20),%sp 468be: 4a03 tstb %d3
468c0: 661a bnes 468dc <pthread_rwlock_timedrdlock+0x88>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
468c2: 2079 0006 1a86 moveal 61a86 <_Per_CPU_Information+0xc>,%a0 468c8: 7002 moveq #2,%d0 468ca: b0a8 0034 cmpl %a0@(52),%d0
468ce: 660c bnes 468dc <pthread_rwlock_timedrdlock+0x88> if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
468d0: 4a82 tstl %d2
468d2: 671c beqs 468f0 <pthread_rwlock_timedrdlock+0x9c><== NEVER TAKEN
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
468d4: 5382 subql #1,%d2 468d6: 7201 moveq #1,%d1 468d8: b282 cmpl %d2,%d1
468da: 6418 bccs 468f4 <pthread_rwlock_timedrdlock+0xa0><== ALWAYS TAKEN
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
468dc: 2079 0006 1a86 moveal 61a86 <_Per_CPU_Information+0xc>,%a0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
468e2: 2f28 0034 movel %a0@(52),%sp@- 468e6: 4eb9 0004 69ac jsr 469ac <_POSIX_RWLock_Translate_core_RWLock_return_code> 468ec: 588f addql #4,%sp 468ee: 6006 bras 468f6 <pthread_rwlock_timedrdlock+0xa2>
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
468f0: 7016 moveq #22,%d0 468f2: 6002 bras 468f6 <pthread_rwlock_timedrdlock+0xa2>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
468f4: 7074 moveq #116,%d0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
468f6: 4cee 040c ffec moveml %fp@(-20),%d2-%d3/%a2
468fc: 4e5e unlk %fp <== NOT EXECUTED
00046900 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
46900: 4e56 ffec linkw %fp,#-20 46904: 48d7 040c moveml %d2-%d3/%a2,%sp@ 46908: 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 )
4690c: 4a8a tstl %a2 4690e: 6700 008c beqw 4699c <pthread_rwlock_timedwrlock+0x9c>
* * 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 );
46912: 486e fff8 pea %fp@(-8) 46916: 2f2e 000c movel %fp@(12),%sp@- 4691a: 4eb9 0004 c430 jsr 4c430 <_POSIX_Absolute_timeout_to_ticks> 46920: 486e fffc pea %fp@(-4) 46924: 2400 movel %d0,%d2 46926: 2f12 movel %a2@,%sp@- 46928: 4879 0006 1784 pea 61784 <_POSIX_RWLock_Information> 4692e: 4eb9 0004 8fdc jsr 48fdc <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
46934: 4fef 0014 lea %sp@(20),%sp 46938: 4aae fffc tstl %fp@(-4)
4693c: 665e bnes 4699c <pthread_rwlock_timedwrlock+0x9c>
(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,
4693e: 7203 moveq #3,%d1 46940: b282 cmpl %d2,%d1 46942: 57c3 seq %d3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
46944: 42a7 clrl %sp@- 46946: 2f2e fff8 movel %fp@(-8),%sp@- 4694a: 4483 negl %d3 4694c: 4281 clrl %d1 4694e: 1203 moveb %d3,%d1 46950: 2040 moveal %d0,%a0 46952: 2f01 movel %d1,%sp@- 46954: 2f12 movel %a2@,%sp@- 46956: 4868 0010 pea %a0@(16) 4695a: 4eb9 0004 8460 jsr 48460 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
46960: 4eb9 0004 9b12 jsr 49b12 <_Thread_Enable_dispatch>
if ( !do_wait &&
46966: 4fef 0014 lea %sp@(20),%sp 4696a: 4a03 tstb %d3
4696c: 661a bnes 46988 <pthread_rwlock_timedwrlock+0x88>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
4696e: 2079 0006 1a86 moveal 61a86 <_Per_CPU_Information+0xc>,%a0
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
46974: 7002 moveq #2,%d0 46976: b0a8 0034 cmpl %a0@(52),%d0
4697a: 660c bnes 46988 <pthread_rwlock_timedwrlock+0x88>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
4697c: 4a82 tstl %d2
4697e: 671c beqs 4699c <pthread_rwlock_timedwrlock+0x9c><== NEVER TAKEN
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
46980: 5382 subql #1,%d2 46982: 7201 moveq #1,%d1 46984: b282 cmpl %d2,%d1
46986: 6418 bccs 469a0 <pthread_rwlock_timedwrlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
46988: 2079 0006 1a86 moveal 61a86 <_Per_CPU_Information+0xc>,%a0
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
4698e: 2f28 0034 movel %a0@(52),%sp@- 46992: 4eb9 0004 69ac jsr 469ac <_POSIX_RWLock_Translate_core_RWLock_return_code> 46998: 588f addql #4,%sp 4699a: 6006 bras 469a2 <pthread_rwlock_timedwrlock+0xa2>
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
4699c: 7016 moveq #22,%d0 4699e: 6002 bras 469a2 <pthread_rwlock_timedwrlock+0xa2>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
469a0: 7074 moveq #116,%d0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
469a2: 4cee 040c ffec moveml %fp@(-20),%d2-%d3/%a2
469a8: 4e5e unlk %fp <== NOT EXECUTED
00047084 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
47084: 4e56 0000 linkw %fp,#0 47088: 206e 0008 moveal %fp@(8),%a0 4708c: 202e 000c movel %fp@(12),%d0
if ( !attr )
47090: 4a88 tstl %a0
47092: 6712 beqs 470a6 <pthread_rwlockattr_setpshared+0x22>
return EINVAL;
if ( !attr->is_initialized )
47094: 4a90 tstl %a0@
47096: 670e beqs 470a6 <pthread_rwlockattr_setpshared+0x22>
return EINVAL;
switch ( pshared ) {
47098: 7201 moveq #1,%d1 4709a: b280 cmpl %d0,%d1
4709c: 6508 bcss 470a6 <pthread_rwlockattr_setpshared+0x22><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
4709e: 2140 0004 movel %d0,%a0@(4)
return 0;
470a2: 4280 clrl %d0 470a4: 6002 bras 470a8 <pthread_rwlockattr_setpshared+0x24>
default:
return EINVAL;
470a6: 7016 moveq #22,%d0
} }
470a8: 4e5e unlk %fp <== NOT EXECUTED
00047dc8 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
47dc8: 4e56 ffe0 linkw %fp,#-32 47dcc: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 47dd0: 242e 000c movel %fp@(12),%d2 47dd4: 282e 0010 movel %fp@(16),%d4
int rc;
/*
* Check all the parameters
*/
if ( !param )
47dd8: 6700 00d8 beqw 47eb2 <pthread_setschedparam+0xea>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
47ddc: 486e fff8 pea %fp@(-8) 47de0: 486e fffc pea %fp@(-4) 47de4: 2f04 movel %d4,%sp@- 47de6: 2f02 movel %d2,%sp@- 47de8: 4eb9 0004 d2a4 jsr 4d2a4 <_POSIX_Thread_Translate_sched_param>
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
47dee: 4fef 0010 lea %sp@(16),%sp
* Check all the parameters
*/
if ( !param )
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
47df2: 2600 movel %d0,%d3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
47df4: 6600 00c2 bnew 47eb8 <pthread_setschedparam+0xf0>
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
47df8: 486e fff4 pea %fp@(-12) 47dfc: 2f2e 0008 movel %fp@(8),%sp@- 47e00: 4eb9 0004 a6e8 jsr 4a6e8 <_Thread_Get>
switch ( location ) {
47e06: 508f addql #8,%sp
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
47e08: 2640 moveal %d0,%a3
switch ( location ) {
47e0a: 4aae fff4 tstl %fp@(-12) 47e0e: 6600 00a6 bnew 47eb6 <pthread_setschedparam+0xee>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
47e12: 246b 0102 moveal %a3@(258),%a2
if ( api->schedpolicy == SCHED_SPORADIC )
47e16: 7004 moveq #4,%d0 47e18: b0aa 0084 cmpl %a2@(132),%d0
47e1c: 660c bnes 47e2a <pthread_setschedparam+0x62>
(void) _Watchdog_Remove( &api->Sporadic_timer );
47e1e: 486a 00a8 pea %a2@(168) 47e22: 4eb9 0004 b5ec jsr 4b5ec <_Watchdog_Remove> 47e28: 588f addql #4,%sp
api->schedpolicy = policy;
47e2a: 2542 0084 movel %d2,%a2@(132)
api->schedparam = *param;
47e2e: 4878 001c pea 1c <OPER2+0x8> 47e32: 2f04 movel %d4,%sp@- 47e34: 486a 0088 pea %a2@(136) 47e38: 4eb9 0004 fe38 jsr 4fe38 <memcpy>
the_thread->budget_algorithm = budget_algorithm;
47e3e: 276e fffc 007a movel %fp@(-4),%a3@(122)
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
47e44: 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;
47e48: 276e fff8 007e movel %fp@(-8),%a3@(126)
switch ( api->schedpolicy ) {
47e4e: 4a82 tstl %d2
47e50: 6d58 blts 47eaa <pthread_setschedparam+0xe2> <== NEVER TAKEN
47e52: 7002 moveq #2,%d0 47e54: b082 cmpl %d2,%d0
47e56: 6c0a bges 47e62 <pthread_setschedparam+0x9a>
47e58: 103c 0004 moveb #4,%d0 47e5c: b082 cmpl %d2,%d0
47e5e: 664a bnes 47eaa <pthread_setschedparam+0xe2> <== NEVER TAKEN
47e60: 602a bras 47e8c <pthread_setschedparam+0xc4> 47e62: 4280 clrl %d0 47e64: 1039 0006 1bf6 moveb 61bf6 <rtems_maximum_priority>,%d0
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
47e6a: 41f9 0006 34d0 lea 634d0 <_Thread_Ticks_per_timeslice>,%a0 47e70: 90aa 0088 subl %a2@(136),%d0 47e74: 2750 0076 movel %a0@,%a3@(118)
the_thread->real_priority =
47e78: 2740 0018 movel %d0,%a3@(24)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
47e7c: 4878 0001 pea 1 <ADD> 47e80: 2f00 movel %d0,%sp@- 47e82: 2f0b movel %a3,%sp@- 47e84: 4eb9 0004 a2a4 jsr 4a2a4 <_Thread_Change_priority> 47e8a: 601a bras 47ea6 <pthread_setschedparam+0xde>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
47e8c: 256a 0088 00a4 movel %a2@(136),%a2@(164)
_Watchdog_Remove( &api->Sporadic_timer );
47e92: 486a 00a8 pea %a2@(168) 47e96: 4eb9 0004 b5ec jsr 4b5ec <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
47e9c: 2f0b movel %a3,%sp@- 47e9e: 42a7 clrl %sp@- 47ea0: 4eb9 0004 7ca4 jsr 47ca4 <_POSIX_Threads_Sporadic_budget_TSR>
break;
47ea6: 4fef 000c lea %sp@(12),%sp
}
_Thread_Enable_dispatch();
47eaa: 4eb9 0004 a6c2 jsr 4a6c2 <_Thread_Enable_dispatch>
return 0;
47eb0: 6006 bras 47eb8 <pthread_setschedparam+0xf0>
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
47eb2: 7616 moveq #22,%d3 47eb4: 6002 bras 47eb8 <pthread_setschedparam+0xf0>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
47eb6: 7603 moveq #3,%d3
}
47eb8: 2003 movel %d3,%d0 47eba: 4cee 0c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a3
47ec0: 4e5e unlk %fp <== NOT EXECUTED
00045d54 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
45d54: 4e56 0000 linkw %fp,#0 45d58: 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() )
45d5a: 4ab9 0005 fd58 tstl 5fd58 <_Per_CPU_Information+0x8>
45d60: 6646 bnes 45da8 <pthread_testcancel+0x54> <== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
45d62: 2079 0005 fd5c moveal 5fd5c <_Per_CPU_Information+0xc>,%a0 45d68: 2039 0005 f8f2 movel 5f8f2 <_Thread_Dispatch_disable_level>,%d0 45d6e: 5280 addql #1,%d0 45d70: 2068 0102 moveal %a0@(258),%a0 45d74: 23c0 0005 f8f2 movel %d0,5f8f2 <_Thread_Dispatch_disable_level>
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
45d7a: 4aa8 00d8 tstl %a0@(216)
45d7e: 660a bnes 45d8a <pthread_testcancel+0x36> <== 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));
45d80: 4aa8 00e0 tstl %a0@(224) 45d84: 56c2 sne %d2 45d86: 4482 negl %d2 45d88: 6002 bras 45d8c <pthread_testcancel+0x38>
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
45d8a: 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();
45d8c: 4eb9 0004 850e jsr 4850e <_Thread_Enable_dispatch>
if ( cancel )
45d92: 4a02 tstb %d2
45d94: 6712 beqs 45da8 <pthread_testcancel+0x54>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
45d96: 4878 ffff pea ffffffff <LESS> 45d9a: 2f39 0005 fd5c movel 5fd5c <_Per_CPU_Information+0xc>,%sp@- 45da0: 4eb9 0004 b1c8 jsr 4b1c8 <_POSIX_Thread_Exit>
45da6: 508f addql #8,%sp <== NOT EXECUTED
}
45da8: 242e fffc movel %fp@(-4),%d2
45dac: 4e5e unlk %fp <== NOT EXECUTED
0005a99c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
5a99c: 4e56 fff4 linkw %fp,#-12 5a9a0: 202e 0008 movel %fp@(8),%d0 5a9a4: 222e 000c movel %fp@(12),%d1 5a9a8: 206e 0010 moveal %fp@(16),%a0 5a9ac: 48d7 040c moveml %d2-%d3/%a2,%sp@
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
5a9b0: b0b9 0005 cff4 cmpl 5cff4 <rtems_libio_number_iops>,%d0
5a9b6: 641a bccs 5a9d2 <read+0x36> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
5a9b8: 2400 movel %d0,%d2 5a9ba: ed88 lsll #6,%d0 5a9bc: e78a lsll #3,%d2 5a9be: 2479 0005 e874 moveal 5e874 <rtems_libio_iops>,%a2 5a9c4: 9082 subl %d2,%d0 5a9c6: d5c0 addal %d0,%a2
rtems_libio_check_is_open( iop );
5a9c8: 202a 0014 movel %a2@(20),%d0 5a9cc: 0800 0008 btst #8,%d0
5a9d0: 660e bnes 5a9e0 <read+0x44>
5a9d2: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5a9d8: 7209 moveq #9,%d1 5a9da: 2040 moveal %d0,%a0 5a9dc: 2081 movel %d1,%a0@ 5a9de: 601a bras 5a9fa <read+0x5e>
rtems_libio_check_buffer( buffer );
5a9e0: 4a81 tstl %d1
5a9e2: 670a beqs 5a9ee <read+0x52> <== NEVER TAKEN
rtems_libio_check_count( count );
5a9e4: 4a88 tstl %a0
5a9e6: 6744 beqs 5aa2c <read+0x90> rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
5a9e8: 0800 0001 btst #1,%d0
5a9ec: 6610 bnes 5a9fe <read+0x62>
5a9ee: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5a9f4: 2040 moveal %d0,%a0 5a9f6: 7016 moveq #22,%d0 5a9f8: 2080 movel %d0,%a0@ 5a9fa: 70ff moveq #-1,%d0 5a9fc: 6030 bras 5aa2e <read+0x92>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
5a9fe: 226a 0020 moveal %a2@(32),%a1 5aa02: 2f08 movel %a0,%sp@- 5aa04: 2f01 movel %d1,%sp@- 5aa06: 2f0a movel %a2,%sp@- 5aa08: 2069 0008 moveal %a1@(8),%a0 5aa0c: 4e90 jsr %a0@
if ( rc > 0 )
5aa0e: 4fef 000c lea %sp@(12),%sp 5aa12: 4a80 tstl %d0
5aa14: 6f18 bles 5aa2e <read+0x92>
iop->offset += rc;
5aa16: 2400 movel %d0,%d2 5aa18: 5bc1 smi %d1 5aa1a: 49c1 extbl %d1 5aa1c: d5aa 0010 addl %d2,%a2@(16) 5aa20: 262a 000c movel %a2@(12),%d3 5aa24: d781 addxl %d1,%d3 5aa26: 2543 000c movel %d3,%a2@(12) 5aa2a: 6002 bras 5aa2e <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 );
5aa2c: 4280 clrl %d0
if ( rc > 0 )
iop->offset += rc;
return rc;
}
5aa2e: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
5aa34: 4e5e unlk %fp <== NOT EXECUTED
00045700 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
45700: 4e56 ffe0 linkw %fp,#-32 45704: 48d7 040c moveml %d2-%d3/%a2,%sp@ 45708: 246e 0008 moveal %fp@(8),%a2 4570c: 262e 000c movel %fp@(12),%d3
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
45710: 660e bnes 45720 <readlink+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
45712: 4eb9 0004 f354 jsr 4f354 <__errno> 45718: 720e moveq #14,%d1 4571a: 2040 moveal %d0,%a0 4571c: 2081 movel %d1,%a0@ 4571e: 6076 bras 45796 <readlink+0x96>
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
45720: 2f0a movel %a2,%sp@- 45722: 240e movel %fp,%d2 45724: 0682 ffff ffec addil #-20,%d2 4572a: 4eb9 0005 0e94 jsr 50e94 <strlen> 45730: 4297 clrl %sp@ 45732: 2f02 movel %d2,%sp@- 45734: 42a7 clrl %sp@- 45736: 2f00 movel %d0,%sp@- 45738: 2f0a movel %a2,%sp@- 4573a: 4eb9 0004 46bc jsr 446bc <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
45740: 4fef 0014 lea %sp@(20),%sp 45744: 4a80 tstl %d0
45746: 664e bnes 45796 <readlink+0x96> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
45748: 206e fff8 moveal %fp@(-8),%a0 4574c: 45f9 0004 4788 lea 44788 <rtems_filesystem_freenode>,%a2 45752: 2f02 movel %d2,%sp@- 45754: 2068 0010 moveal %a0@(16),%a0 45758: 4e90 jsr %a0@ 4575a: 588f addql #4,%sp 4575c: 7204 moveq #4,%d1 4575e: b280 cmpl %d0,%d1
45760: 6714 beqs 45776 <readlink+0x76>
rtems_filesystem_freenode( &loc );
45762: 2f02 movel %d2,%sp@- 45764: 4e92 jsr %a2@
rtems_set_errno_and_return_minus_one( EINVAL );
45766: 4eb9 0004 f354 jsr 4f354 <__errno> 4576c: 588f addql #4,%sp 4576e: 2040 moveal %d0,%a0 45770: 7016 moveq #22,%d0 45772: 2080 movel %d0,%a0@ 45774: 6020 bras 45796 <readlink+0x96>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
45776: 2f2e 0010 movel %fp@(16),%sp@- 4577a: 206e fff8 moveal %fp@(-8),%a0 4577e: 2f03 movel %d3,%sp@- 45780: 2f02 movel %d2,%sp@- 45782: 2068 003c moveal %a0@(60),%a0 45786: 4e90 jsr %a0@ 45788: 2600 movel %d0,%d3
rtems_filesystem_freenode( &loc );
4578a: 2f02 movel %d2,%sp@- 4578c: 4e92 jsr %a2@
return result;
4578e: 4fef 0010 lea %sp@(16),%sp 45792: 2003 movel %d3,%d0 45794: 6002 bras 45798 <readlink+0x98>
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
return -1;
45796: 70ff moveq #-1,%d0
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
45798: 4cee 040c ffe0 moveml %fp@(-32),%d2-%d3/%a2 4579e: 4e5e unlk %fp
...
000444f8 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
444f8: 4e56 ffe4 linkw %fp,#-28 444fc: 202e 0008 movel %fp@(8),%d0 44500: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@ 44504: 246e 000c moveal %fp@(12),%a2 44508: 262e 0010 movel %fp@(16),%d3
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
4450c: b0b9 0005 da64 cmpl 5da64 <rtems_libio_number_iops>,%d0
44512: 641a bccs 4452e <readv+0x36> iop = rtems_libio_iop( fd );
44514: 2200 movel %d0,%d1 44516: ed88 lsll #6,%d0 44518: e789 lsll #3,%d1 4451a: 2679 0005 f2e4 moveal 5f2e4 <rtems_libio_iops>,%a3 44520: 9081 subl %d1,%d0 44522: d7c0 addal %d0,%a3
rtems_libio_check_is_open( iop );
44524: 202b 0014 movel %a3@(20),%d0 44528: 0800 0008 btst #8,%d0
4452c: 6610 bnes 4453e <readv+0x46>
4452e: 4eb9 0004 d74c jsr 4d74c <__errno> 44534: 7209 moveq #9,%d1 44536: 2040 moveal %d0,%a0 44538: 2081 movel %d1,%a0@ 4453a: 6000 009e braw 445da <readv+0xe2>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
4453e: 0800 0001 btst #1,%d0
44542: 672c beqs 44570 <readv+0x78> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
44544: 4a8a tstl %a2
44546: 6728 beqs 44570 <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
44548: 4a83 tstl %d3
4454a: 6f24 bles 44570 <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
4454c: 0c83 0000 0400 cmpil #1024,%d3
44552: 6e1c bgts 44570 <readv+0x78> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
44554: 204a moveal %a2,%a0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
44556: 93c9 subal %a1,%a1 44558: 4281 clrl %d1 4455a: 7001 moveq #1,%d0 4455c: 6002 bras 44560 <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;
4455e: 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 )
44560: 4a90 tstl %a0@
44562: 670c beqs 44570 <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
44564: 2428 0004 movel %a0@(4),%d2 44568: 2801 movel %d1,%d4 4456a: d882 addl %d2,%d4
if ( total < old )
4456c: b284 cmpl %d4,%d1
4456e: 6f0e bles 4457e <readv+0x86>
rtems_set_errno_and_return_minus_one( EINVAL );
44570: 4eb9 0004 d74c jsr 4d74c <__errno> 44576: 2040 moveal %d0,%a0 44578: 7016 moveq #22,%d0 4457a: 2080 movel %d0,%a0@ 4457c: 605c bras 445da <readv+0xe2>
if ( iov[v].iov_len )
all_zeros = false;
4457e: 4a82 tstl %d2 44580: 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++ ) {
44582: 5289 addql #1,%a1 44584: 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;
44586: 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++ ) {
44588: b689 cmpl %a1,%d3
4458a: 6ed2 bgts 4455e <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 ) {
4458c: 4a00 tstb %d0
4458e: 6646 bnes 445d6 <readv+0xde>
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
44590: 588a addql #4,%a2 44592: 4284 clrl %d4 44594: 4282 clrl %d2
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
44596: 206b 0020 moveal %a3@(32),%a0 4459a: 2f12 movel %a2@,%sp@- 4459c: 2f2a fffc movel %a2@(-4),%sp@- 445a0: 2f0b movel %a3,%sp@- 445a2: 2068 0008 moveal %a0@(8),%a0 445a6: 4e90 jsr %a0@
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
445a8: 4fef 000c lea %sp@(12),%sp 445ac: 4a80 tstl %d0
445ae: 6d2a blts 445da <readv+0xe2> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
445b0: 6716 beqs 445c8 <readv+0xd0> <== NEVER TAKEN
iop->offset += bytes;
total += bytes;
445b2: d480 addl %d0,%d2
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
445b4: 2c00 movel %d0,%d6 445b6: 5bc5 smi %d5 445b8: 49c5 extbl %d5 445ba: ddab 0010 addl %d6,%a3@(16) 445be: 222b 000c movel %a3@(12),%d1 445c2: d385 addxl %d5,%d1 445c4: 2741 000c movel %d1,%a3@(12)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
445c8: b092 cmpl %a2@,%d0
445ca: 6610 bnes 445dc <readv+0xe4> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
445cc: 5284 addql #1,%d4 445ce: 508a addql #8,%a2 445d0: b684 cmpl %d4,%d3
445d2: 6ec2 bgts 44596 <readv+0x9e>
445d4: 6006 bras 445dc <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;
445d6: 4282 clrl %d2 445d8: 6002 bras 445dc <readv+0xe4>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
445da: 74ff moveq #-1,%d2
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
445dc: 2002 movel %d2,%d0 445de: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
445e4: 4e5e unlk %fp <== NOT EXECUTED
0005aabc <realloc>:
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
5aabc: 7003 moveq #3,%d0
void *realloc(
void *ptr,
size_t size
)
{
5aabe: 4e56 fff0 linkw %fp,#-16
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
5aac2: 52b9 0005 e89c addql #1,5e89c <rtems_malloc_statistics+0x10>
void *realloc(
void *ptr,
size_t size
)
{
5aac8: 48d7 001c moveml %d2-%d4,%sp@ 5aacc: 242e 0008 movel %fp@(8),%d2 5aad0: 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())) {
5aad4: b0b9 0005 eb14 cmpl 5eb14 <_System_state_Current>,%d0
5aada: 6614 bnes 5aaf0 <realloc+0x34> <== NEVER TAKEN
if (_Thread_Dispatch_disable_level > 0)
5aadc: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0 5aae2: 6600 00aa bnew 5ab8e <realloc+0xd2>
return (void *) 0;
if (_ISR_Nest_level > 0)
5aae6: 4ab9 0005 ee2e tstl 5ee2e <_Per_CPU_Information+0x8> 5aaec: 6600 00a0 bnew 5ab8e <realloc+0xd2>
}
/*
* Continue with realloc().
*/
if ( !ptr )
5aaf0: 4a82 tstl %d2
5aaf2: 6610 bnes 5ab04 <realloc+0x48>
return malloc( size );
5aaf4: 2f03 movel %d3,%sp@- 5aaf6: 4eb9 0004 2cd4 jsr 42cd4 <malloc> 5aafc: 588f addql #4,%sp 5aafe: 2400 movel %d0,%d2 5ab00: 6000 008e braw 5ab90 <realloc+0xd4>
if ( !size ) {
5ab04: 4a83 tstl %d3
5ab06: 660c bnes 5ab14 <realloc+0x58> <== ALWAYS TAKEN
free( ptr );
5ab08: 2f02 movel %d2,%sp@- <== NOT EXECUTED 5ab0a: 4eb9 0004 29ec jsr 429ec <free> <== NOT EXECUTED
return (void *) 0;
5ab10: 588f addql #4,%sp <== NOT EXECUTED 5ab12: 607a bras 5ab8e <realloc+0xd2> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
5ab14: 486e fffc pea %fp@(-4) 5ab18: 2f02 movel %d2,%sp@- 5ab1a: 2f39 0005 d030 movel 5d030 <RTEMS_Malloc_Heap>,%sp@- 5ab20: 4eb9 0005 b028 jsr 5b028 <_Protected_heap_Get_block_size> 5ab26: 4fef 000c lea %sp@(12),%sp 5ab2a: 4a00 tstb %d0
5ab2c: 660e bnes 5ab3c <realloc+0x80>
errno = EINVAL;
5ab2e: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5ab34: 2040 moveal %d0,%a0 5ab36: 7016 moveq #22,%d0 5ab38: 2080 movel %d0,%a0@ 5ab3a: 6052 bras 5ab8e <realloc+0xd2>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
5ab3c: 2f03 movel %d3,%sp@- 5ab3e: 2f02 movel %d2,%sp@- 5ab40: 2f39 0005 d030 movel 5d030 <RTEMS_Malloc_Heap>,%sp@- 5ab46: 4eb9 0005 b064 jsr 5b064 <_Protected_heap_Resize_block> 5ab4c: 4fef 000c lea %sp@(12),%sp 5ab50: 4a00 tstb %d0
5ab52: 663c bnes 5ab90 <realloc+0xd4>
* 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 );
5ab54: 2f03 movel %d3,%sp@- 5ab56: 4eb9 0004 2cd4 jsr 42cd4 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
5ab5c: 588f addql #4,%sp
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
5ab5e: 53b9 0005 e890 subql #1,5e890 <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 );
5ab64: 2800 movel %d0,%d4
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
5ab66: 6726 beqs 5ab8e <realloc+0xd2>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
5ab68: 202e fffc movel %fp@(-4),%d0 5ab6c: b083 cmpl %d3,%d0
5ab6e: 6402 bccs 5ab72 <realloc+0xb6> <== NEVER TAKEN
5ab70: 2600 movel %d0,%d3 5ab72: 2f03 movel %d3,%sp@- 5ab74: 2f02 movel %d2,%sp@- 5ab76: 2f04 movel %d4,%sp@- 5ab78: 4eb9 0004 d37c jsr 4d37c <memcpy>
free( ptr );
5ab7e: 2f02 movel %d2,%sp@-
return new_area;
5ab80: 2404 movel %d4,%d2
if ( !new_area ) {
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
5ab82: 4eb9 0004 29ec jsr 429ec <free>
return new_area;
5ab88: 4fef 0010 lea %sp@(16),%sp 5ab8c: 6002 bras 5ab90 <realloc+0xd4>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
5ab8e: 4282 clrl %d2
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
5ab90: 2002 movel %d2,%d0 5ab92: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
5ab98: 4e5e unlk %fp <== NOT EXECUTED
00043afc <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
43afc: 4e56 ffbc linkw %fp,#-68 43b00: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 43b04: 246e 0008 moveal %fp@(8),%a2
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
43b08: 2f0a movel %a2,%sp@- 43b0a: 4eb9 0004 2d90 jsr 42d90 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
43b10: 588f addql #4,%sp
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
43b12: 2a00 movel %d0,%d5 43b14: 200e movel %fp,%d0 43b16: 0680 ffff ffe8 addil #-24,%d0
if ( parentpathlen == 0 )
43b1c: 4a85 tstl %d5
43b1e: 6616 bnes 43b36 <rmdir+0x3a>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
43b20: 2f00 movel %d0,%sp@- 43b22: 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;
43b26: 4204 clrb %d4
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
43b28: 2f0a movel %a2,%sp@- 43b2a: 4eb9 0004 3c20 jsr 43c20 <rtems_filesystem_get_start_loc> 43b30: 4fef 000c lea %sp@(12),%sp 43b34: 601e bras 43b54 <rmdir+0x58>
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
43b36: 42a7 clrl %sp@- 43b38: 2f00 movel %d0,%sp@- 43b3a: 4878 0002 pea 2 <DOUBLE_FLOAT> 43b3e: 2f05 movel %d5,%sp@- 43b40: 2f0a movel %a2,%sp@- 43b42: 4eb9 0004 2d44 jsr 42d44 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
43b48: 4fef 0014 lea %sp@(20),%sp 43b4c: 4a80 tstl %d0 43b4e: 6600 00c2 bnew 43c12 <rmdir+0x116>
return -1;
free_parentloc = true;
43b52: 7801 moveq #1,%d4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
43b54: 4878 0014 pea 14 <OPER2> 43b58: 260e movel %fp,%d3 43b5a: 0683 ffff ffe8 addil #-24,%d3 43b60: 240e movel %fp,%d2 43b62: 0682 ffff ffd4 addil #-44,%d2
name = pathname + parentpathlen;
43b68: d5c5 addal %d5,%a2
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
43b6a: 47f9 0004 e624 lea 4e624 <strlen>,%a3
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
43b70: 2f03 movel %d3,%sp@- 43b72: 2f02 movel %d2,%sp@- 43b74: 4eb9 0004 db2c jsr 4db2c <memcpy>
name = pathname + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
43b7a: 2f0a movel %a2,%sp@- 43b7c: 4e93 jsr %a3@ 43b7e: 2e80 movel %d0,%sp@ 43b80: 2f0a movel %a2,%sp@- 43b82: 4eb9 0004 2dd2 jsr 42dd2 <rtems_filesystem_prefix_separators> 43b88: d5c0 addal %d0,%a2
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
43b8a: 2f0a movel %a2,%sp@- 43b8c: 4e93 jsr %a3@ 43b8e: 4297 clrl %sp@ 43b90: 2f02 movel %d2,%sp@- 43b92: 42a7 clrl %sp@- 43b94: 2f00 movel %d0,%sp@- 43b96: 2f0a movel %a2,%sp@- 43b98: 4eb9 0004 2cd4 jsr 42cd4 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
43b9e: 4fef 0028 lea %sp@(40),%sp 43ba2: 4a80 tstl %d0
43ba4: 6710 beqs 43bb6 <rmdir+0xba>
if ( free_parentloc )
43ba6: 4a04 tstb %d4
43ba8: 6768 beqs 43c12 <rmdir+0x116> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
43baa: 2f03 movel %d3,%sp@- 43bac: 4eb9 0004 2e10 jsr 42e10 <rtems_filesystem_freenode> 43bb2: 588f addql #4,%sp 43bb4: 605c bras 43c12 <rmdir+0x116>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
43bb6: 206e ffe0 moveal %fp@(-32),%a0 43bba: 45f9 0004 2e10 lea 42e10 <rtems_filesystem_freenode>,%a2 43bc0: 2f02 movel %d2,%sp@- 43bc2: 2068 0010 moveal %a0@(16),%a0 43bc6: 4e90 jsr %a0@ 43bc8: 588f addql #4,%sp 43bca: 7201 moveq #1,%d1 43bcc: b280 cmpl %d0,%d1
43bce: 671e beqs 43bee <rmdir+0xf2>
rtems_filesystem_freenode( &loc );
43bd0: 2f02 movel %d2,%sp@- 43bd2: 4e92 jsr %a2@
if ( free_parentloc )
43bd4: 588f addql #4,%sp 43bd6: 4a04 tstb %d4
43bd8: 6706 beqs 43be0 <rmdir+0xe4> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
43bda: 2f03 movel %d3,%sp@- 43bdc: 4e92 jsr %a2@ 43bde: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( ENOTDIR );
43be0: 4eb9 0004 d280 jsr 4d280 <__errno> 43be6: 2040 moveal %d0,%a0 43be8: 7014 moveq #20,%d0 43bea: 2080 movel %d0,%a0@ 43bec: 6024 bras 43c12 <rmdir+0x116>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
43bee: 2f02 movel %d2,%sp@- 43bf0: 206e ffdc moveal %fp@(-36),%a0 43bf4: 2f03 movel %d3,%sp@- 43bf6: 2068 0034 moveal %a0@(52),%a0 43bfa: 4e90 jsr %a0@ 43bfc: 2a00 movel %d0,%d5
rtems_filesystem_freenode( &loc );
43bfe: 2f02 movel %d2,%sp@- 43c00: 4e92 jsr %a2@
if ( free_parentloc )
43c02: 4fef 000c lea %sp@(12),%sp 43c06: 4a04 tstb %d4
43c08: 670a beqs 43c14 <rmdir+0x118>
rtems_filesystem_freenode( &parentloc );
43c0a: 2f03 movel %d3,%sp@- 43c0c: 4e92 jsr %a2@ 43c0e: 588f addql #4,%sp 43c10: 6002 bras 43c14 <rmdir+0x118>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
43c12: 7aff moveq #-1,%d5
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
43c14: 2005 movel %d5,%d0 43c16: 4cee 0c3c ffbc moveml %fp@(-68),%d2-%d5/%a2-%a3
43c1c: 4e5e unlk %fp <== NOT EXECUTED
00046750 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
46750: 4e56 ffc0 linkw %fp,#-64 46754: 48d7 3c1c moveml %d2-%d4/%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);
46758: 4879 0006 1378 pea 61378 <aio_request_queue> 4675e: 4bf9 0004 7078 lea 47078 <pthread_mutex_lock>,%a5
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
46764: 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);
46768: 4e95 jsr %a5@
if (result != 0) {
4676a: 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);
4676c: 2400 movel %d0,%d2
if (result != 0) {
4676e: 670c beqs 4677c <rtems_aio_enqueue+0x2c> <== ALWAYS TAKEN
free (req);
46770: 2f0a movel %a2,%sp@- <== NOT EXECUTED 46772: 4eb9 0004 3434 jsr 43434 <free> <== NOT EXECUTED 46778: 6000 01c6 braw 46940 <rtems_aio_enqueue+0x1f0> <== 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);
4677c: 47f9 0004 784c lea 4784c <pthread_self>,%a3 46782: 4e93 jsr %a3@ 46784: 486e ffdc pea %fp@(-36) 46788: 486e fff8 pea %fp@(-8) 4678c: 2f00 movel %d0,%sp@- 4678e: 4eb9 0004 7478 jsr 47478 <pthread_getschedparam>
req->caller_thread = pthread_self ();
46794: 4e93 jsr %a3@
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
46796: 206a 0014 moveal %a2@(20),%a0
req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
4679a: 7277 moveq #119,%d1
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
4679c: 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 ();
467a0: 2540 0010 movel %d0,%a2@(16)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
467a4: 202e ffdc movel %fp@(-36),%d0 467a8: 90a8 0014 subl %a0@(20),%d0
req->policy = policy;
467ac: 256e fff8 0008 movel %fp@(-8),%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;
467b2: 2540 000c movel %d0,%a2@(12)
req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
467b6: 2141 0030 movel %d1,%a0@(48)
req->aiocbp->return_value = 0;
467ba: 42a8 0034 clrl %a0@(52)
if ((aio_request_queue.idle_threads == 0) &&
467be: 4ab9 0006 13e0 tstl 613e0 <aio_request_queue+0x68> 467c4: 6600 00ae bnew 46874 <rtems_aio_enqueue+0x124> 467c8: 7004 moveq #4,%d0 467ca: b0b9 0006 13dc cmpl 613dc <aio_request_queue+0x64>,%d0 467d0: 6d00 00a2 bltw 46874 <rtems_aio_enqueue+0x124>
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);
467d4: 4878 0001 pea 1 <ADD> 467d8: 2f10 movel %a0@,%sp@- 467da: 4879 0006 13c0 pea 613c0 <aio_request_queue+0x48> 467e0: 4eb9 0004 634a jsr 4634a <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
467e6: 4fef 000c lea %sp@(12),%sp 467ea: 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);
467ec: 2640 moveal %d0,%a3 467ee: 2800 movel %d0,%d4 467f0: 2600 movel %d0,%d3 467f2: 5084 addql #8,%d4 467f4: 0683 0000 001c addil #28,%d3 467fa: 49eb 0020 lea %a3@(32),%a4
if (r_chain->new_fd == 1) {
467fe: b2ab 0018 cmpl %a3@(24),%d1
46802: 665e bnes 46862 <rtems_aio_enqueue+0x112>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
46804: 2f0a movel %a2,%sp@- 46806: 2f04 movel %d4,%sp@- 46808: 4eb9 0004 8914 jsr 48914 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0;
4680e: 42ab 0018 clrl %a3@(24)
pthread_mutex_init (&r_chain->mutex, NULL);
46812: 42a7 clrl %sp@- 46814: 2f03 movel %d3,%sp@- 46816: 4eb9 0004 6f60 jsr 46f60 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
4681c: 42a7 clrl %sp@- 4681e: 2f0c movel %a4,%sp@- 46820: 4eb9 0004 6c00 jsr 46c00 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
46826: 2f0b movel %a3,%sp@- 46828: 487a fbe8 pea %pc@(46412 <rtems_aio_handle>) 4682c: 4879 0006 1380 pea 61380 <aio_request_queue+0x8> 46832: 486e fffc pea %fp@(-4) 46836: 4eb9 0004 7270 jsr 47270 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
4683c: 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,
46840: 2600 movel %d0,%d3
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
46842: 6714 beqs 46858 <rtems_aio_enqueue+0x108> <== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
46844: 4879 0006 1378 pea 61378 <aio_request_queue> <== NOT EXECUTED
return result;
4684a: 2403 movel %d3,%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);
4684c: 4eb9 0004 7110 jsr 47110 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
46852: 588f addql #4,%sp <== NOT EXECUTED 46854: 6000 00ec braw 46942 <rtems_aio_enqueue+0x1f2> <== NOT EXECUTED
} ++aio_request_queue.active_threads;
46858: 52b9 0006 13dc addql #1,613dc <aio_request_queue+0x64> 4685e: 6000 00d4 braw 46934 <rtems_aio_enqueue+0x1e4>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
46862: 2f03 movel %d3,%sp@- 46864: 4e95 jsr %a5@
rtems_aio_insert_prio (&r_chain->perfd, req);
46866: 2f0a movel %a2,%sp@- 46868: 2f04 movel %d4,%sp@- 4686a: 4eb9 0004 664c jsr 4664c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
46870: 2f0c movel %a4,%sp@- 46872: 603c bras 468b0 <rtems_aio_enqueue+0x160>
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,
46874: 42a7 clrl %sp@- 46876: 2f10 movel %a0@,%sp@- 46878: 49f9 0004 634a lea 4634a <rtems_aio_search_fd>,%a4 4687e: 4879 0006 13c0 pea 613c0 <aio_request_queue+0x48> 46884: 4e94 jsr %a4@
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
46886: 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,
4688a: 2640 moveal %d0,%a3
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
4688c: 4a80 tstl %d0
4688e: 6734 beqs 468c4 <rtems_aio_enqueue+0x174>
{
pthread_mutex_lock (&r_chain->mutex);
46890: 2600 movel %d0,%d3 46892: 0683 0000 001c addil #28,%d3 46898: 2f03 movel %d3,%sp@- 4689a: 4eb9 0004 7078 jsr 47078 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
468a0: 2f0a movel %a2,%sp@- 468a2: 486b 0008 pea %a3@(8) 468a6: 4eb9 0004 664c jsr 4664c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
468ac: 486b 0020 pea %a3@(32) 468b0: 4eb9 0004 6ca4 jsr 46ca4 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
468b6: 2f03 movel %d3,%sp@- 468b8: 4eb9 0004 7110 jsr 47110 <pthread_mutex_unlock> 468be: 4fef 0014 lea %sp@(20),%sp 468c2: 6070 bras 46934 <rtems_aio_enqueue+0x1e4>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
468c4: 4878 0001 pea 1 <ADD> 468c8: 206a 0014 moveal %a2@(20),%a0 468cc: 2f10 movel %a0@,%sp@- 468ce: 4879 0006 13cc pea 613cc <aio_request_queue+0x54> 468d4: 4e94 jsr %a4@
if (r_chain->new_fd == 1) {
468d6: 4fef 000c lea %sp@(12),%sp 468da: 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);
468dc: 2640 moveal %d0,%a3 468de: 5080 addql #8,%d0
if (r_chain->new_fd == 1) {
468e0: b2ab 0018 cmpl %a3@(24),%d1
468e4: 662c bnes 46912 <rtems_aio_enqueue+0x1c2>
468e6: 2f0a movel %a2,%sp@- 468e8: 2f00 movel %d0,%sp@- 468ea: 4eb9 0004 8914 jsr 48914 <_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;
468f0: 42ab 0018 clrl %a3@(24)
pthread_mutex_init (&r_chain->mutex, NULL);
468f4: 42a7 clrl %sp@- 468f6: 486b 001c pea %a3@(28) 468fa: 4eb9 0004 6f60 jsr 46f60 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
46900: 42a7 clrl %sp@- 46902: 486b 0020 pea %a3@(32) 46906: 4eb9 0004 6c00 jsr 46c00 <pthread_cond_init> 4690c: 4fef 0018 lea %sp@(24),%sp 46910: 600c bras 4691e <rtems_aio_enqueue+0x1ce>
} else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
46912: 2f0a movel %a2,%sp@- 46914: 2f00 movel %d0,%sp@- 46916: 4eb9 0004 664c jsr 4664c <rtems_aio_insert_prio> 4691c: 508f addql #8,%sp
if (aio_request_queue.idle_threads > 0)
4691e: 4ab9 0006 13e0 tstl 613e0 <aio_request_queue+0x68>
46924: 6f0e bles 46934 <rtems_aio_enqueue+0x1e4> <== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
46926: 4879 0006 137c pea 6137c <aio_request_queue+0x4> <== NOT EXECUTED 4692c: 4eb9 0004 6ca4 jsr 46ca4 <pthread_cond_signal> <== NOT EXECUTED 46932: 588f addql #4,%sp <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
46934: 4879 0006 1378 pea 61378 <aio_request_queue> 4693a: 4eb9 0004 7110 jsr 47110 <pthread_mutex_unlock>
return 0;
46940: 588f addql #4,%sp
}
46942: 2002 movel %d2,%d0 46944: 4cee 3c1c ffc0 moveml %fp@(-64),%d2-%d4/%a2-%a5 4694a: 4e5e unlk %fp
...
00046412 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
46412: 4e56 ffa8 linkw %fp,#-88 46416: 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);
4641a: 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);
4641c: 280e movel %fp,%d4
/* 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);
4641e: 2e3c 0004 7078 movel #290936,%d7 46424: 4bf9 0004 7110 lea 47110 <pthread_mutex_unlock>,%a5
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
4642a: 0682 ffff fff4 addil #-12,%d2 46430: 2c3c 0004 6ad0 movel #289488,%d6
timeout.tv_sec += 3; timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
46436: 2a3c 0004 6d18 movel #290072,%d5
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4643c: 49f9 0004 88b8 lea 488b8 <_Chain_Extract>,%a4
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);
46442: 0684 ffff ffd8 addil #-40,%d4
static void *
rtems_aio_handle (void *arg)
{
rtems_aio_request_chain *r_chain = arg;
46448: 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);
4644c: 260a movel %a2,%d3 4644e: 0683 0000 001c addil #28,%d3 46454: 2047 moveal %d7,%a0 46456: 2f03 movel %d3,%sp@- 46458: 4e90 jsr %a0@
if (result != 0)
4645a: 588f addql #4,%sp 4645c: 4a80 tstl %d0 4645e: 6600 01e0 bnew 46640 <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 );
46462: 200a movel %a2,%d0 46464: 0680 0000 000c addil #12,%d0
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
4646a: 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)) {
4646e: b08b cmpl %a3,%d0 46470: 6700 00da beqw 4654c <rtems_aio_handle+0x13a>
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);
46474: 41f9 0004 784c lea 4784c <pthread_self>,%a0 4647a: 2d48 ffd0 movel %a0,%fp@(-48) 4647e: 4e90 jsr %a0@ 46480: 2f04 movel %d4,%sp@- 46482: 486e fffc pea %fp@(-4) 46486: 2f00 movel %d0,%sp@- 46488: 4eb9 0004 7478 jsr 47478 <pthread_getschedparam>
param.sched_priority = req->priority;
pthread_setschedparam (pthread_self(), req->policy, ¶m);
4648e: 202b 0008 movel %a3@(8),%d0
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;
46492: 2d6b 000c ffd8 movel %a3@(12),%fp@(-40)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
46498: 206e ffd0 moveal %fp@(-48),%a0 4649c: 2d40 ffd4 movel %d0,%fp@(-44) 464a0: 4e90 jsr %a0@ 464a2: 2f04 movel %d4,%sp@- 464a4: 2f2e ffd4 movel %fp@(-44),%sp@- 464a8: 2f00 movel %d0,%sp@- 464aa: 4eb9 0004 7860 jsr 47860 <pthread_setschedparam> 464b0: 2f0b movel %a3,%sp@- 464b2: 4e94 jsr %a4@
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
464b4: 2f03 movel %d3,%sp@- 464b6: 4e95 jsr %a5@
switch (req->aiocbp->aio_lio_opcode) {
464b8: 206b 0014 moveal %a3@(20),%a0 464bc: 4fef 0020 lea %sp@(32),%sp 464c0: 7202 moveq #2,%d1 464c2: 2028 002c movel %a0@(44),%d0 464c6: b280 cmpl %d0,%d1
464c8: 672a beqs 464f4 <rtems_aio_handle+0xe2>
464ca: 123c 0003 moveb #3,%d1 464ce: b280 cmpl %d0,%d1
464d0: 6740 beqs 46512 <rtems_aio_handle+0x100> <== NEVER TAKEN
464d2: 123c 0001 moveb #1,%d1 464d6: b280 cmpl %d0,%d1
464d8: 6648 bnes 46522 <rtems_aio_handle+0x110> <== NEVER TAKEN
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
464da: 2f28 0008 movel %a0@(8),%sp@- 464de: 2f28 0004 movel %a0@(4),%sp@- 464e2: 2f28 0010 movel %a0@(16),%sp@- 464e6: 2f28 000c movel %a0@(12),%sp@- 464ea: 2f10 movel %a0@,%sp@- 464ec: 4eb9 0004 fbf6 jsr 4fbf6 <pread> 464f2: 6018 bras 4650c <rtems_aio_handle+0xfa>
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
464f4: 2f28 0008 movel %a0@(8),%sp@- 464f8: 2f28 0004 movel %a0@(4),%sp@- 464fc: 2f28 0010 movel %a0@(16),%sp@- 46500: 2f28 000c movel %a0@(12),%sp@- 46504: 2f10 movel %a0@,%sp@- 46506: 4eb9 0004 fcbe jsr 4fcbe <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
4650c: 4fef 0014 lea %sp@(20),%sp 46510: 600a bras 4651c <rtems_aio_handle+0x10a>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
46512: 2f10 movel %a0@,%sp@- <== NOT EXECUTED 46514: 4eb9 0004 c438 jsr 4c438 <fsync> <== NOT EXECUTED
break;
4651a: 588f addql #4,%sp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
4651c: 72ff moveq #-1,%d1 4651e: b280 cmpl %d0,%d1
46520: 661a bnes 4653c <rtems_aio_handle+0x12a> <== ALWAYS TAKEN
req->aiocbp->return_value = -1;
46522: 266b 0014 moveal %a3@(20),%a3 <== NOT EXECUTED 46526: 70ff moveq #-1,%d0 <== NOT EXECUTED 46528: 2740 0034 movel %d0,%a3@(52) <== NOT EXECUTED
req->aiocbp->error_code = errno;
4652c: 4eb9 0004 f150 jsr 4f150 <__errno> <== NOT EXECUTED 46532: 2040 moveal %d0,%a0 <== NOT EXECUTED 46534: 2750 0030 movel %a0@,%a3@(48) <== NOT EXECUTED 46538: 6000 ff12 braw 4644c <rtems_aio_handle+0x3a> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
4653c: 206b 0014 moveal %a3@(20),%a0 46540: 2140 0034 movel %d0,%a0@(52)
req->aiocbp->error_code = 0;
46544: 42a8 0030 clrl %a0@(48) 46548: 6000 ff02 braw 4644c <rtems_aio_handle+0x3a>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
4654c: 2f03 movel %d3,%sp@- 4654e: 4e95 jsr %a5@
pthread_mutex_lock (&aio_request_queue.mutex);
46550: 4879 0006 1378 pea 61378 <aio_request_queue> 46556: 2047 moveal %d7,%a0 46558: 4e90 jsr %a0@
if (rtems_chain_is_empty (chain))
4655a: 508f addql #8,%sp 4655c: b7ea 0008 cmpal %a2@(8),%a3 46560: 6600 00d0 bnew 46632 <rtems_aio_handle+0x220>
{
clock_gettime (CLOCK_REALTIME, &timeout);
46564: 2f02 movel %d2,%sp@- 46566: 4878 0001 pea 1 <ADD> 4656a: 2046 moveal %d6,%a0
timeout.tv_sec += 3; timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
4656c: 47ea 0020 lea %a2@(32),%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);
46570: 4e90 jsr %a0@
timeout.tv_sec += 3;
46572: 56ae fff4 addql #3,%fp@(-12)
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
46576: 2045 moveal %d5,%a0 46578: 2f02 movel %d2,%sp@- 4657a: 4879 0006 1378 pea 61378 <aio_request_queue>
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
46580: 42ae fff8 clrl %fp@(-8)
result = pthread_cond_timedwait (&r_chain->cond,
46584: 2f0b movel %a3,%sp@- 46586: 4e90 jsr %a0@
&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) {
46588: 4fef 0014 lea %sp@(20),%sp 4658c: 7274 moveq #116,%d1 4658e: b280 cmpl %d0,%d1 46590: 6600 00a0 bnew 46632 <rtems_aio_handle+0x220> 46594: 2f0a movel %a2,%sp@- 46596: 4e94 jsr %a4@
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
46598: 2f03 movel %d3,%sp@- 4659a: 4eb9 0004 6e40 jsr 46e40 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
465a0: 2f0b movel %a3,%sp@- 465a2: 4eb9 0004 6b3c jsr 46b3c <pthread_cond_destroy>
free (r_chain);
465a8: 2f0a movel %a2,%sp@- 465aa: 4eb9 0004 3434 jsr 43434 <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)) {
465b0: 4fef 0010 lea %sp@(16),%sp 465b4: 41f9 0006 13d0 lea 613d0 <aio_request_queue+0x58>,%a0 465ba: b1f9 0006 13cc cmpal 613cc <aio_request_queue+0x54>,%a0
465c0: 6650 bnes 46612 <rtems_aio_handle+0x200>
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);
465c2: 2f02 movel %d2,%sp@- 465c4: 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;
465c8: 52b9 0006 13e0 addql #1,613e0 <aio_request_queue+0x68>
--aio_request_queue.active_threads; clock_gettime (CLOCK_REALTIME, &timeout);
465ce: 2046 moveal %d6,%a0
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;
--aio_request_queue.active_threads;
465d0: 53b9 0006 13dc subql #1,613dc <aio_request_queue+0x64>
clock_gettime (CLOCK_REALTIME, &timeout);
465d6: 4e90 jsr %a0@
timeout.tv_sec += 3;
465d8: 56ae fff4 addql #3,%fp@(-12)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
465dc: 2045 moveal %d5,%a0 465de: 2f02 movel %d2,%sp@- 465e0: 4879 0006 1378 pea 61378 <aio_request_queue> 465e6: 4879 0006 137c pea 6137c <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;
465ec: 42ae fff8 clrl %fp@(-8)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
465f0: 4e90 jsr %a0@
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
465f2: 4fef 0014 lea %sp@(20),%sp 465f6: 7274 moveq #116,%d1 465f8: b280 cmpl %d0,%d1
465fa: 6616 bnes 46612 <rtems_aio_handle+0x200> <== NEVER TAKEN
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
465fc: 4879 0006 1378 pea 61378 <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;
46602: 53b9 0006 13e0 subql #1,613e0 <aio_request_queue+0x68>
pthread_mutex_unlock (&aio_request_queue.mutex);
46608: 4eb9 0004 7110 jsr 47110 <pthread_mutex_unlock>
return NULL;
4660e: 588f addql #4,%sp 46610: 602e bras 46640 <rtems_aio_handle+0x22e>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
46612: 2479 0006 13cc moveal 613cc <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;
46618: 53b9 0006 13e0 subql #1,613e0 <aio_request_queue+0x68>
++aio_request_queue.active_threads;
4661e: 52b9 0006 13dc addql #1,613dc <aio_request_queue+0x64> 46624: 2f0a movel %a2,%sp@- 46626: 4e94 jsr %a4@
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);
46628: 2f0a movel %a2,%sp@- 4662a: 4eb9 0004 63dc jsr 463dc <rtems_aio_move_to_work> 46630: 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);
46632: 4879 0006 1378 pea 61378 <aio_request_queue> 46638: 4e95 jsr %a5@ 4663a: 588f addql #4,%sp 4663c: 6000 fe0e braw 4644c <rtems_aio_handle+0x3a>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
46640: 4280 clrl %d0 46642: 4cee 3cfc ffa8 moveml %fp@(-88),%d2-%d7/%a2-%a5
46648: 4e5e unlk %fp <== NOT EXECUTED
00046260 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
46260: 4e56 0000 linkw %fp,#0 46264: 2f02 movel %d2,%sp@-
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
46266: 4879 0006 1380 pea 61380 <aio_request_queue+0x8> 4626c: 4eb9 0004 721c jsr 4721c <pthread_attr_init>
if (result != 0)
46272: 588f addql #4,%sp
int
rtems_aio_init (void)
{
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
46274: 2400 movel %d0,%d2
if (result != 0)
46276: 6600 00c8 bnew 46340 <rtems_aio_init+0xe0>
return result;
result =
4627a: 42a7 clrl %sp@- 4627c: 4879 0006 1380 pea 61380 <aio_request_queue+0x8> 46282: 4eb9 0004 7248 jsr 47248 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
46288: 508f addql #8,%sp 4628a: 4a80 tstl %d0
4628c: 670e beqs 4629c <rtems_aio_init+0x3c> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
4628e: 4879 0006 1380 pea 61380 <aio_request_queue+0x8> <== NOT EXECUTED 46294: 4eb9 0004 7200 jsr 47200 <pthread_attr_destroy> <== NOT EXECUTED 4629a: 588f addql #4,%sp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
4629c: 42a7 clrl %sp@- 4629e: 4879 0006 1378 pea 61378 <aio_request_queue> 462a4: 4eb9 0004 6f60 jsr 46f60 <pthread_mutex_init>
if (result != 0)
462aa: 508f addql #8,%sp 462ac: 4a80 tstl %d0
462ae: 670e beqs 462be <rtems_aio_init+0x5e> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
462b0: 4879 0006 1380 pea 61380 <aio_request_queue+0x8> <== NOT EXECUTED 462b6: 4eb9 0004 7200 jsr 47200 <pthread_attr_destroy> <== NOT EXECUTED 462bc: 588f addql #4,%sp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
462be: 42a7 clrl %sp@- 462c0: 4879 0006 137c pea 6137c <aio_request_queue+0x4> 462c6: 4eb9 0004 6c00 jsr 46c00 <pthread_cond_init>
if (result != 0) {
462cc: 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);
462ce: 2400 movel %d0,%d2
if (result != 0) {
462d0: 671a beqs 462ec <rtems_aio_init+0x8c> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
462d2: 4879 0006 1378 pea 61378 <aio_request_queue> <== NOT EXECUTED 462d8: 4eb9 0004 6e40 jsr 46e40 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
462de: 4879 0006 1380 pea 61380 <aio_request_queue+0x8> <== NOT EXECUTED 462e4: 4eb9 0004 7200 jsr 47200 <pthread_attr_destroy> <== NOT EXECUTED 462ea: 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;
462ec: 42b9 0006 13c4 clrl 613c4 <aio_request_queue+0x4c>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
462f2: 203c 0006 13c4 movel #398276,%d0 462f8: 23c0 0006 13c0 movel %d0,613c0 <aio_request_queue+0x48>
head->previous = NULL; tail->previous = head;
462fe: 203c 0006 13c0 movel #398272,%d0 46304: 23c0 0006 13c8 movel %d0,613c8 <aio_request_queue+0x50>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4630a: 203c 0006 13d0 movel #398288,%d0 46310: 23c0 0006 13cc movel %d0,613cc <aio_request_queue+0x54>
head->previous = NULL; tail->previous = head;
46316: 203c 0006 13cc movel #398284,%d0 4631c: 23c0 0006 13d4 movel %d0,613d4 <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;
46322: 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;
46328: 42b9 0006 13d0 clrl 613d0 <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;
4632e: 42b9 0006 13dc clrl 613dc <aio_request_queue+0x64>
aio_request_queue.idle_threads = 0;
46334: 42b9 0006 13e0 clrl 613e0 <aio_request_queue+0x68>
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
4633a: 23c0 0006 13d8 movel %d0,613d8 <aio_request_queue+0x60>
return result;
}
46340: 2002 movel %d2,%d0 46342: 242e fffc movel %fp@(-4),%d2
46346: 4e5e unlk %fp <== NOT EXECUTED
0004664c <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
4664c: 4e56 0000 linkw %fp,#0 46650: 202e 0008 movel %fp@(8),%d0
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
46654: 2240 moveal %d0,%a1
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
46656: 2f0b movel %a3,%sp@- 46658: 2f0a movel %a2,%sp@- 4665a: 246e 000c moveal %fp@(12),%a2
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
4665e: 2059 moveal %a1@+,%a0
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
46660: b3c8 cmpal %a0,%a1
46662: 672e beqs 46692 <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;
46664: 2668 0014 moveal %a0@(20),%a3 46668: 202b 0014 movel %a3@(20),%d0
while (req->aiocbp->aio_reqprio > prio &&
4666c: 266a 0014 moveal %a2@(20),%a3 46670: 222b 0014 movel %a3@(20),%d1 46674: 600a bras 46680 <rtems_aio_insert_prio+0x34>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
46676: 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;
46678: 2668 0014 moveal %a0@(20),%a3 <== NOT EXECUTED 4667c: 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 &&
46680: b081 cmpl %d1,%d0
46682: 6c04 bges 46688 <rtems_aio_insert_prio+0x3c> <== ALWAYS TAKEN
46684: b3c8 cmpal %a0,%a1 <== NOT EXECUTED 46686: 66ee bnes 46676 <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 );
46688: 2d4a 000c movel %a2,%fp@(12) 4668c: 2d68 0004 0008 movel %a0@(4),%fp@(8)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
46692: 245f moveal %sp@+,%a2 46694: 265f moveal %sp@+,%a3 46696: 4e5e unlk %fp 46698: 4ef9 0004 8914 jmp 48914 <_Chain_Insert>
000463dc <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
463dc: 4e56 0000 linkw %fp,#0 463e0: 226e 0008 moveal %fp@(8),%a1
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
463e4: 2079 0006 13c0 moveal 613c0 <aio_request_queue+0x48>,%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 &&
463ea: 2029 0014 movel %a1@(20),%d0 463ee: 6002 bras 463f2 <rtems_aio_move_to_work+0x16>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
463f0: 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 &&
463f2: b0a8 0014 cmpl %a0@(20),%d0
463f6: 6f08 bles 46400 <rtems_aio_move_to_work+0x24>
463f8: b1fc 0006 13c4 cmpal #398276,%a0
463fe: 66f0 bnes 463f0 <rtems_aio_move_to_work+0x14> <== ALWAYS TAKEN
46400: 2f09 movel %a1,%sp@- 46402: 2f28 0004 movel %a0@(4),%sp@- 46406: 4eb9 0004 8914 jsr 48914 <_Chain_Insert> 4640c: 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);
}
4640e: 4e5e unlk %fp <== NOT EXECUTED
000466f4 <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)
{
466f4: 4e56 0000 linkw %fp,#0
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
466f8: 206e 0008 moveal %fp@(8),%a0
* 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)
{
466fc: 2f0a movel %a2,%sp@- 466fe: 202e 000c movel %fp@(12),%d0
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
46702: 2458 moveal %a0@+,%a2
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
46704: b1ca cmpal %a2,%a0
46706: 6608 bnes 46710 <rtems_aio_remove_req+0x1c>
46708: 6038 bras 46742 <rtems_aio_remove_req+0x4e>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
4670a: 2451 moveal %a1@,%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) {
4670c: b1ca cmpal %a2,%a0 <== NOT EXECUTED 4670e: 6736 beqs 46746 <rtems_aio_remove_req+0x52> <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
46710: 224a moveal %a2,%a1
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) {
46712: b0aa 0014 cmpl %a2@(20),%d0
46716: 66f2 bnes 4670a <rtems_aio_remove_req+0x16> <== NEVER TAKEN
46718: 2f0a movel %a2,%sp@- 4671a: 4eb9 0004 88b8 jsr 488b8 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
46720: 206a 0014 moveal %a2@(20),%a0 46724: 203c 0000 008c movel #140,%d0 4672a: 2140 0030 movel %d0,%a0@(48)
current->aiocbp->return_value = -1;
4672e: 70ff moveq #-1,%d0 46730: 2140 0034 movel %d0,%a0@(52)
free (current);
46734: 2f0a movel %a2,%sp@- 46736: 4eb9 0004 3434 jsr 43434 <free>
}
return AIO_CANCELED;
4673c: 508f addql #8,%sp 4673e: 4280 clrl %d0 46740: 6006 bras 46748 <rtems_aio_remove_req+0x54>
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
46742: 7002 moveq #2,%d0 46744: 6002 bras 46748 <rtems_aio_remove_req+0x54>
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
46746: 7001 moveq #1,%d0 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
46748: 246e fffc moveal %fp@(-4),%a2
4674c: 4e5e unlk %fp <== NOT EXECUTED
0004cf60 <rtems_barrier_delete>:
*/
rtems_status_code rtems_barrier_delete(
rtems_id id
)
{
4cf60: 4e56 fffc linkw %fp,#-4 4cf64: 2f0a movel %a2,%sp@-
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
4cf66: 486e fffc pea %fp@(-4) 4cf6a: 2f2e 0008 movel %fp@(8),%sp@- 4cf6e: 4879 0006 15b8 pea 615b8 <_Barrier_Information> 4cf74: 4eb9 0004 8c14 jsr 48c14 <_Objects_Get>
Barrier_Control *the_barrier;
Objects_Locations location;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
4cf7a: 4fef 000c lea %sp@(12),%sp 4cf7e: 2440 moveal %d0,%a2 4cf80: 4aae fffc tstl %fp@(-4)
4cf84: 663a bnes 4cfc0 <rtems_barrier_delete+0x60> <== NEVER TAKEN
case OBJECTS_LOCAL:
_CORE_barrier_Flush(
4cf86: 4878 0002 pea 2 <DOUBLE_FLOAT> 4cf8a: 42a7 clrl %sp@- 4cf8c: 486a 0014 pea %a2@(20) 4cf90: 4eb9 0004 9db8 jsr 49db8 <_Thread_queue_Flush>
&the_barrier->Barrier,
NULL,
CORE_BARRIER_WAS_DELETED
);
_Objects_Close( &_Barrier_Information, &the_barrier->Object );
4cf96: 2f0a movel %a2,%sp@- 4cf98: 4879 0006 15b8 pea 615b8 <_Barrier_Information> 4cf9e: 4eb9 0004 883c jsr 4883c <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Barrier_Free (
Barrier_Control *the_barrier
)
{
_Objects_Free( &_Barrier_Information, &the_barrier->Object );
4cfa4: 2f0a movel %a2,%sp@- 4cfa6: 4879 0006 15b8 pea 615b8 <_Barrier_Information> 4cfac: 4eb9 0004 8ab0 jsr 48ab0 <_Objects_Free>
_Barrier_Free( the_barrier );
_Thread_Enable_dispatch();
4cfb2: 4eb9 0004 977a jsr 4977a <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4cfb8: 4fef 001c lea %sp@(28),%sp 4cfbc: 4280 clrl %d0 4cfbe: 6002 bras 4cfc2 <rtems_barrier_delete+0x62>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4cfc0: 7004 moveq #4,%d0
}
4cfc2: 246e fff8 moveal %fp@(-8),%a2 4cfc6: 4e5e unlk %fp
...
000464a4 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
464a4: 4e56 ffe0 linkw %fp,#-32 464a8: 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(
464ac: 260e movel %fp,%d3
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
464ae: 47f9 0004 6a80 lea 46a80 <_Chain_Get>,%a3 464b4: 5983 subql #4,%d3 464b6: 45f9 0004 5930 lea 45930 <rtems_event_receive>,%a2
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
464bc: 2c2e 0008 movel %fp@(8),%d6 464c0: 2a2e 000c movel %fp@(12),%d5 464c4: 282e 0010 movel %fp@(16),%d4 464c8: 6012 bras 464dc <rtems_chain_get_with_wait+0x38>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
464ca: 2f03 movel %d3,%sp@- 464cc: 2f04 movel %d4,%sp@- 464ce: 42a7 clrl %sp@- 464d0: 2f05 movel %d5,%sp@- 464d2: 4e92 jsr %a2@
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
464d4: 4fef 0010 lea %sp@(16),%sp 464d8: 4a80 tstl %d0
464da: 660c bnes 464e8 <rtems_chain_get_with_wait+0x44> <== ALWAYS TAKEN
464dc: 2f06 movel %d6,%sp@- 464de: 4e93 jsr %a3@
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
464e0: 588f addql #4,%sp 464e2: 2400 movel %d0,%d2
464e4: 67e4 beqs 464ca <rtems_chain_get_with_wait+0x26>
464e6: 4280 clrl %d0
timeout,
&out
);
}
*node_ptr = node;
464e8: 206e 0014 moveal %fp@(20),%a0 464ec: 2082 movel %d2,%a0@
return sc;
}
464ee: 4cee 0c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a3
464f4: 4e5e unlk %fp <== NOT EXECUTED
0004f3b8 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
4f3b8: 4e56 fff8 linkw %fp,#-8 4f3bc: 2f0a movel %a2,%sp@- 4f3be: 246e 0008 moveal %fp@(8),%a2 4f3c2: 2f02 movel %d2,%sp@-
if ( !time )
4f3c4: 4a8a tstl %a2
4f3c6: 673c beqs 4f404 <rtems_clock_get_tod_timeval+0x4c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
4f3c8: 4a39 0007 752c tstb 7752c <_TOD_Is_set>
4f3ce: 6738 beqs 4f408 <rtems_clock_get_tod_timeval+0x50><== NEVER TAKEN
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
4f3d0: 203c 0000 0700 movel #1792,%d0 4f3d6: 40c2 movew %sr,%d2 4f3d8: 8082 orl %d2,%d0 4f3da: 46c0 movew %d0,%sr
_TOD_Get( &now );
4f3dc: 486e fff8 pea %fp@(-8) 4f3e0: 4eb9 0005 355c jsr 5355c <_TOD_Get>
_ISR_Enable(level);
4f3e6: 46c2 movew %d2,%sr
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
4f3e8: 243c 0000 03e8 movel #1000,%d2
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
4f3ee: 588f addql #4,%sp
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
4f3f0: 202e fffc movel %fp@(-4),%d0
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
4f3f4: 4c42 0800 remsl %d2,%d0,%d0
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
4f3f8: 24ae fff8 movel %fp@(-8),%a2@
time->tv_usec = useconds;
4f3fc: 2540 0004 movel %d0,%a2@(4) 4f400: 4280 clrl %d0 4f402: 6006 bras 4f40a <rtems_clock_get_tod_timeval+0x52>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
4f404: 7009 moveq #9,%d0 4f406: 6002 bras 4f40a <rtems_clock_get_tod_timeval+0x52>
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
4f408: 700b moveq #11,%d0
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
4f40a: 242e fff0 movel %fp@(-16),%d2 4f40e: 246e fff4 moveal %fp@(-12),%a2 4f412: 4e5e unlk %fp
...
0004ca08 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
4ca08: 4e56 0000 linkw %fp,#0 4ca0c: 202e 0008 movel %fp@(8),%d0 4ca10: 2f02 movel %d2,%sp@-
if (sc == RTEMS_SUCCESSFUL) {
4ca12: 4a80 tstl %d0
4ca14: 6722 beqs 4ca38 <rtems_deviceio_errno+0x30>
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
4ca16: 721c moveq #28,%d1 4ca18: b280 cmpl %d0,%d1
4ca1a: 650c bcss 4ca28 <rtems_deviceio_errno+0x20> <== NEVER TAKEN
eno = status_code_to_errno [sc];
4ca1c: 41f9 0005 c6b6 lea 5c6b6 <status_code_to_errno>,%a0 4ca22: 2430 0c00 movel %a0@(00000000,%d0:l:4),%d2 4ca26: 6002 bras 4ca2a <rtems_deviceio_errno+0x22>
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
4ca28: 7416 moveq #22,%d2 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
4ca2a: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4ca30: 2040 moveal %d0,%a0
return -1;
4ca32: 70ff moveq #-1,%d0
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
4ca34: 2082 movel %d2,%a0@
return -1;
4ca36: 6002 bras 4ca3a <rtems_deviceio_errno+0x32>
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
4ca38: 4280 clrl %d0
errno = eno;
return -1;
}
}
4ca3a: 242e fffc movel %fp@(-4),%d2 4ca3e: 4e5e unlk %fp
...
00049dc6 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
49dc6: 4e56 fff8 linkw %fp,#-8 49dca: 202e 0008 movel %fp@(8),%d0
find_arg fa = {
49dce: 42ae fffc clrl %fp@(-4) 49dd2: 2d40 fff8 movel %d0,%fp@(-8)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
49dd6: 6710 beqs 49de8 <rtems_filesystem_get_mount_handler+0x22><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
49dd8: 486e fff8 pea %fp@(-8) 49ddc: 487a ff16 pea %pc@(49cf4 <find_handler>) 49de0: 4eb9 0004 9d5e jsr 49d5e <rtems_filesystem_iterate> 49de6: 508f addql #8,%sp
}
return fa.mount_h;
}
49de8: 202e fffc movel %fp@(-4),%d0
49dec: 4e5e unlk %fp <== NOT EXECUTED
00042560 <rtems_filesystem_initialize>:
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
42560: 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 )
{
42562: 4e56 ffe0 linkw %fp,#-32
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
42566: 2079 0005 d244 moveal 5d244 <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 )
{
4256c: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
42570: 2140 002c movel %d0,%a0@(44)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
42574: 4ab9 0005 b54e tstl 5b54e <rtems_filesystem_mount_table_size>
4257a: 6608 bnes 42584 <rtems_filesystem_initialize+0x24><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
4257c: 2f3c abcd 0001 movel #-1412628479,%sp@- <== NOT EXECUTED 42582: 602c bras 425b0 <rtems_filesystem_initialize+0x50><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
42584: 2079 0005 cffc moveal 5cffc <rtems_filesystem_mount_table>,%a0
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
4258a: 42a7 clrl %sp@- 4258c: 2f28 0004 movel %a0@(4),%sp@- 42590: 2f10 movel %a0@,%sp@- 42592: 2f28 000c movel %a0@(12),%sp@- 42596: 2f28 0008 movel %a0@(8),%sp@- 4259a: 4eb9 0004 2ef8 jsr 42ef8 <mount>
if ( status == -1 )
425a0: 4fef 0014 lea %sp@(20),%sp 425a4: 72ff moveq #-1,%d1 425a6: b280 cmpl %d0,%d1
425a8: 660c bnes 425b6 <rtems_filesystem_initialize+0x56><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
425aa: 2f3c abcd 0002 movel #-1412628478,%sp@- <== NOT EXECUTED 425b0: 4eb9 0004 5efc jsr 45efc <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_filesystem_link_counts = 0;
425b6: 2079 0005 d244 moveal 5d244 <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);
425bc: 240e movel %fp,%d2 425be: 0682 ffff ffec addil #-20,%d2 425c4: 47f9 0004 290c lea 4290c <rtems_filesystem_evaluate_path>,%a3
rtems_filesystem_root = loc;
425ca: 45f9 0004 d37c lea 4d37c <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;
425d0: 4240 clrw %d0 425d2: 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);
425d6: 42a7 clrl %sp@- 425d8: 2f02 movel %d2,%sp@- 425da: 42a7 clrl %sp@- 425dc: 4878 0001 pea 1 <ADD> 425e0: 4879 0005 bbfe pea 5bbfe <IMFS_ops+0x48> 425e6: 4e93 jsr %a3@
rtems_filesystem_root = loc;
425e8: 4878 0014 pea 14 <OPER2> 425ec: 2079 0005 d244 moveal 5d244 <rtems_current_user_env>,%a0 425f2: 41e8 0018 lea %a0@(24),%a0 425f6: 2f02 movel %d2,%sp@- 425f8: 2f08 movel %a0,%sp@- 425fa: 4e92 jsr %a2@
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
425fc: 4fef 001c lea %sp@(28),%sp 42600: 4297 clrl %sp@ 42602: 2f02 movel %d2,%sp@- 42604: 42a7 clrl %sp@- 42606: 4878 0001 pea 1 <ADD> 4260a: 4879 0005 bbfe pea 5bbfe <IMFS_ops+0x48> 42610: 4e93 jsr %a3@
rtems_filesystem_current = loc;
42612: 4878 0014 pea 14 <OPER2> 42616: 2039 0005 d244 movel 5d244 <rtems_current_user_env>,%d0 4261c: 5880 addql #4,%d0 4261e: 2f02 movel %d2,%sp@- 42620: 2f00 movel %d0,%sp@- 42622: 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);
42624: 4fef 0020 lea %sp@(32),%sp 42628: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca> 4262c: 4879 0005 bc00 pea 5bc00 <IMFS_ops+0x4a> 42632: 4eb9 0004 2d80 jsr 42d80 <mkdir>
if ( status != 0 )
42638: 508f addql #8,%sp 4263a: 4a80 tstl %d0
4263c: 670a beqs 42648 <rtems_filesystem_initialize+0xe8><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
4263e: 2f3c abcd 0003 movel #-1412628477,%sp@- <== NOT EXECUTED 42644: 6000 ff6a braw 425b0 <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. */ }
42648: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3 4264e: 4e5e unlk %fp
...
00049d5e <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
49d5e: 4e56 fff0 linkw %fp,#-16
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false;
49d62: 4200 clrb %d0
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
49d64: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 49d68: 266e 0008 moveal %fp@(8),%a3
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
49d6c: 45f9 0005 b52e lea 5b52e <rtems_filesystem_table>,%a2
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
49d72: 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;
while ( table_entry->type && !stop ) {
49d76: 600a bras 49d82 <rtems_filesystem_iterate+0x24>
stop = (*routine)( table_entry, routine_arg );
49d78: 2f02 movel %d2,%sp@- 49d7a: 2f0a movel %a2,%sp@-
++table_entry;
49d7c: 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 );
49d7e: 4e93 jsr %a3@
++table_entry;
49d80: 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 ) {
49d82: 4a92 tstl %a2@
49d84: 6706 beqs 49d8c <rtems_filesystem_iterate+0x2e>
49d86: 4a00 tstb %d0
49d88: 67ee beqs 49d78 <rtems_filesystem_iterate+0x1a>
49d8a: 6030 bras 49dbc <rtems_filesystem_iterate+0x5e> 49d8c: 1600 moveb %d0,%d3
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
49d8e: 662c bnes 49dbc <rtems_filesystem_iterate+0x5e>
rtems_libio_lock();
49d90: 4eba ff9a jsr %pc@(49d2c <rtems_libio_lock>)
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
49d94: 2479 0005 d24c moveal 5d24c <filesystem_chain>,%a2
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
49d9a: 600e bras 49daa <rtems_filesystem_iterate+0x4c>
!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 );
49d9c: 2f02 movel %d2,%sp@- 49d9e: 486a 0008 pea %a2@(8) 49da2: 4e93 jsr %a3@
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
49da4: 2452 moveal %a2@,%a2
if ( !stop ) {
rtems_libio_lock();
for (
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
49da6: 508f addql #8,%sp
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
49da8: 1600 moveb %d0,%d3
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
49daa: b5fc 0005 d250 cmpal #381520,%a2
49db0: 6704 beqs 49db6 <rtems_filesystem_iterate+0x58>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
49db2: 4a03 tstb %d3
49db4: 67e6 beqs 49d9c <rtems_filesystem_iterate+0x3e> <== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
49db6: 4eba ff90 jsr %pc@(49d48 <rtems_libio_unlock>) 49dba: 1003 moveb %d3,%d0
}
return stop;
}
49dbc: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
49dc2: 4e5e unlk %fp <== NOT EXECUTED
00042eae <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
42eae: 4e56 fff0 linkw %fp,#-16 42eb2: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 42eb6: 266e 0008 moveal %fp@(8),%a3 42eba: 242e 000c movel %fp@(12),%d2
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
42ebe: 4eba ffbc jsr %pc@(42e7c <rtems_libio_lock>)
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
42ec2: 2479 0005 d128 moveal 5d128 <mount_chain>,%a2
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
42ec8: 4200 clrb %d0
rtems_libio_lock();
for (
42eca: 600a bras 42ed6 <rtems_filesystem_mount_iterate+0x28>
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 );
42ecc: 2f02 movel %d2,%sp@- 42ece: 2f0a movel %a2,%sp@- 42ed0: 4e93 jsr %a3@
}
rtems_libio_unlock();
return stop;
}
42ed2: 2452 moveal %a2@,%a2
rtems_libio_lock();
for (
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
node = rtems_chain_next( node )
42ed4: 508f addql #8,%sp
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
42ed6: b5fc 0005 d12c cmpal #381228,%a2
42edc: 6704 beqs 42ee2 <rtems_filesystem_mount_iterate+0x34>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
42ede: 4a00 tstb %d0
42ee0: 67ea beqs 42ecc <rtems_filesystem_mount_iterate+0x1e><== ALWAYS TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
42ee2: 2d40 fffc movel %d0,%fp@(-4) 42ee6: 4eba ffb0 jsr %pc@(42e98 <rtems_libio_unlock>)
return stop;
}
42eea: 202e fffc movel %fp@(-4),%d0 42eee: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
42ef4: 4e5e unlk %fp <== NOT EXECUTED
0004299a <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
4299a: 4e56 fff0 linkw %fp,#-16 4299e: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 429a2: 262e 000c movel %fp@(12),%d3
/* * Eat any separators at start of the path. */ int stripped = 0;
429a6: 4282 clrl %d2
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
429a8: 47f9 0004 3728 lea 43728 <rtems_filesystem_is_separator>,%a3
)
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
429ae: 246e 0008 moveal %fp@(8),%a2
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
429b2: 6002 bras 429b6 <rtems_filesystem_prefix_separators+0x1c>
{
pathname++;
pathnamelen--;
stripped++;
429b4: 5282 addql #1,%d2
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
429b6: 101a moveb %a2@+,%d0
429b8: 6710 beqs 429ca <rtems_filesystem_prefix_separators+0x30><== NEVER TAKEN
429ba: b483 cmpl %d3,%d2
429bc: 670c beqs 429ca <rtems_filesystem_prefix_separators+0x30><== NEVER TAKEN
429be: 49c0 extbl %d0 429c0: 2f00 movel %d0,%sp@- 429c2: 4e93 jsr %a3@ 429c4: 588f addql #4,%sp 429c6: 4a80 tstl %d0
429c8: 66ea bnes 429b4 <rtems_filesystem_prefix_separators+0x1a>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
429ca: 2002 movel %d2,%d0 429cc: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3 429d2: 4e5e unlk %fp
...
000432a6 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
432a6: 4e56 0000 linkw %fp,#0 432aa: 2f0a movel %a2,%sp@- 432ac: 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 ) );
432ae: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
432b2: 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 ) );
432b6: 4eb9 0004 368c jsr 4368c <malloc>
*key = new_key;
432bc: 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 ) );
432c0: 2440 moveal %d0,%a2
*key = new_key;
432c2: 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 );
432c4: 2f02 movel %d2,%sp@- 432c6: 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;
432c8: 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 );
432ca: 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;
432cc: 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 );
432d0: 4eb9 0004 67cc jsr 467cc <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
432d6: 4fef 0010 lea %sp@(16),%sp 432da: 4a80 tstl %d0
432dc: 670e beqs 432ec <rtems_gxx_key_create+0x46> <== ALWAYS TAKEN
return 0;
free( new_key );
432de: 2f0a movel %a2,%sp@- <== NOT EXECUTED 432e0: 4eb9 0004 313c jsr 4313c <free> <== NOT EXECUTED
return -1;
432e6: 588f addql #4,%sp <== NOT EXECUTED 432e8: 70ff moveq #-1,%d0 <== NOT EXECUTED 432ea: 6002 bras 432ee <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;
432ec: 4280 clrl %d0
free( new_key );
return -1;
}
432ee: 242e fff8 movel %fp@(-8),%d2 432f2: 246e fffc moveal %fp@(-4),%a2
432f6: 4e5e unlk %fp <== NOT EXECUTED
0004330a <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
4330a: 4e56 0000 linkw %fp,#0 4330e: 2f0a movel %a2,%sp@- 43310: 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 );
43314: 2f0a movel %a2,%sp@- 43316: 42a7 clrl %sp@- 43318: 4eb9 0004 6860 jsr 46860 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
4331e: 508f addql #8,%sp 43320: 4a80 tstl %d0
43322: 660e bnes 43332 <rtems_gxx_key_delete+0x28> <== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
43324: 4a8a tstl %a2
43326: 670a beqs 43332 <rtems_gxx_key_delete+0x28> <== NEVER TAKEN
43328: 2f12 movel %a2@,%sp@- 4332a: 4eb9 0004 313c jsr 4313c <free> 43330: 588f addql #4,%sp
return 0;
}
key = NULL;
return 0;
}
43332: 246e fffc moveal %fp@(-4),%a2 43336: 4280 clrl %d0
43338: 4e5e unlk %fp <== NOT EXECUTED
00043248 <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))
{
43248: 4e56 fffc linkw %fp,#-4 4324c: 2f0a movel %a2,%sp@- 4324e: 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 ) {
43252: 2012 movel %a2@,%d0
/* 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))
{
43254: 2f02 movel %d2,%sp@-
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
43256: 4a80 tstl %d0
43258: 663e bnes 43298 <rtems_gxx_once+0x50>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
4325a: 486e fffc pea %fp@(-4) 4325e: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 43262: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 43266: 4eb9 0004 65f4 jsr 465f4 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
4326c: 2412 movel %a2@,%d2 4326e: 4fef 000c lea %sp@(12),%sp
43272: 6604 bnes 43278 <rtems_gxx_once+0x30> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
43274: 7001 moveq #1,%d0 43276: 2480 movel %d0,%a2@
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
43278: 486e fffc pea %fp@(-4) 4327c: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 43280: 2f2e fffc movel %fp@(-4),%sp@- 43284: 4eb9 0004 65f4 jsr 465f4 <rtems_task_mode>
if ( o == 0 )
4328a: 4fef 000c lea %sp@(12),%sp 4328e: 4a82 tstl %d2
43290: 6606 bnes 43298 <rtems_gxx_once+0x50> <== NEVER TAKEN
(*func)();
43292: 206e 000c moveal %fp@(12),%a0 43296: 4e90 jsr %a0@
} return 0; }
43298: 242e fff4 movel %fp@(-12),%d2 4329c: 4280 clrl %d0 4329e: 246e fff8 moveal %fp@(-8),%a2
432a2: 4e5e unlk %fp <== NOT EXECUTED
00043398 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
43398: 4e56 0000 linkw %fp,#0 4339c: 2f0a movel %a2,%sp@- 4339e: 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 );
433a2: 2f2a 0004 movel %a2@(4),%sp@- 433a6: 2f0a movel %a2,%sp@- 433a8: 42a7 clrl %sp@- 433aa: 4eb9 0004 67cc jsr 467cc <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
433b0: 4fef 000c lea %sp@(12),%sp 433b4: 4a80 tstl %d0
433b6: 6606 bnes 433be <rtems_gxx_setspecific+0x26> <== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
433b8: 24ae 000c movel %fp@(12),%a2@
return 0;
433bc: 6002 bras 433c0 <rtems_gxx_setspecific+0x28>
} return -1;
433be: 70ff moveq #-1,%d0 <== NOT EXECUTED
}
433c0: 246e fffc moveal %fp@(-4),%a2
433c4: 4e5e unlk %fp <== NOT EXECUTED
00046f24 <rtems_heap_allocate_aligned_with_boundary>:
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
if (
46f24: 7003 moveq #3,%d0
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
46f26: 4e56 0000 linkw %fp,#0
if (
46f2a: b0b9 0006 43d0 cmpl 643d0 <_System_state_Current>,%d0
46f30: 660a bnes 46f3c <rtems_heap_allocate_aligned_with_boundary+0x18><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
46f32: 4eb9 0004 6054 jsr 46054 <malloc_is_system_state_OK> 46f38: 4a00 tstb %d0
46f3a: 6724 beqs 46f60 <rtems_heap_allocate_aligned_with_boundary+0x3c>
) {
return NULL;
}
malloc_deferred_frees_process();
46f3c: 4eb9 0004 6092 jsr 46092 <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
46f42: 2f2e 0010 movel %fp@(16),%sp@- 46f46: 2f2e 000c movel %fp@(12),%sp@- 46f4a: 2f2e 0008 movel %fp@(8),%sp@- 46f4e: 2f39 0006 2010 movel 62010 <RTEMS_Malloc_Heap>,%sp@- 46f54: 4eb9 0004 b4f4 jsr 4b4f4 <_Protected_heap_Allocate_aligned_with_boundary> 46f5a: 4fef 0010 lea %sp@(16),%sp 46f5e: 6002 bras 46f62 <rtems_heap_allocate_aligned_with_boundary+0x3e>
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
) {
return NULL;
46f60: 4280 clrl %d0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
46f62: 4e5e unlk %fp
...
000424d0 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
424d0: 4e56 ffd4 linkw %fp,#-44 424d4: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@ 424d8: 242e 0008 movel %fp@(8),%d2
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(
424dc: 49f9 0004 df28 lea 4df28 <strlen>,%a4 424e2: 260e movel %fp,%d3 424e4: 0683 ffff ffec addil #-20,%d3 424ea: 2f02 movel %d2,%sp@-
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
424ec: 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(
424f0: 4e94 jsr %a4@ 424f2: 7201 moveq #1,%d1 424f4: 2e81 movel %d1,%sp@ 424f6: 2f03 movel %d3,%sp@- 424f8: 42a7 clrl %sp@- 424fa: 2f00 movel %d0,%sp@- 424fc: 2f02 movel %d2,%sp@- 424fe: 4eb9 0004 290c jsr 4290c <rtems_filesystem_evaluate_path>
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
42504: 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(
42508: 2800 movel %d0,%d4
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
4250a: 2f03 movel %d3,%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;
4250c: 266e ffec moveal %fp@(-20),%a3
node_type = (*loc.ops->node_type_h)( &loc );
42510: 2068 0010 moveal %a0@(16),%a0 42514: 4e90 jsr %a0@
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
42516: 4fef 0018 lea %sp@(24),%sp 4251a: 4a84 tstl %d4
4251c: 6606 bnes 42524 <rtems_io_lookup_name+0x54> <== NEVER TAKEN
4251e: 7202 moveq #2,%d1 42520: b280 cmpl %d0,%d1
42522: 6710 beqs 42534 <rtems_io_lookup_name+0x64>
rtems_filesystem_freenode( &loc );
42524: 486e ffec pea %fp@(-20) 42528: 4eb9 0004 29d8 jsr 429d8 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
4252e: 588f addql #4,%sp 42530: 700d moveq #13,%d0 42532: 6022 bras 42556 <rtems_io_lookup_name+0x86>
}
device_info->device_name = (char *) name;
42534: 2482 movel %d2,%a2@
device_info->device_name_length = strlen( name );
42536: 2f02 movel %d2,%sp@- 42538: 4e94 jsr %a4@ 4253a: 2540 0004 movel %d0,%a2@(4)
device_info->major = the_jnode->info.device.major;
4253e: 256b 004c 0008 movel %a3@(76),%a2@(8)
device_info->minor = the_jnode->info.device.minor;
42544: 256b 0050 000c movel %a3@(80),%a2@(12)
rtems_filesystem_freenode( &loc );
4254a: 2e83 movel %d3,%sp@ 4254c: 4eb9 0004 29d8 jsr 429d8 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
42552: 588f addql #4,%sp 42554: 4280 clrl %d0
}
42556: 4cee 1c1c ffd4 moveml %fp@(-44),%d2-%d4/%a2-%a4
4255c: 4e5e unlk %fp <== NOT EXECUTED
00047dc0 <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)
{
47dc0: 4e56 fff0 linkw %fp,#-16 47dc4: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 47dc8: 286e 0008 moveal %fp@(8),%a4
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
47dcc: 4a8c tstl %a4
47dce: 6738 beqs 47e08 <rtems_iterate_over_all_threads+0x48><== NEVER TAKEN
47dd0: 45f9 0006 0e08 lea 60e08 <_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 ];
47dd6: 205a moveal %a2@+,%a0 47dd8: 2668 0004 moveal %a0@(4),%a3
if ( !information )
47ddc: 4a8b tstl %a3
47dde: 6720 beqs 47e00 <rtems_iterate_over_all_threads+0x40>
47de0: 7401 moveq #1,%d2 47de2: 6012 bras 47df6 <rtems_iterate_over_all_threads+0x36>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
47de4: 206b 0018 moveal %a3@(24),%a0 47de8: 2030 2c00 movel %a0@(00000000,%d2:l:4),%d0
if ( !the_thread )
47dec: 6706 beqs 47df4 <rtems_iterate_over_all_threads+0x34><== NEVER TAKEN
continue;
(*routine)(the_thread);
47dee: 2f00 movel %d0,%sp@- 47df0: 4e94 jsr %a4@ 47df2: 588f addql #4,%sp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
47df4: 5282 addql #1,%d2 47df6: 4280 clrl %d0 47df8: 302b 000e movew %a3@(14),%d0 47dfc: b082 cmpl %d2,%d0
47dfe: 64e4 bccs 47de4 <rtems_iterate_over_all_threads+0x24>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
47e00: b5fc 0006 0e14 cmpal #396820,%a2
47e06: 66ce bnes 47dd6 <rtems_iterate_over_all_threads+0x16>
(*routine)(the_thread);
}
}
}
47e08: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 47e0e: 4e5e unlk %fp
...
00049b74 <rtems_libio_allocate>:
* This routine searches the IOP Table for an unused entry. If it
* finds one, it returns it. Otherwise, it returns NULL.
*/
rtems_libio_t *rtems_libio_allocate( void )
{
49b74: 4e56 fffc linkw %fp,#-4 49b78: 2f0a movel %a2,%sp@- 49b7a: 2f02 movel %d2,%sp@-
rtems_libio_t *iop, *next;
rtems_status_code rc;
rtems_id sema;
rtems_libio_lock();
49b7c: 4eba ff36 jsr %pc@(49ab4 <rtems_libio_lock>)
if (rtems_libio_iop_freelist) {
49b80: 2039 0005 e878 movel 5e878 <rtems_libio_iop_freelist>,%d0
49b86: 676a beqs 49bf2 <rtems_libio_allocate+0x7e> <== NEVER TAKEN
rc = rtems_semaphore_create(
49b88: 486e fffc pea %fp@(-4)
RTEMS_LIBIO_IOP_SEM(rtems_libio_iop_freelist - rtems_libio_iops),
49b8c: 90b9 0005 e874 subl 5e874 <rtems_libio_iops>,%d0 49b92: 223c b6db 6db7 movel #-1227133513,%d1
rtems_id sema;
rtems_libio_lock();
if (rtems_libio_iop_freelist) {
rc = rtems_semaphore_create(
49b98: 42a7 clrl %sp@- 49b9a: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
RTEMS_LIBIO_IOP_SEM(rtems_libio_iop_freelist - rtems_libio_iops),
49b9e: e680 asrl #3,%d0 49ba0: 4c01 0800 mulsl %d1,%d0
rtems_id sema;
rtems_libio_lock();
if (rtems_libio_iop_freelist) {
rc = rtems_semaphore_create(
49ba4: 4878 0001 pea 1 <ADD> 49ba8: 0080 4c42 4900 oril #1279412480,%d0 49bae: 2f00 movel %d0,%sp@- 49bb0: 4eb9 0004 561c jsr 4561c <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
0,
&sema
);
if (rc != RTEMS_SUCCESSFUL)
49bb6: 4fef 0014 lea %sp@(20),%sp 49bba: 4a80 tstl %d0
49bbc: 6634 bnes 49bf2 <rtems_libio_allocate+0x7e>
goto failed;
iop = rtems_libio_iop_freelist;
49bbe: 2479 0005 e878 moveal 5e878 <rtems_libio_iop_freelist>,%a2
next = iop->data1;
49bc4: 242a 0034 movel %a2@(52),%d2
(void) memset( iop, 0, sizeof(rtems_libio_t) );
49bc8: 4878 0038 pea 38 <DBL_MANT_DIG+0x3> 49bcc: 42a7 clrl %sp@- 49bce: 2f0a movel %a2,%sp@- 49bd0: 4eb9 0004 d3ec jsr 4d3ec <memset>
iop->flags = LIBIO_FLAGS_OPEN;
iop->sem = sema;
49bd6: 256e fffc 002c movel %fp@(-4),%a2@(44)
if (rc != RTEMS_SUCCESSFUL)
goto failed;
iop = rtems_libio_iop_freelist;
next = iop->data1;
(void) memset( iop, 0, sizeof(rtems_libio_t) );
iop->flags = LIBIO_FLAGS_OPEN;
49bdc: 203c 0000 0100 movel #256,%d0
iop->sem = sema;
rtems_libio_iop_freelist = next;
goto done;
49be2: 4fef 000c lea %sp@(12),%sp
if (rc != RTEMS_SUCCESSFUL)
goto failed;
iop = rtems_libio_iop_freelist;
next = iop->data1;
(void) memset( iop, 0, sizeof(rtems_libio_t) );
iop->flags = LIBIO_FLAGS_OPEN;
49be6: 2540 0014 movel %d0,%a2@(20)
iop->sem = sema;
rtems_libio_iop_freelist = next;
49bea: 23c2 0005 e878 movel %d2,5e878 <rtems_libio_iop_freelist>
goto done;
49bf0: 6002 bras 49bf4 <rtems_libio_allocate+0x80>
}
failed:
iop = 0;
49bf2: 95ca subal %a2,%a2
done:
rtems_libio_unlock();
49bf4: 4eba feda jsr %pc@(49ad0 <rtems_libio_unlock>)
return iop; }
49bf8: 242e fff4 movel %fp@(-12),%d2 49bfc: 200a movel %a2,%d0 49bfe: 246e fff8 moveal %fp@(-8),%a2
49c02: 4e5e unlk %fp <== NOT EXECUTED
00049c06 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
49c06: 4e56 0000 linkw %fp,#0 49c0a: 2f0a movel %a2,%sp@- 49c0c: 246e 0008 moveal %fp@(8),%a2
rtems_libio_lock();
49c10: 4eba fea2 jsr %pc@(49ab4 <rtems_libio_lock>)
if (iop->sem)
49c14: 202a 002c movel %a2@(44),%d0
49c18: 670a beqs 49c24 <rtems_libio_free+0x1e> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
49c1a: 2f00 movel %d0,%sp@- 49c1c: 4eb9 0004 57b8 jsr 457b8 <rtems_semaphore_delete> 49c22: 588f addql #4,%sp
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
49c24: 41f9 0005 e878 lea 5e878 <rtems_libio_iop_freelist>,%a0
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
49c2a: 203c ffff feff movel #-257,%d0
iop->data1 = rtems_libio_iop_freelist;
49c30: 2550 0034 movel %a0@,%a2@(52)
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
49c34: c1aa 0014 andl %d0,%a2@(20)
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
49c38: 23ca 0005 e878 movel %a2,5e878 <rtems_libio_iop_freelist>
rtems_libio_unlock();
}
49c3e: 246e fffc moveal %fp@(-4),%a2 49c42: 4e5e unlk %fp
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
49c44: 6000 fe8a braw 49ad0 <rtems_libio_unlock>
00042af8 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
42af8: 4e56 0000 linkw %fp,#0 42afc: 2f02 movel %d2,%sp@-
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
42afe: 2439 0005 cff4 movel 5cff4 <rtems_libio_number_iops>,%d2
42b04: 6744 beqs 42b4a <rtems_libio_init+0x52> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
42b06: 4878 0038 pea 38 <DBL_MANT_DIG+0x3> 42b0a: 2f02 movel %d2,%sp@- 42b0c: 4eb9 0004 2654 jsr 42654 <calloc>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
42b12: 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,
42b14: 23c0 0005 e874 movel %d0,5e874 <rtems_libio_iops>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
42b1a: 6606 bnes 42b22 <rtems_libio_init+0x2a>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
42b1c: 4878 001a pea 1a <OPER2+0x6> 42b20: 604e bras 42b70 <rtems_libio_init+0x78>
iop = rtems_libio_iop_freelist = rtems_libio_iops;
42b22: 23c0 0005 e878 movel %d0,5e878 <rtems_libio_iop_freelist> 42b28: 2040 moveal %d0,%a0
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
42b2a: 4281 clrl %d1 42b2c: 6004 bras 42b32 <rtems_libio_init+0x3a>
iop->data1 = iop + 1;
42b2e: 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++)
42b32: 5281 addql #1,%d1 42b34: 41e8 0038 lea %a0@(56),%a0 42b38: b481 cmpl %d1,%d2
42b3a: 62f2 bhis 42b2e <rtems_libio_init+0x36>
iop->data1 = iop + 1;
iop->data1 = NULL;
42b3c: 2202 movel %d2,%d1 42b3e: 2040 moveal %d0,%a0 42b40: e789 lsll #3,%d1 42b42: ed8a lsll #6,%d2 42b44: 9481 subl %d1,%d2 42b46: 42b0 28fc clrl %a0@(fffffffc,%d2:l)
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
42b4a: 4879 0005 e87c pea 5e87c <rtems_libio_semaphore> 42b50: 42a7 clrl %sp@- 42b52: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f> 42b56: 4878 0001 pea 1 <ADD> 42b5a: 2f3c 4c42 494f movel #1279412559,%sp@- 42b60: 4eb9 0004 561c jsr 4561c <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
42b66: 4fef 0014 lea %sp@(20),%sp 42b6a: 4a80 tstl %d0
42b6c: 6708 beqs 42b76 <rtems_libio_init+0x7e> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
42b6e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
42b70: 4eb9 0004 5efc jsr 45efc <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
42b76: 2279 0005 cff0 moveal 5cff0 <rtems_fs_init_helper>,%a1 42b7c: 4a89 tstl %a1
42b7e: 6708 beqs 42b88 <rtems_libio_init+0x90> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
42b80: 242e fffc movel %fp@(-4),%d2 42b84: 4e5e unlk %fp
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
42b86: 4ed1 jmp %a1@
}
42b88: 242e fffc movel %fp@(-4),%d2 <== NOT EXECUTED 42b8c: 4e5e unlk %fp <== NOT EXECUTED
00043eb0 <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)
{
43eb0: 4e56 fff8 linkw %fp,#-8 43eb4: 2f03 movel %d3,%sp@- 43eb6: 262e 0008 movel %fp@(8),%d3 43eba: 2f02 movel %d2,%sp@-
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
43ebc: 4eb9 0004 6534 jsr 46534 <rtems_task_self> 43ec2: 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 )
43ec4: b083 cmpl %d3,%d0
43ec6: 6740 beqs 43f08 <rtems_libio_share_private_env+0x58><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
43ec8: 486e fffc pea %fp@(-4) 43ecc: 4879 0005 da4c pea 5da4c <rtems_current_user_env> 43ed2: 2f03 movel %d3,%sp@- 43ed4: 4eb9 0004 6688 jsr 46688 <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
43eda: 4fef 000c lea %sp@(12),%sp 43ede: 4a80 tstl %d0
43ee0: 6628 bnes 43f0a <rtems_libio_share_private_env+0x5a><== NEVER TAKEN
* 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) {
43ee2: 2079 0005 da4c moveal 5da4c <rtems_current_user_env>,%a0 43ee8: b490 cmpl %a0@,%d2
43eea: 6610 bnes 43efc <rtems_libio_share_private_env+0x4c><== NEVER TAKEN
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
43eec: 2f08 movel %a0,%sp@- 43eee: 2d40 fff8 movel %d0,%fp@(-8) 43ef2: 4eba fe70 jsr %pc@(43d64 <free_user_env>) 43ef6: 202e fff8 movel %fp@(-8),%d0 43efa: 588f addql #4,%sp
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
43efc: 41ee fffc lea %fp@(-4),%a0 43f00: 23d0 0005 da4c movel %a0@,5da4c <rtems_current_user_env>
/* increase the reference count */
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
43f06: 6002 bras 43f0a <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;
43f08: 4280 clrl %d0 <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
43f0a: 242e fff0 movel %fp@(-16),%d2 43f0e: 262e fff4 movel %fp@(-12),%d3 43f12: 4e5e unlk %fp
...
00049b26 <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49b26: 7006 moveq #6,%d0
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
49b28: 4e56 0000 linkw %fp,#0 49b2c: 222e 0008 movel %fp@(8),%d1
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49b30: c081 andl %d1,%d0
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
49b32: 2f02 movel %d2,%sp@-
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49b34: 7406 moveq #6,%d2 49b36: b480 cmpl %d0,%d2
49b38: 6710 beqs 49b4a <rtems_libio_to_fcntl_flags+0x24>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
49b3a: 0801 0001 btst #1,%d1
49b3e: 660e bnes 49b4e <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;
49b40: 44c1 movew %d1,%ccr <== NOT EXECUTED 49b42: 57c0 seq %d0 <== NOT EXECUTED 49b44: 49c0 extbl %d0 <== NOT EXECUTED 49b46: 4480 negl %d0 <== NOT EXECUTED 49b48: 6006 bras 49b50 <rtems_libio_to_fcntl_flags+0x2a><== NOT EXECUTED
49b4a: 7002 moveq #2,%d0 49b4c: 6002 bras 49b50 <rtems_libio_to_fcntl_flags+0x2a>
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
49b4e: 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 ) {
49b50: 0801 0000 btst #0,%d1
49b54: 6704 beqs 49b5a <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_NONBLOCK;
49b56: 08c0 000e bset #14,%d0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
49b5a: 0801 0009 btst #9,%d1
49b5e: 6704 beqs 49b64 <rtems_libio_to_fcntl_flags+0x3e>
fcntl_flags |= O_APPEND;
49b60: 7408 moveq #8,%d2 49b62: 8082 orl %d2,%d0
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
49b64: 0801 000a btst #10,%d1
49b68: 6704 beqs 49b6e <rtems_libio_to_fcntl_flags+0x48>
fcntl_flags |= O_CREAT;
49b6a: 08c0 0009 bset #9,%d0
}
return fcntl_flags;
}
49b6e: 241f movel %sp@+,%d2
49b70: 4e5e unlk %fp <== NOT EXECUTED
000463a4 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
463a4: 4e56 fffc linkw %fp,#-4 463a8: 2f03 movel %d3,%sp@- 463aa: 2f02 movel %d2,%sp@-
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
463ac: 486e fffc pea %fp@(-4) 463b0: 2f2e 0008 movel %fp@(8),%sp@- 463b4: 2f39 0006 2010 movel 62010 <RTEMS_Malloc_Heap>,%sp@- 463ba: 4eb9 0004 b5ac jsr 4b5ac <_Protected_heap_Get_block_size> 463c0: 4fef 000c lea %sp@(12),%sp 463c4: 4a00 tstb %d0
463c6: 671a beqs 463e2 <rtems_malloc_statistics_at_free+0x3e><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
463c8: 262e fffc movel %fp@(-4),%d3 463cc: 4282 clrl %d2 463ce: d7b9 0006 4170 addl %d3,64170 <rtems_malloc_statistics+0x28> 463d4: 2039 0006 416c movel 6416c <rtems_malloc_statistics+0x24>,%d0 463da: d182 addxl %d2,%d0 463dc: 23c0 0006 416c movel %d0,6416c <rtems_malloc_statistics+0x24>
} }
463e2: 242e fff4 movel %fp@(-12),%d2 463e6: 262e fff8 movel %fp@(-8),%d3
463ea: 4e5e unlk %fp <== NOT EXECUTED
000463ee <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
463ee: 4e56 fffc linkw %fp,#-4 463f2: 202e 0008 movel %fp@(8),%d0 463f6: 2f03 movel %d3,%sp@-
uintptr_t actual_size = 0;
463f8: 42ae fffc clrl %fp@(-4)
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
463fc: 2f02 movel %d2,%sp@-
uintptr_t actual_size = 0;
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
463fe: 4a80 tstl %d0
46400: 674c beqs 4644e <rtems_malloc_statistics_at_malloc+0x60><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
46402: 486e fffc pea %fp@(-4)
MSBUMP(lifetime_allocated, actual_size);
46406: 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);
46408: 2f00 movel %d0,%sp@- 4640a: 2f39 0006 2010 movel 62010 <RTEMS_Malloc_Heap>,%sp@- 46410: 4eb9 0004 b5ac jsr 4b5ac <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
46416: 262e fffc movel %fp@(-4),%d3
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
4641a: 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);
4641e: 2039 0006 4164 movel 64164 <rtems_malloc_statistics+0x1c>,%d0 46424: d6b9 0006 4168 addl 64168 <rtems_malloc_statistics+0x20>,%d3 4642a: d580 addxl %d0,%d2
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
4642c: 2003 movel %d3,%d0 4642e: 90b9 0006 4170 subl 64170 <rtems_malloc_statistics+0x28>,%d0
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
46434: 23c2 0006 4164 movel %d2,64164 <rtems_malloc_statistics+0x1c> 4643a: 23c3 0006 4168 movel %d3,64168 <rtems_malloc_statistics+0x20>
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
46440: b0b9 0006 4160 cmpl 64160 <rtems_malloc_statistics+0x18>,%d0
46446: 6306 blss 4644e <rtems_malloc_statistics_at_malloc+0x60>
s->max_depth = current_depth;
46448: 23c0 0006 4160 movel %d0,64160 <rtems_malloc_statistics+0x18>
}
4644e: 242e fff4 movel %fp@(-12),%d2 46452: 262e fff8 movel %fp@(-8),%d3
46456: 4e5e unlk %fp <== NOT EXECUTED
0004d464 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
4d464: 4e56 0000 linkw %fp,#0 4d468: 2f0a movel %a2,%sp@- 4d46a: 246e 0008 moveal %fp@(8),%a2 4d46e: 2f02 movel %d2,%sp@-
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
4d470: 4a8a tstl %a2
4d472: 6754 beqs 4d4c8 <rtems_memalign+0x64>
return EINVAL;
*pointer = NULL;
4d474: 4292 clrl %a2@
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
4d476: 7003 moveq #3,%d0 4d478: b0b9 0006 213c cmpl 6213c <_System_state_Current>,%d0
4d47e: 660a bnes 4d48a <rtems_memalign+0x26> <== NEVER TAKEN
!malloc_is_system_state_OK() )
4d480: 4eb9 0004 3840 jsr 43840 <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()) &&
4d486: 4a00 tstb %d0
4d488: 673e beqs 4d4c8 <rtems_memalign+0x64> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
4d48a: 4eb9 0004 387e jsr 4387e <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
4d490: 42a7 clrl %sp@- 4d492: 2f2e 000c movel %fp@(12),%sp@- 4d496: 2f2e 0010 movel %fp@(16),%sp@- 4d49a: 2f39 0006 05b0 movel 605b0 <RTEMS_Malloc_Heap>,%sp@- 4d4a0: 4eb9 0004 814c jsr 4814c <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
4d4a6: 4fef 0010 lea %sp@(16),%sp 4d4aa: 2400 movel %d0,%d2
4d4ac: 671e beqs 4d4cc <rtems_memalign+0x68>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
4d4ae: 2079 0006 0d96 moveal 60d96 <rtems_malloc_statistics_helpers>,%a0 4d4b4: 4a88 tstl %a0
4d4b6: 670a beqs 4d4c2 <rtems_memalign+0x5e>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
4d4b8: 2f0a movel %a2,%sp@- 4d4ba: 2068 0004 moveal %a0@(4),%a0 4d4be: 4e90 jsr %a0@ 4d4c0: 588f addql #4,%sp
*pointer = return_this;
4d4c2: 2482 movel %d2,%a2@
return 0;
4d4c4: 4280 clrl %d0 4d4c6: 6006 bras 4d4ce <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;
4d4c8: 7016 moveq #22,%d0 4d4ca: 6002 bras 4d4ce <rtems_memalign+0x6a>
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
4d4cc: 700c moveq #12,%d0
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
4d4ce: 242e fff8 movel %fp@(-8),%d2 4d4d2: 246e fffc moveal %fp@(-4),%a2 4d4d6: 4e5e unlk %fp
...
0004bd30 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
4bd30: 4e56 ff90 linkw %fp,#-112 4bd34: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int success = 0; char *dup_path = strdup(path);
4bd38: 2f2e 0008 movel %fp@(8),%sp@- 4bd3c: 4eb9 0004 f2f8 jsr 4f2f8 <strdup>
if (dup_path != NULL) {
4bd42: 588f addql #4,%sp
int
rtems_mkdir(const char *path, mode_t mode)
{
int success = 0;
char *dup_path = strdup(path);
4bd44: 2440 moveal %d0,%a2
if (dup_path != NULL) {
4bd46: 4a80 tstl %d0 4bd48: 6700 0122 beqw 4be6c <rtems_mkdir+0x13c>
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bd4c: 722f moveq #47,%d1 4bd4e: 1012 moveb %a2@,%d0 4bd50: 49c0 extbl %d0 4bd52: b280 cmpl %d0,%d1
4bd54: 6606 bnes 4bd5c <rtems_mkdir+0x2c>
++p;
4bd56: 47ea 0001 lea %a2@(1),%a3 4bd5a: 6002 bras 4bd5e <rtems_mkdir+0x2e>
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bd5c: 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) {
4bd5e: 2c0e movel %fp,%d6
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
4bd60: 2a4b moveal %a3,%a5
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bd62: 4283 clrl %d3 4bd64: 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) {
4bd66: 2e3c 0004 3f48 movel #278344,%d7
if (errno == EEXIST || errno == EISDIR) {
4bd6c: 283c 0004 e348 movel #320328,%d4
if (stat(path, &sb) < 0) {
4bd72: 0686 ffff ffba addil #-70,%d6 4bd78: 2a3c 0004 be88 movel #310920,%d5
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
4bd7e: 49f9 0004 bf2c lea 4bf2c <umask>,%a4
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
4bd84: 121d moveb %a5@+,%d1
4bd86: 670e beqs 4bd96 <rtems_mkdir+0x66>
last = 1;
else if (p[0] != '/')
4bd88: 49c1 extbl %d1 4bd8a: 742f moveq #47,%d2 4bd8c: b481 cmpl %d1,%d2 4bd8e: 6600 00b8 bnew 4be48 <rtems_mkdir+0x118> 4bd92: 4281 clrl %d1 4bd94: 6002 bras 4bd98 <rtems_mkdir+0x68>
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
4bd96: 7201 moveq #1,%d1
else if (p[0] != '/')
continue;
*p = '\0';
4bd98: 4213 clrb %a3@
if (!last && p[1] == '\0')
4bd9a: 4a81 tstl %d1
4bd9c: 660a bnes 4bda8 <rtems_mkdir+0x78>
4bd9e: 4a15 tstb %a5@ 4bda0: 57c2 seq %d2 4bda2: 49c2 extbl %d2 4bda4: 4482 negl %d2 4bda6: 6002 bras 4bdaa <rtems_mkdir+0x7a> 4bda8: 7401 moveq #1,%d2
last = 1;
if (first) {
4bdaa: 4a80 tstl %d0
4bdac: 6712 beqs 4bdc0 <rtems_mkdir+0x90>
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
4bdae: 42a7 clrl %sp@- 4bdb0: 4e94 jsr %a4@ 4bdb2: 2600 movel %d0,%d3
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
4bdb4: 0280 ffff ff3f andil #-193,%d0 4bdba: 2f00 movel %d0,%sp@- 4bdbc: 4e94 jsr %a4@ 4bdbe: 508f addql #8,%sp
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bdc0: 203c 0000 01ff movel #511,%d0
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
4bdc6: 4a82 tstl %d2
4bdc8: 670a beqs 4bdd4 <rtems_mkdir+0xa4>
(void)umask(oumask);
4bdca: 2f03 movel %d3,%sp@- 4bdcc: 4e94 jsr %a4@
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bdce: 202e 000c movel %fp@(12),%d0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
4bdd2: 588f addql #4,%sp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bdd4: 2f00 movel %d0,%sp@- 4bdd6: 2047 moveal %d7,%a0 4bdd8: 2f0a movel %a2,%sp@- 4bdda: 4e90 jsr %a0@ 4bddc: 508f addql #8,%sp 4bdde: 4a80 tstl %d0
4bde0: 6c5c bges 4be3e <rtems_mkdir+0x10e>
if (errno == EEXIST || errno == EISDIR) {
4bde2: 2044 moveal %d4,%a0 4bde4: 4e90 jsr %a0@ 4bde6: 7211 moveq #17,%d1 4bde8: 2040 moveal %d0,%a0 4bdea: b290 cmpl %a0@,%d1
4bdec: 670c beqs 4bdfa <rtems_mkdir+0xca>
4bdee: 2044 moveal %d4,%a0 4bdf0: 4e90 jsr %a0@ 4bdf2: 7215 moveq #21,%d1 4bdf4: 2040 moveal %d0,%a0 4bdf6: b290 cmpl %a0@,%d1
4bdf8: 667e bnes 4be78 <rtems_mkdir+0x148> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
4bdfa: 2f06 movel %d6,%sp@- 4bdfc: 2045 moveal %d5,%a0 4bdfe: 2f0a movel %a2,%sp@- 4be00: 4e90 jsr %a0@ 4be02: 508f addql #8,%sp 4be04: 4a80 tstl %d0
4be06: 6d70 blts 4be78 <rtems_mkdir+0x148> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
4be08: 202e ffc6 movel %fp@(-58),%d0 4be0c: 0280 0000 f000 andil #61440,%d0 4be12: 0c80 0000 4000 cmpil #16384,%d0
4be18: 671e beqs 4be38 <rtems_mkdir+0x108>
4be1a: 41f9 0004 e348 lea 4e348 <__errno>,%a0
if (last)
4be20: 4a82 tstl %d2
4be22: 670a beqs 4be2e <rtems_mkdir+0xfe>
errno = EEXIST;
4be24: 4e90 jsr %a0@ 4be26: 7211 moveq #17,%d1 4be28: 2040 moveal %d0,%a0 4be2a: 2081 movel %d1,%a0@ 4be2c: 602a bras 4be58 <rtems_mkdir+0x128>
else
errno = ENOTDIR;
4be2e: 4e90 jsr %a0@ 4be30: 2040 moveal %d0,%a0 4be32: 7014 moveq #20,%d0 4be34: 2080 movel %d0,%a0@ 4be36: 6016 bras 4be4e <rtems_mkdir+0x11e>
retval = 0;
break;
}
if (last)
4be38: 4a82 tstl %d2
4be3a: 6642 bnes 4be7e <rtems_mkdir+0x14e>
4be3c: 6004 bras 4be42 <rtems_mkdir+0x112>
} else {
retval = 0;
break;
}
}
if (!last)
4be3e: 4a82 tstl %d2
4be40: 6640 bnes 4be82 <rtems_mkdir+0x152>
*p = '/';
4be42: 4280 clrl %d0 4be44: 16bc 002f moveb #47,%a3@
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
4be48: 528b addql #1,%a3 4be4a: 6000 ff38 braw 4bd84 <rtems_mkdir+0x54>
}
if (!last)
*p = '/';
}
if (!first && !last)
(void)umask(oumask);
4be4e: 2f03 movel %d3,%sp@- 4be50: 4eb9 0004 bf2c jsr 4bf2c <umask> 4be56: 588f addql #4,%sp 4be58: 4282 clrl %d2
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
4be5a: 2f0a movel %a2,%sp@- 4be5c: 4eb9 0004 3930 jsr 43930 <free>
}
return success != 0 ? 0 : -1;
4be62: 588f addql #4,%sp 4be64: 4a82 tstl %d2 4be66: 57c0 seq %d0 4be68: 49c0 extbl %d0 4be6a: 6002 bras 4be6e <rtems_mkdir+0x13e>
4be6c: 70ff moveq #-1,%d0 <== NOT EXECUTED
}
4be6e: 4cee 3cfc ff90 moveml %fp@(-112),%d2-%d7/%a2-%a5 4be74: 4e5e unlk %fp 4be76: 4e75 rts
}
}
if (!last)
*p = '/';
}
if (!first && !last)
4be78: 4a82 tstl %d2
4be7a: 67d2 beqs 4be4e <rtems_mkdir+0x11e> <== NEVER TAKEN
4be7c: 60da bras 4be58 <rtems_mkdir+0x128>
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
4be7e: 7402 moveq #2,%d2 4be80: 60d8 bras 4be5a <rtems_mkdir+0x12a>
} else {
retval = 0;
break;
}
}
if (!last)
4be82: 7401 moveq #1,%d2 4be84: 60d4 bras 4be5a <rtems_mkdir+0x12a>
...
00042866 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
42866: 4e56 0000 linkw %fp,#0
va_list arglist;
va_start(arglist, printf_format);
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
4286a: 486e 000c pea %fp@(12) 4286e: 2f2e 0008 movel %fp@(8),%sp@- 42872: 2f3c 2000 0000 movel #536870912,%sp@- 42878: 4eba fe3e jsr %pc@(426b8 <rtems_verror>)
va_end(arglist);
rtems_error(0, "fatal error, exiting");
4287c: 4879 0005 bc34 pea 5bc34 <IMFS_ops+0x7e> 42882: 42a7 clrl %sp@- 42884: 4eb9 0004 2804 jsr 42804 <rtems_error>
_exit(errno);
4288a: 4eb9 0004 cad0 jsr 4cad0 <__errno> 42890: 2040 moveal %d0,%a0 42892: 2f10 movel %a0@,%sp@- 42894: 4eb9 0004 31b8 jsr 431b8 <_exit>
...
00050188 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
50188: 4e56 fffc linkw %fp,#-4 5018c: 2f0a movel %a2,%sp@- 5018e: 2f02 movel %d2,%sp@-
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
50190: 486e fffc pea %fp@(-4) 50194: 2f2e 0008 movel %fp@(8),%sp@- 50198: 4879 0007 73b2 pea 773b2 <_Partition_Information> 5019e: 242e 000c movel %fp@(12),%d2 501a2: 4eb9 0005 46c4 jsr 546c4 <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
501a8: 4fef 000c lea %sp@(12),%sp 501ac: 2440 moveal %d0,%a2 501ae: 4aae fffc tstl %fp@(-4)
501b2: 663e bnes 501f2 <rtems_partition_return_buffer+0x6a>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
501b4: 202a 0010 movel %a2@(16),%d0
ending = _Addresses_Add_offset( starting, the_partition->length );
501b8: 222a 0014 movel %a2@(20),%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
501bc: b082 cmpl %d2,%d0
501be: 6240 bhis 50200 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
501c0: d280 addl %d0,%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
501c2: b282 cmpl %d2,%d1
501c4: 653a bcss 50200 <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);
501c6: 2202 movel %d2,%d1 501c8: 9280 subl %d0,%d1 501ca: 2001 movel %d1,%d0
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
501cc: 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 ) &&
501d2: 4a81 tstl %d1
501d4: 662a bnes 50200 <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 );
501d6: 2f02 movel %d2,%sp@- 501d8: 486a 0024 pea %a2@(36) 501dc: 4eb9 0005 2d24 jsr 52d24 <_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;
501e2: 53aa 0020 subql #1,%a2@(32)
_Thread_Enable_dispatch();
501e6: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
501ec: 508f addql #8,%sp 501ee: 4280 clrl %d0 501f0: 6002 bras 501f4 <rtems_partition_return_buffer+0x6c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
501f2: 7004 moveq #4,%d0
}
501f4: 242e fff4 movel %fp@(-12),%d2 501f8: 246e fff8 moveal %fp@(-8),%a2 501fc: 4e5e unlk %fp 501fe: 4e75 rts
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
50200: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
50206: 7009 moveq #9,%d0 50208: 60ea bras 501f4 <rtems_partition_return_buffer+0x6c>
...
0004f7ac <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
rtems_id id,
void *internal,
void **external
)
{
4f7ac: 4e56 fffc linkw %fp,#-4 4f7b0: 2f0a movel %a2,%sp@- 4f7b2: 246e 0010 moveal %fp@(16),%a2 4f7b6: 2f02 movel %d2,%sp@- 4f7b8: 242e 000c movel %fp@(12),%d2
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
4f7bc: 4a8a tstl %a2
4f7be: 6740 beqs 4f800 <rtems_port_internal_to_external+0x54><== NEVER TAKEN
4f7c0: 486e fffc pea %fp@(-4) 4f7c4: 2f2e 0008 movel %fp@(8),%sp@- 4f7c8: 4879 0007 7378 pea 77378 <_Dual_ported_memory_Information> 4f7ce: 4eb9 0005 46c4 jsr 546c4 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
4f7d4: 4fef 000c lea %sp@(12),%sp 4f7d8: 2040 moveal %d0,%a0 4f7da: 4aae fffc tstl %fp@(-4)
4f7de: 6624 bnes 4f804 <rtems_port_internal_to_external+0x58><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
4f7e0: 2002 movel %d2,%d0 4f7e2: 90a8 0010 subl %a0@(16),%d0
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
4f7e6: b0a8 0018 cmpl %a0@(24),%d0
4f7ea: 6304 blss 4f7f0 <rtems_port_internal_to_external+0x44>
*external = internal;
4f7ec: 2482 movel %d2,%a2@ 4f7ee: 6006 bras 4f7f6 <rtems_port_internal_to_external+0x4a>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
4f7f0: d0a8 0014 addl %a0@(20),%d0 4f7f4: 2480 movel %d0,%a2@
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
4f7f6: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4f7fc: 4280 clrl %d0 4f7fe: 6006 bras 4f806 <rtems_port_internal_to_external+0x5a>
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
return RTEMS_INVALID_ADDRESS;
4f800: 7009 moveq #9,%d0 4f802: 6002 bras 4f806 <rtems_port_internal_to_external+0x5a>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4f804: 7004 moveq #4,%d0
}
4f806: 242e fff4 movel %fp@(-12),%d2 4f80a: 246e fff8 moveal %fp@(-8),%a2 4f80e: 4e5e unlk %fp
...
0004bfb4 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
4bfb4: 4e56 fffc linkw %fp,#-4 4bfb8: 2f0a movel %a2,%sp@- 4bfba: 246e 000c moveal %fp@(12),%a2
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
4bfbe: 4a8a tstl %a2 4bfc0: 6700 0096 beqw 4c058 <rtems_rate_monotonic_get_statistics+0xa4> 4bfc4: 486e fffc pea %fp@(-4) 4bfc8: 2f2e 0008 movel %fp@(8),%sp@- 4bfcc: 4879 0006 04ec pea 604ec <_Rate_monotonic_Information> 4bfd2: 4eb9 0004 8540 jsr 48540 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
4bfd8: 4fef 000c lea %sp@(12),%sp 4bfdc: 2040 moveal %d0,%a0 4bfde: 4aae fffc tstl %fp@(-4)
4bfe2: 6678 bnes 4c05c <rtems_rate_monotonic_get_statistics+0xa8><== NEVER TAKEN
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
4bfe4: 24a8 0054 movel %a0@(84),%a2@
dst->missed_count = src->missed_count;
4bfe8: 2568 0058 0004 movel %a0@(88),%a2@(4)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
4bfee: 2028 005c movel %a0@(92),%d0 4bff2: 2228 0060 movel %a0@(96),%d1 4bff6: 2540 0008 movel %d0,%a2@(8) 4bffa: 2541 000c movel %d1,%a2@(12)
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
4bffe: 2028 0064 movel %a0@(100),%d0 4c002: 2228 0068 movel %a0@(104),%d1 4c006: 2540 0010 movel %d0,%a2@(16) 4c00a: 2541 0014 movel %d1,%a2@(20)
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
4c00e: 2028 006c movel %a0@(108),%d0 4c012: 2228 0070 movel %a0@(112),%d1 4c016: 2540 0018 movel %d0,%a2@(24) 4c01a: 2541 001c movel %d1,%a2@(28)
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
4c01e: 2028 0074 movel %a0@(116),%d0 4c022: 2228 0078 movel %a0@(120),%d1 4c026: 2540 0020 movel %d0,%a2@(32) 4c02a: 2541 0024 movel %d1,%a2@(36)
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
4c02e: 2028 007c movel %a0@(124),%d0 4c032: 2228 0080 movel %a0@(128),%d1 4c036: 2540 0028 movel %d0,%a2@(40) 4c03a: 2541 002c movel %d1,%a2@(44)
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
4c03e: 2028 0084 movel %a0@(132),%d0 4c042: 2228 0088 movel %a0@(136),%d1 4c046: 2540 0030 movel %d0,%a2@(48) 4c04a: 2541 0034 movel %d1,%a2@(52)
dst->min_wall_time = src->min_wall_time;
dst->max_wall_time = src->max_wall_time;
dst->total_wall_time = src->total_wall_time;
#endif
_Thread_Enable_dispatch();
4c04e: 4eb9 0004 90ea jsr 490ea <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4c054: 4280 clrl %d0 4c056: 6006 bras 4c05e <rtems_rate_monotonic_get_statistics+0xaa>
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
4c058: 7009 moveq #9,%d0 4c05a: 6002 bras 4c05e <rtems_rate_monotonic_get_statistics+0xaa>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4c05c: 7004 moveq #4,%d0
}
4c05e: 246e fff8 moveal %fp@(-8),%a2 4c062: 4e5e unlk %fp
...
00046586 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
46586: 4e56 ffec linkw %fp,#-20 4658a: 48d7 041c moveml %d2-%d4/%a2,%sp@
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
4658e: 486e fffc pea %fp@(-4) 46592: 262e 0008 movel %fp@(8),%d3 46596: 2f03 movel %d3,%sp@- 46598: 4879 0006 04ec pea 604ec <_Rate_monotonic_Information> 4659e: 242e 000c movel %fp@(12),%d2 465a2: 4eb9 0004 8540 jsr 48540 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
465a8: 4fef 000c lea %sp@(12),%sp 465ac: 2440 moveal %d0,%a2 465ae: 4aae fffc tstl %fp@(-4) 465b2: 6600 0148 bnew 466fc <rtems_rate_monotonic_period+0x176>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
465b6: 2039 0006 0a4c movel 60a4c <_Per_CPU_Information+0xc>,%d0 465bc: b0aa 0040 cmpl %a2@(64),%d0
465c0: 670c beqs 465ce <rtems_rate_monotonic_period+0x48>
_Thread_Enable_dispatch();
465c2: 4eb9 0004 90ea jsr 490ea <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
465c8: 7417 moveq #23,%d2 465ca: 6000 0132 braw 466fe <rtems_rate_monotonic_period+0x178>
}
if ( length == RTEMS_PERIOD_STATUS ) {
465ce: 4a82 tstl %d2
465d0: 6622 bnes 465f4 <rtems_rate_monotonic_period+0x6e>
switch ( the_period->state ) {
465d2: 202a 0038 movel %a2@(56),%d0 465d6: 7204 moveq #4,%d1 465d8: b280 cmpl %d0,%d1
465da: 650c bcss 465e8 <rtems_rate_monotonic_period+0x62><== NEVER TAKEN
465dc: 41f9 0005 db46 lea 5db46 <CSWTCH.2>,%a0 465e2: 2430 0c00 movel %a0@(00000000,%d0:l:4),%d2 465e6: 6002 bras 465ea <rtems_rate_monotonic_period+0x64>
465e8: 4282 clrl %d2 <== NOT EXECUTED
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
465ea: 4eb9 0004 90ea jsr 490ea <_Thread_Enable_dispatch>
return( return_value );
465f0: 6000 010c braw 466fe <rtems_rate_monotonic_period+0x178>
}
_ISR_Disable( level );
465f4: 203c 0000 0700 movel #1792,%d0 465fa: 40c4 movew %sr,%d4 465fc: 8084 orl %d4,%d0 465fe: 46c0 movew %d0,%sr
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
46600: 202a 0038 movel %a2@(56),%d0
46604: 664a bnes 46650 <rtems_rate_monotonic_period+0xca>
_ISR_Enable( level );
46606: 46c4 movew %d4,%sr
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
46608: 2f0a movel %a2,%sp@- 4660a: 4eb9 0004 641a jsr 4641a <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
46610: 7002 moveq #2,%d0
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
46612: 223c 0004 6948 movel #289096,%d1 46618: 2540 0038 movel %d0,%a2@(56) 4661c: 2541 002c movel %d1,%a2@(44)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
46620: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine; the_watchdog->id = id;
46624: 2543 0030 movel %d3,%a2@(48)
the_watchdog->user_data = user_data;
46628: 42aa 0034 clrl %a2@(52)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
4662c: 2542 003c movel %d2,%a2@(60)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
46630: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
46634: 486a 0010 pea %a2@(16) 46638: 4879 0006 06a2 pea 606a2 <_Watchdog_Ticks_chain> 4663e: 4eb9 0004 9e70 jsr 49e70 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
46644: 4eb9 0004 90ea jsr 490ea <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4664a: 4fef 000c lea %sp@(12),%sp 4664e: 606c bras 466bc <rtems_rate_monotonic_period+0x136>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
46650: 7202 moveq #2,%d1 46652: b280 cmpl %d0,%d1
46654: 666a bnes 466c0 <rtems_rate_monotonic_period+0x13a>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
46656: 2f0a movel %a2,%sp@- 46658: 4eb9 0004 6492 jsr 46492 <_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;
4665e: 7001 moveq #1,%d0
the_period->next_length = length;
46660: 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;
46664: 2540 0038 movel %d0,%a2@(56)
the_period->next_length = length;
_ISR_Enable( level );
46668: 46c4 movew %d4,%sr
_Thread_Executing->Wait.id = the_period->Object.id;
4666a: 2079 0006 0a4c moveal 60a4c <_Per_CPU_Information+0xc>,%a0 46670: 216a 0008 0020 movel %a2@(8),%a0@(32)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
46676: 4878 4000 pea 4000 <D_MAX_EXP+0x3801> 4667a: 2f08 movel %a0,%sp@- 4667c: 4eb9 0004 987c jsr 4987c <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
46682: 203c 0000 0700 movel #1792,%d0 46688: 40c1 movew %sr,%d1 4668a: 8081 orl %d1,%d0 4668c: 46c0 movew %d0,%sr
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
4668e: 7402 moveq #2,%d2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
46690: 202a 0038 movel %a2@(56),%d0
the_period->state = RATE_MONOTONIC_ACTIVE;
46694: 2542 0038 movel %d2,%a2@(56)
_ISR_Enable( level );
46698: 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 )
4669a: 7203 moveq #3,%d1 4669c: 4fef 000c lea %sp@(12),%sp 466a0: b280 cmpl %d0,%d1
466a2: 6612 bnes 466b6 <rtems_rate_monotonic_period+0x130>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
466a4: 4878 4000 pea 4000 <D_MAX_EXP+0x3801> 466a8: 2f39 0006 0a4c movel 60a4c <_Per_CPU_Information+0xc>,%sp@- 466ae: 4eb9 0004 8da8 jsr 48da8 <_Thread_Clear_state> 466b4: 508f addql #8,%sp
_Thread_Enable_dispatch();
466b6: 4eb9 0004 90ea jsr 490ea <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
466bc: 4282 clrl %d2 466be: 603e bras 466fe <rtems_rate_monotonic_period+0x178>
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
466c0: 7204 moveq #4,%d1 466c2: b280 cmpl %d0,%d1
466c4: 6636 bnes 466fc <rtems_rate_monotonic_period+0x176><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
466c6: 2f0a movel %a2,%sp@- 466c8: 4eb9 0004 6492 jsr 46492 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
466ce: 46c4 movew %d4,%sr
the_period->state = RATE_MONOTONIC_ACTIVE;
466d0: 7002 moveq #2,%d0
the_period->next_length = length;
466d2: 2542 003c movel %d2,%a2@(60)
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
466d6: 2540 0038 movel %d0,%a2@(56)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
466da: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
466de: 486a 0010 pea %a2@(16)
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
466e2: 7406 moveq #6,%d2 466e4: 4879 0006 06a2 pea 606a2 <_Watchdog_Ticks_chain> 466ea: 4eb9 0004 9e70 jsr 49e70 <_Watchdog_Insert>
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
466f0: 4eb9 0004 90ea jsr 490ea <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
466f6: 4fef 000c lea %sp@(12),%sp 466fa: 6002 bras 466fe <rtems_rate_monotonic_period+0x178>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
466fc: 7404 moveq #4,%d2
}
466fe: 2002 movel %d2,%d0 46700: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2 46706: 4e5e unlk %fp
...
00050d70 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
50d70: 4e56 fffc linkw %fp,#-4 50d74: 2f03 movel %d3,%sp@- 50d76: 262e 0010 movel %fp@(16),%d3 50d7a: 2f02 movel %d2,%sp@- 50d7c: 242e 000c movel %fp@(12),%d2
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
50d80: 6768 beqs 50dea <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
if ( !size )
50d82: 4a83 tstl %d3
50d84: 6764 beqs 50dea <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
50d86: 2f39 0007 75bc movel 775bc <_RTEMS_Allocator_Mutex>,%sp@- 50d8c: 4eb9 0005 2c90 jsr 52c90 <_API_Mutex_Lock> 50d92: 486e fffc pea %fp@(-4) 50d96: 2f2e 0008 movel %fp@(8),%sp@- 50d9a: 4879 0007 7426 pea 77426 <_Region_Information> 50da0: 4eb9 0005 468c jsr 5468c <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
50da6: 222e fffc movel %fp@(-4),%d1 50daa: 4fef 0010 lea %sp@(16),%sp
50dae: 6708 beqs 50db8 <rtems_region_get_segment_size+0x48>
50db0: 7001 moveq #1,%d0 50db2: b081 cmpl %d1,%d0
50db4: 661a bnes 50dd0 <rtems_region_get_segment_size+0x60><== NEVER TAKEN
50db6: 601c bras 50dd4 <rtems_region_get_segment_size+0x64>
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
50db8: 2f03 movel %d3,%sp@- 50dba: 2040 moveal %d0,%a0 50dbc: 2f02 movel %d2,%sp@- 50dbe: 4868 0068 pea %a0@(104) 50dc2: 4eb9 0005 4104 jsr 54104 <_Heap_Size_of_alloc_area> 50dc8: 4fef 000c lea %sp@(12),%sp 50dcc: 4a00 tstb %d0
50dce: 6708 beqs 50dd8 <rtems_region_get_segment_size+0x68><== NEVER TAKEN
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
50dd0: 4282 clrl %d2 50dd2: 6006 bras 50dda <rtems_region_get_segment_size+0x6a>
case OBJECTS_REMOTE: /* this error cannot be returned */
break;
#endif
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
50dd4: 7404 moveq #4,%d2 50dd6: 6002 bras 50dda <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;
50dd8: 7409 moveq #9,%d2 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
50dda: 2f39 0007 75bc movel 775bc <_RTEMS_Allocator_Mutex>,%sp@- 50de0: 4eb9 0005 2cf0 jsr 52cf0 <_API_Mutex_Unlock>
return return_status;
50de6: 588f addql #4,%sp 50de8: 6002 bras 50dec <rtems_region_get_segment_size+0x7c>
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
50dea: 7409 moveq #9,%d2
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
50dec: 2002 movel %d2,%d0 50dee: 242e fff4 movel %fp@(-12),%d2 50df2: 262e fff8 movel %fp@(-8),%d3 50df6: 4e5e unlk %fp
...
00045e94 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
45e94: 7003 moveq #3,%d0
*/
void rtems_shutdown_executive(
uint32_t result
)
{
45e96: 4e56 0000 linkw %fp,#0
if ( _System_state_Is_up( _System_state_Get() ) ) {
45e9a: b0b9 0005 eb14 cmpl 5eb14 <_System_state_Current>,%d0
45ea0: 6618 bnes 45eba <rtems_shutdown_executive+0x26>
45ea2: 103c 0004 moveb #4,%d0
* 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 );
45ea6: 4879 0005 e994 pea 5e994 <_Thread_BSP_context> 45eac: 23c0 0005 eb14 movel %d0,5eb14 <_System_state_Current> 45eb2: 4eb9 0004 8a5a jsr 48a5a <_CPU_Context_Restart_self>
45eb8: 588f addql #4,%sp <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_SHUTDOWN );
_Thread_Stop_multitasking();
}
_Internal_error_Occurred(
45eba: 4878 0014 pea 14 <OPER2> 45ebe: 4878 0001 pea 1 <ADD> 45ec2: 42a7 clrl %sp@- 45ec4: 4eb9 0004 6a08 jsr 46a08 <_Internal_error_Occurred>
...
000513d0 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
513d0: 4e56 fffc linkw %fp,#-4 513d4: 2f03 movel %d3,%sp@- 513d6: 2f02 movel %d2,%sp@- 513d8: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
513dc: 677a beqs 51458 <rtems_signal_send+0x88> <== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
513de: 486e fffc pea %fp@(-4) 513e2: 2f2e 0008 movel %fp@(8),%sp@- 513e6: 4eb9 0005 5294 jsr 55294 <_Thread_Get>
switch ( location ) {
513ec: 508f addql #8,%sp 513ee: 4aae fffc tstl %fp@(-4)
513f2: 6668 bnes 5145c <rtems_signal_send+0x8c> <== NEVER TAKEN
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
513f4: 2240 moveal %d0,%a1 513f6: 2069 00fe moveal %a1@(254),%a0
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
513fa: 4aa8 000a tstl %a0@(10)
513fe: 674e beqs 5144e <rtems_signal_send+0x7e>
if ( asr->is_enabled ) {
51400: 4a28 0008 tstb %a0@(8)
51404: 672c beqs 51432 <rtems_signal_send+0x62>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
51406: 223c 0000 0700 movel #1792,%d1 5140c: 40c3 movew %sr,%d3 5140e: 8283 orl %d3,%d1 51410: 46c1 movew %d1,%sr
*signal_set |= signals;
51412: 85a8 0012 orl %d2,%a0@(18)
_ISR_Enable( _level );
51416: 46c3 movew %d3,%sr
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
51418: 4ab9 0007 798a tstl 7798a <_Per_CPU_Information+0x8>
5141e: 6724 beqs 51444 <rtems_signal_send+0x74>
51420: b0b9 0007 798e cmpl 7798e <_Per_CPU_Information+0xc>,%d0
51426: 661c bnes 51444 <rtems_signal_send+0x74> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
51428: 7001 moveq #1,%d0 5142a: 13c0 0007 799a moveb %d0,7799a <_Per_CPU_Information+0x18> 51430: 6012 bras 51444 <rtems_signal_send+0x74>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
51432: 203c 0000 0700 movel #1792,%d0 51438: 40c1 movew %sr,%d1 5143a: 8081 orl %d1,%d0 5143c: 46c0 movew %d0,%sr
*signal_set |= signals;
5143e: 85a8 0016 orl %d2,%a0@(22)
_ISR_Enable( _level );
51442: 46c1 movew %d1,%sr
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
51444: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
5144a: 4280 clrl %d0 5144c: 6010 bras 5145e <rtems_signal_send+0x8e>
}
_Thread_Enable_dispatch();
5144e: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
51454: 700b moveq #11,%d0 51456: 6006 bras 5145e <rtems_signal_send+0x8e>
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
51458: 700a moveq #10,%d0 5145a: 6002 bras 5145e <rtems_signal_send+0x8e>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
5145c: 7004 moveq #4,%d0
}
5145e: 242e fff4 movel %fp@(-12),%d2 51462: 262e fff8 movel %fp@(-8),%d3 51466: 4e5e unlk %fp
...
00042722 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
42722: 4e56 0000 linkw %fp,#0 42726: 206e 0008 moveal %fp@(8),%a0
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
4272a: 4aa8 0008 tstl %a0@(8)
4272e: 671c beqs 4274c <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;
42730: 4878 0010 pea 10 <INVALID_OPERATION> 42734: 4879 0006 12c4 pea 612c4 <Stack_check_Pattern> 4273a: 2068 00b6 moveal %a0@(182),%a0 4273e: 5088 addql #8,%a0 42740: 2f08 movel %a0,%sp@- 42742: 4eb9 0004 fa7c jsr 4fa7c <memcpy> 42748: 4fef 000c lea %sp@(12),%sp
}
4274c: 4e5e unlk %fp <== NOT EXECUTED
000426ee <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
426ee: 4e56 0000 linkw %fp,#0 426f2: 2f0a movel %a2,%sp@- 426f4: 246e 000c moveal %fp@(12),%a2
Stack_check_Initialize();
426f8: 4eb9 0004 2676 jsr 42676 <Stack_check_Initialize>
if (the_thread)
426fe: 4a8a tstl %a2
42700: 6716 beqs 42718 <rtems_stack_checker_create_extension+0x2a><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
42702: 2f2a 00b2 movel %a2@(178),%sp@- 42706: 4878 00a5 pea a5 <DBL_MANT_DIG+0x70> 4270a: 2f2a 00b6 movel %a2@(182),%sp@- 4270e: 4eb9 0004 faec jsr 4faec <memset> 42714: 4fef 000c lea %sp@(12),%sp
return true;
}
42718: 246e fffc moveal %fp@(-4),%a2 4271c: 4e5e unlk %fp
4271e: 7001 moveq #1,%d0 <== NOT EXECUTED
0004285e <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
4285e: 4e56 0000 linkw %fp,#0
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
42862: 2279 0006 190a moveal 6190a <_Per_CPU_Information+0xc>,%a1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
42868: 2069 00b6 moveal %a1@(182),%a0
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
4286c: 2f02 movel %d2,%sp@-
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
4286e: b1ce cmpal %fp,%a0
42870: 620e bhis 42880 <rtems_stack_checker_is_blown+0x22><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
42872: 2008 movel %a0,%d0 42874: d0a9 00b2 addl %a1@(178),%d0
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
42878: b08e cmpl %fp,%d0 4287a: 54c2 scc %d2 4287c: 4482 negl %d2 4287e: 6002 bras 42882 <rtems_stack_checker_is_blown+0x24>
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
42880: 4202 clrb %d2 <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
42882: 4ab9 0006 0ac0 tstl 60ac0 <Stack_check_Initialized>
42888: 6720 beqs 428aa <rtems_stack_checker_is_blown+0x4c><== NEVER TAKEN
pattern_ok = (!memcmp(
4288a: 4878 0010 pea 10 <INVALID_OPERATION> 4288e: 4879 0006 12c4 pea 612c4 <Stack_check_Pattern> 42894: 4868 0008 pea %a0@(8) 42898: 4eb9 0004 f9fc jsr 4f9fc <memcmp> 4289e: 4fef 000c lea %sp@(12),%sp 428a2: 4a80 tstl %d0 428a4: 57c0 seq %d0 428a6: 4480 negl %d0 428a8: 6002 bras 428ac <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;
428aa: 7001 moveq #1,%d0 <== NOT EXECUTED
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
428ac: 4a02 tstb %d2
428ae: 6704 beqs 428b4 <rtems_stack_checker_is_blown+0x56><== NEVER TAKEN
428b0: 4a00 tstb %d0
428b2: 6614 bnes 428c8 <rtems_stack_checker_is_blown+0x6a><== ALWAYS TAKEN
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
428b4: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED 428ba: 2f00 movel %d0,%sp@- <== NOT EXECUTED 428bc: 2f39 0006 190a movel 6190a <_Per_CPU_Information+0xc>,%sp@-<== NOT EXECUTED 428c2: 4eb9 0004 2750 jsr 42750 <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
428c8: 242e fffc movel %fp@(-4),%d2 428cc: 4e5e unlk %fp
428ce: 4200 clrb %d0 <== NOT EXECUTED
00042938 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
42938: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
4293c: 4879 0004 4420 pea 44420 <printk_plugin> <== NOT EXECUTED 42942: 42a7 clrl %sp@- <== NOT EXECUTED 42944: 4eb9 0004 28d2 jsr 428d2 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED 4294a: 508f addql #8,%sp <== NOT EXECUTED
}
4294c: 4e5e unlk %fp <== NOT EXECUTED
000428d2 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
428d2: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED 428d6: 2f0a movel %a2,%sp@- <== NOT EXECUTED 428d8: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED 428dc: 2f02 movel %d2,%sp@- <== NOT EXECUTED 428de: 242e 0008 movel %fp@(8),%d2 <== NOT EXECUTED
if ( !print )
428e2: 4a8a tstl %a2 <== NOT EXECUTED 428e4: 6746 beqs 4292c <rtems_stack_checker_report_usage_with_plugin+0x5a><== NOT EXECUTED
return;
print_context = context;
print_handler = print;
(*print)( context, "Stack usage by thread\n");
428e6: 4879 0005 e55c pea 5e55c <IntUartPollCallbacks.6374+0x13c> <== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
428ec: 23c2 0006 0ab8 movel %d2,60ab8 <print_context> <== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
428f2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
{
if ( !print )
return;
print_context = context;
print_handler = print;
428f4: 23ca 0006 0abc movel %a2,60abc <print_handler> <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
428fa: 4e92 jsr %a2@ <== NOT EXECUTED
(*print)( context,
428fc: 4879 0005 e573 pea 5e573 <IntUartPollCallbacks.6374+0x153> <== NOT EXECUTED 42902: 2f02 movel %d2,%sp@- <== NOT EXECUTED 42904: 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 );
42906: 4879 0004 2554 pea 42554 <Stack_check_Dump_threads_usage> <== NOT EXECUTED 4290c: 4eb9 0004 9194 jsr 49194 <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);
42912: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED 42916: 4eb9 0004 2554 jsr 42554 <Stack_check_Dump_threads_usage> <== NOT EXECUTED
#endif
print_context = NULL;
print_handler = NULL;
4291c: 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;
42920: 42b9 0006 0ab8 clrl 60ab8 <print_context> <== NOT EXECUTED
print_handler = NULL;
42926: 42b9 0006 0abc clrl 60abc <print_handler> <== NOT EXECUTED
}
4292c: 242e fff8 movel %fp@(-8),%d2 <== NOT EXECUTED 42930: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED 42934: 4e5e unlk %fp <== NOT EXECUTED
000427f6 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
427f6: 4e56 0000 linkw %fp,#0 427fa: 2f0a movel %a2,%sp@- 427fc: 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);
42800: 222a 00b6 movel %a2@(182),%d1 42804: 5081 addql #8,%d1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
42806: 202a 00b6 movel %a2@(182),%d0
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
4280a: 2f02 movel %d2,%sp@-
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
4280c: b08e cmpl %fp,%d0
4280e: 620c bhis 4281c <rtems_stack_checker_switch_extension+0x26><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
42810: d0aa 00b2 addl %a2@(178),%d0
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
42814: b08e cmpl %fp,%d0 42816: 54c2 scc %d2 42818: 4482 negl %d2 4281a: 6002 bras 4281e <rtems_stack_checker_switch_extension+0x28>
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
4281c: 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,
4281e: 4878 0010 pea 10 <INVALID_OPERATION> 42822: 4879 0006 12c4 pea 612c4 <Stack_check_Pattern> 42828: 2f01 movel %d1,%sp@- 4282a: 4eb9 0004 f9fc jsr 4f9fc <memcmp> 42830: 4fef 000c lea %sp@(12),%sp 42834: 4a80 tstl %d0 42836: 57c0 seq %d0 42838: 4480 negl %d0
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
4283a: 4a02 tstb %d2
4283c: 6704 beqs 42842 <rtems_stack_checker_switch_extension+0x4c><== NEVER TAKEN
4283e: 4a00 tstb %d0
42840: 6610 bnes 42852 <rtems_stack_checker_switch_extension+0x5c><== ALWAYS TAKEN
Stack_check_report_blown_task( running, pattern_ok );
42842: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED 42848: 2f00 movel %d0,%sp@- <== NOT EXECUTED 4284a: 2f0a movel %a2,%sp@- <== NOT EXECUTED 4284c: 4eb9 0004 2750 jsr 42750 <Stack_check_report_blown_task> <== NOT EXECUTED
} }
42852: 242e fff8 movel %fp@(-8),%d2 42856: 246e fffc moveal %fp@(-4),%a2
4285a: 4e5e unlk %fp <== NOT EXECUTED
0004b928 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
4b928: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED 4b92c: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ <== NOT EXECUTED 4b930: 282e 0008 movel %fp@(8),%d4 <== NOT EXECUTED 4b934: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED 4b938: 266e 0010 moveal %fp@(16),%a3 <== NOT EXECUTED
double result;
char *end;
if ( !n )
4b93c: 4a8a tstl %a2 <== NOT EXECUTED 4b93e: 6700 009c beqw 4b9dc <rtems_string_to_double+0xb4> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
errno = 0;
4b942: 4eb9 0004 e66c jsr 4e66c <__errno> <== NOT EXECUTED
*n = 0;
4b948: 4281 clrl %d1 <== NOT EXECUTED
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4b94a: 2040 moveal %d0,%a0 <== NOT EXECUTED
*n = 0;
4b94c: 4280 clrl %d0 <== NOT EXECUTED
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4b94e: 4290 clrl %a0@ <== NOT EXECUTED
*n = 0;
4b950: 2480 movel %d0,%a2@ <== NOT EXECUTED 4b952: 2541 0004 movel %d1,%a2@(4) <== NOT EXECUTED
result = strtod( s, &end );
4b956: 486e fffc pea %fp@(-4) <== NOT EXECUTED 4b95a: 2f04 movel %d4,%sp@- <== NOT EXECUTED 4b95c: 4eb9 0005 0f8e jsr 50f8e <strtod> <== NOT EXECUTED
if ( endptr )
4b962: 508f addql #8,%sp <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
4b964: 2400 movel %d0,%d2 <== NOT EXECUTED 4b966: 2601 movel %d1,%d3 <== NOT EXECUTED
if ( endptr )
4b968: 4a8b tstl %a3 <== NOT EXECUTED 4b96a: 6704 beqs 4b970 <rtems_string_to_double+0x48> <== NOT EXECUTED
*endptr = end;
4b96c: 26ae fffc movel %fp@(-4),%a3@ <== NOT EXECUTED
if ( end == s )
4b970: b8ae fffc cmpl %fp@(-4),%d4 <== NOT EXECUTED 4b974: 676a beqs 4b9e0 <rtems_string_to_double+0xb8> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4b976: 4eb9 0004 e66c jsr 4e66c <__errno> <== NOT EXECUTED 4b97c: 7222 moveq #34,%d1 <== NOT EXECUTED 4b97e: 2040 moveal %d0,%a0 <== NOT EXECUTED 4b980: b290 cmpl %a0@,%d1 <== NOT EXECUTED 4b982: 664e bnes 4b9d2 <rtems_string_to_double+0xaa> <== NOT EXECUTED 4b984: 42a7 clrl %sp@- <== NOT EXECUTED 4b986: 42a7 clrl %sp@- <== NOT EXECUTED 4b988: 2f03 movel %d3,%sp@- <== NOT EXECUTED 4b98a: 2f02 movel %d2,%sp@- <== NOT EXECUTED 4b98c: 4eb9 0004 24c8 jsr 424c8 <__eqdf2> <== NOT EXECUTED 4b992: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED 4b996: 4a80 tstl %d0 <== NOT EXECUTED 4b998: 674a beqs 4b9e4 <rtems_string_to_double+0xbc> <== NOT EXECUTED
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4b99a: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED 4b99e: 2f3c 7fef ffff movel #2146435071,%sp@- <== NOT EXECUTED 4b9a4: 2f03 movel %d3,%sp@- <== NOT EXECUTED 4b9a6: 2f02 movel %d2,%sp@- <== NOT EXECUTED 4b9a8: 4eb9 0005 cac0 jsr 5cac0 <__gtdf2> <== NOT EXECUTED 4b9ae: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED 4b9b2: 4a80 tstl %d0 <== NOT EXECUTED 4b9b4: 6e2e bgts 4b9e4 <rtems_string_to_double+0xbc> <== NOT EXECUTED 4b9b6: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED 4b9ba: 2f3c ffef ffff movel #-1048577,%sp@- <== NOT EXECUTED 4b9c0: 2f03 movel %d3,%sp@- <== NOT EXECUTED 4b9c2: 2f02 movel %d2,%sp@- <== NOT EXECUTED 4b9c4: 4eb9 0005 cb08 jsr 5cb08 <__ltdf2> <== NOT EXECUTED 4b9ca: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED 4b9ce: 4a80 tstl %d0 <== NOT EXECUTED 4b9d0: 6d12 blts 4b9e4 <rtems_string_to_double+0xbc> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
4b9d2: 2482 movel %d2,%a2@ <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4b9d4: 4280 clrl %d0 <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
4b9d6: 2543 0004 movel %d3,%a2@(4) <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4b9da: 600a bras 4b9e6 <rtems_string_to_double+0xbe> <== NOT EXECUTED
{
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4b9dc: 7009 moveq #9,%d0 <== NOT EXECUTED 4b9de: 6006 bras 4b9e6 <rtems_string_to_double+0xbe> <== NOT EXECUTED
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4b9e0: 700b moveq #11,%d0 <== NOT EXECUTED 4b9e2: 6002 bras 4b9e6 <rtems_string_to_double+0xbe> <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
4b9e4: 700a moveq #10,%d0 <== NOT EXECUTED
*n = result;
return RTEMS_SUCCESSFUL;
}
4b9e6: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3 <== NOT EXECUTED 4b9ec: 4e5e unlk %fp <== NOT EXECUTED
0004b9f0 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
4b9f0: 4e56 ffec linkw %fp,#-20 4b9f4: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 4b9f8: 262e 0008 movel %fp@(8),%d3 4b9fc: 246e 000c moveal %fp@(12),%a2 4ba00: 266e 0010 moveal %fp@(16),%a3
float result;
char *end;
if ( !n )
4ba04: 4a8a tstl %a2
4ba06: 677e beqs 4ba86 <rtems_string_to_float+0x96>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4ba08: 4eb9 0004 e66c jsr 4e66c <__errno> 4ba0e: 2040 moveal %d0,%a0 4ba10: 4290 clrl %a0@
*n = 0;
4ba12: 24bc 0000 0000 movel #0,%a2@
result = strtof( s, &end );
4ba18: 486e fffc pea %fp@(-4) 4ba1c: 2f03 movel %d3,%sp@- 4ba1e: 4eb9 0005 0fae jsr 50fae <strtof>
if ( endptr )
4ba24: 508f addql #8,%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
4ba26: 2400 movel %d0,%d2
if ( endptr )
4ba28: 4a8b tstl %a3
4ba2a: 6704 beqs 4ba30 <rtems_string_to_float+0x40>
*endptr = end;
4ba2c: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4ba30: b6ae fffc cmpl %fp@(-4),%d3
4ba34: 6754 beqs 4ba8a <rtems_string_to_float+0x9a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4ba36: 4eb9 0004 e66c jsr 4e66c <__errno> 4ba3c: 7222 moveq #34,%d1 4ba3e: 2040 moveal %d0,%a0 4ba40: b290 cmpl %a0@,%d1
4ba42: 663c bnes 4ba80 <rtems_string_to_float+0x90>
4ba44: 2f3c 0000 0000 movel #0,%sp@- 4ba4a: 2f02 movel %d2,%sp@- 4ba4c: 4eb9 0004 24ec jsr 424ec <__eqsf2> 4ba52: 508f addql #8,%sp 4ba54: 4a80 tstl %d0
4ba56: 6736 beqs 4ba8e <rtems_string_to_float+0x9e> <== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4ba58: 2f3c 7f7f ffff movel #2139095039,%sp@- 4ba5e: 2f02 movel %d2,%sp@- 4ba60: 4eb9 0005 cb50 jsr 5cb50 <__gtsf2> 4ba66: 508f addql #8,%sp 4ba68: 4a80 tstl %d0
4ba6a: 6e22 bgts 4ba8e <rtems_string_to_float+0x9e> <== NEVER TAKEN
4ba6c: 2f3c ff7f ffff movel #-8388609,%sp@- 4ba72: 2f02 movel %d2,%sp@- 4ba74: 4eb9 0005 cb6c jsr 5cb6c <__ltsf2> 4ba7a: 508f addql #8,%sp 4ba7c: 4a80 tstl %d0
4ba7e: 6d0e blts 4ba8e <rtems_string_to_float+0x9e> <== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
4ba80: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4ba82: 4280 clrl %d0 4ba84: 600a bras 4ba90 <rtems_string_to_float+0xa0>
{
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4ba86: 7009 moveq #9,%d0 4ba88: 6006 bras 4ba90 <rtems_string_to_float+0xa0>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4ba8a: 700b moveq #11,%d0 4ba8c: 6002 bras 4ba90 <rtems_string_to_float+0xa0>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
4ba8e: 700a moveq #10,%d0 <== NOT EXECUTED
*n = result;
return RTEMS_SUCCESSFUL;
}
4ba90: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3 4ba96: 4e5e unlk %fp
...
0004ba9c <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
4ba9c: 4e56 ffec linkw %fp,#-20 4baa0: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 4baa4: 262e 0008 movel %fp@(8),%d3 4baa8: 246e 000c moveal %fp@(12),%a2 4baac: 266e 0010 moveal %fp@(16),%a3
long result;
char *end;
if ( !n )
4bab0: 4a8a tstl %a2
4bab2: 6758 beqs 4bb0c <rtems_string_to_int+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bab4: 4eb9 0004 e66c jsr 4e66c <__errno> 4baba: 2040 moveal %d0,%a0 4babc: 4290 clrl %a0@
*n = 0;
4babe: 4292 clrl %a2@
result = strtol( s, &end, base );
4bac0: 2f2e 0014 movel %fp@(20),%sp@- 4bac4: 486e fffc pea %fp@(-4) 4bac8: 2f03 movel %d3,%sp@- 4baca: 4eb9 0005 116a jsr 5116a <strtol>
if ( endptr )
4bad0: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4bad4: 2400 movel %d0,%d2
if ( endptr )
4bad6: 4a8b tstl %a3
4bad8: 6704 beqs 4bade <rtems_string_to_int+0x42>
*endptr = end;
4bada: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bade: b6ae fffc cmpl %fp@(-4),%d3
4bae2: 672c beqs 4bb10 <rtems_string_to_int+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bae4: 4eb9 0004 e66c jsr 4e66c <__errno> 4baea: 7222 moveq #34,%d1 4baec: 2040 moveal %d0,%a0 4baee: b290 cmpl %a0@,%d1
4baf0: 6614 bnes 4bb06 <rtems_string_to_int+0x6a>
4baf2: 4a82 tstl %d2
4baf4: 671e beqs 4bb14 <rtems_string_to_int+0x78> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4baf6: 0c82 7fff ffff cmpil #2147483647,%d2
4bafc: 6716 beqs 4bb14 <rtems_string_to_int+0x78> <== ALWAYS TAKEN
4bafe: 0c82 8000 0000 cmpil #-2147483648,%d2 <== NOT EXECUTED 4bb04: 670e beqs 4bb14 <rtems_string_to_int+0x78> <== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4bb06: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bb08: 4280 clrl %d0 4bb0a: 600a bras 4bb16 <rtems_string_to_int+0x7a>
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bb0c: 7009 moveq #9,%d0 4bb0e: 6006 bras 4bb16 <rtems_string_to_int+0x7a>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bb10: 700b moveq #11,%d0 4bb12: 6002 bras 4bb16 <rtems_string_to_int+0x7a>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4bb14: 700a moveq #10,%d0
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4bb16: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bb1c: 4e5e unlk %fp <== NOT EXECUTED
0004bbc0 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
4bbc0: 4e56 ffec linkw %fp,#-20 4bbc4: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 4bbc8: 262e 0008 movel %fp@(8),%d3 4bbcc: 246e 000c moveal %fp@(12),%a2 4bbd0: 266e 0010 moveal %fp@(16),%a3
long result;
char *end;
if ( !n )
4bbd4: 4a8a tstl %a2
4bbd6: 6758 beqs 4bc30 <rtems_string_to_long+0x70> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bbd8: 4eb9 0004 e66c jsr 4e66c <__errno> 4bbde: 2040 moveal %d0,%a0 4bbe0: 4290 clrl %a0@
*n = 0;
4bbe2: 4292 clrl %a2@
result = strtol( s, &end, base );
4bbe4: 2f2e 0014 movel %fp@(20),%sp@- 4bbe8: 486e fffc pea %fp@(-4) 4bbec: 2f03 movel %d3,%sp@- 4bbee: 4eb9 0005 116a jsr 5116a <strtol>
if ( endptr )
4bbf4: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4bbf8: 2400 movel %d0,%d2
if ( endptr )
4bbfa: 4a8b tstl %a3
4bbfc: 6704 beqs 4bc02 <rtems_string_to_long+0x42> <== NEVER TAKEN
*endptr = end;
4bbfe: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bc02: b6ae fffc cmpl %fp@(-4),%d3
4bc06: 672c beqs 4bc34 <rtems_string_to_long+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bc08: 4eb9 0004 e66c jsr 4e66c <__errno> 4bc0e: 7222 moveq #34,%d1 4bc10: 2040 moveal %d0,%a0 4bc12: b290 cmpl %a0@,%d1
4bc14: 6614 bnes 4bc2a <rtems_string_to_long+0x6a>
4bc16: 4a82 tstl %d2
4bc18: 671e beqs 4bc38 <rtems_string_to_long+0x78> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4bc1a: 0c82 7fff ffff cmpil #2147483647,%d2
4bc20: 6716 beqs 4bc38 <rtems_string_to_long+0x78>
4bc22: 0c82 8000 0000 cmpil #-2147483648,%d2
4bc28: 670e beqs 4bc38 <rtems_string_to_long+0x78> <== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
4bc2a: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bc2c: 4280 clrl %d0 4bc2e: 600a bras 4bc3a <rtems_string_to_long+0x7a>
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bc30: 7009 moveq #9,%d0 4bc32: 6006 bras 4bc3a <rtems_string_to_long+0x7a>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bc34: 700b moveq #11,%d0 4bc36: 6002 bras 4bc3a <rtems_string_to_long+0x7a>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4bc38: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4bc3a: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bc40: 4e5e unlk %fp <== NOT EXECUTED
0004bb20 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
4bb20: 4e56 ffe8 linkw %fp,#-24 4bb24: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 4bb28: 282e 0008 movel %fp@(8),%d4 4bb2c: 246e 000c moveal %fp@(12),%a2 4bb30: 266e 0010 moveal %fp@(16),%a3
long long result;
char *end;
if ( !n )
4bb34: 4a8a tstl %a2
4bb36: 6774 beqs 4bbac <rtems_string_to_long_long+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bb38: 4eb9 0004 e66c jsr 4e66c <__errno> 4bb3e: 2040 moveal %d0,%a0
*n = 0;
4bb40: 4280 clrl %d0 4bb42: 4281 clrl %d1
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bb44: 4290 clrl %a0@
*n = 0;
4bb46: 2480 movel %d0,%a2@ 4bb48: 2541 0004 movel %d1,%a2@(4)
result = strtoll( s, &end, base );
4bb4c: 2f2e 0014 movel %fp@(20),%sp@- 4bb50: 486e fffc pea %fp@(-4) 4bb54: 2f04 movel %d4,%sp@- 4bb56: 4eb9 0005 118c jsr 5118c <strtoll>
if ( endptr )
4bb5c: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
4bb60: 2400 movel %d0,%d2 4bb62: 2601 movel %d1,%d3
if ( endptr )
4bb64: 4a8b tstl %a3
4bb66: 6704 beqs 4bb6c <rtems_string_to_long_long+0x4c>
*endptr = end;
4bb68: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bb6c: b8ae fffc cmpl %fp@(-4),%d4
4bb70: 673e beqs 4bbb0 <rtems_string_to_long_long+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bb72: 4eb9 0004 e66c jsr 4e66c <__errno> 4bb78: 7222 moveq #34,%d1 4bb7a: 2040 moveal %d0,%a0 4bb7c: b290 cmpl %a0@,%d1
4bb7e: 6622 bnes 4bba2 <rtems_string_to_long_long+0x82>
4bb80: 2002 movel %d2,%d0 4bb82: 8083 orl %d3,%d0
4bb84: 672e beqs 4bbb4 <rtems_string_to_long_long+0x94> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4bb86: 203c 7fff ffff movel #2147483647,%d0 4bb8c: 72ff moveq #-1,%d1 4bb8e: 9283 subl %d3,%d1 4bb90: 9182 subxl %d2,%d0
4bb92: 6720 beqs 4bbb4 <rtems_string_to_long_long+0x94>
4bb94: 203c 8000 0000 movel #-2147483648,%d0 4bb9a: 4281 clrl %d1 4bb9c: 9283 subl %d3,%d1 4bb9e: 9182 subxl %d2,%d0
4bba0: 6712 beqs 4bbb4 <rtems_string_to_long_long+0x94> <== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
4bba2: 4280 clrl %d0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4bba4: 2482 movel %d2,%a2@ 4bba6: 2543 0004 movel %d3,%a2@(4)
return RTEMS_SUCCESSFUL;
4bbaa: 600a bras 4bbb6 <rtems_string_to_long_long+0x96>
{
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bbac: 7009 moveq #9,%d0 4bbae: 6006 bras 4bbb6 <rtems_string_to_long_long+0x96>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bbb0: 700b moveq #11,%d0 4bbb2: 6002 bras 4bbb6 <rtems_string_to_long_long+0x96>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4bbb4: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4bbb6: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3
4bbbc: 4e5e unlk %fp <== NOT EXECUTED
0004bc60 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
4bc60: 4e56 ffec linkw %fp,#-20 4bc64: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 4bc68: 262e 0008 movel %fp@(8),%d3 4bc6c: 246e 000c moveal %fp@(12),%a2 4bc70: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4bc74: 4a8a tstl %a2
4bc76: 6764 beqs 4bcdc <rtems_string_to_unsigned_char+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bc78: 4eb9 0004 e66c jsr 4e66c <__errno> 4bc7e: 2040 moveal %d0,%a0 4bc80: 4290 clrl %a0@
*n = 0;
4bc82: 4212 clrb %a2@
result = strtoul( s, &end, base );
4bc84: 2f2e 0014 movel %fp@(20),%sp@- 4bc88: 486e fffc pea %fp@(-4) 4bc8c: 2f03 movel %d3,%sp@- 4bc8e: 4eb9 0005 15ae jsr 515ae <strtoul>
if ( endptr )
4bc94: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4bc98: 2400 movel %d0,%d2
if ( endptr )
4bc9a: 4a8b tstl %a3
4bc9c: 6704 beqs 4bca2 <rtems_string_to_unsigned_char+0x42>
*endptr = end;
4bc9e: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bca2: b6ae fffc cmpl %fp@(-4),%d3
4bca6: 6738 beqs 4bce0 <rtems_string_to_unsigned_char+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bca8: 4eb9 0004 e66c jsr 4e66c <__errno> 4bcae: 7222 moveq #34,%d1 4bcb0: 2040 moveal %d0,%a0 4bcb2: b290 cmpl %a0@,%d1
4bcb4: 660a bnes 4bcc0 <rtems_string_to_unsigned_char+0x60><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
4bcb6: 2002 movel %d2,%d0 <== NOT EXECUTED 4bcb8: 5380 subql #1,%d0 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bcba: 72fd moveq #-3,%d1 <== NOT EXECUTED 4bcbc: b280 cmpl %d0,%d1 <== NOT EXECUTED 4bcbe: 6524 bcss 4bce4 <rtems_string_to_unsigned_char+0x84><== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
4bcc0: 0c82 0000 00ff cmpil #255,%d2
4bcc6: 630e blss 4bcd6 <rtems_string_to_unsigned_char+0x76><== ALWAYS TAKEN
errno = ERANGE;
4bcc8: 4eb9 0004 e66c jsr 4e66c <__errno> <== NOT EXECUTED 4bcce: 2040 moveal %d0,%a0 <== NOT EXECUTED 4bcd0: 7022 moveq #34,%d0 <== NOT EXECUTED 4bcd2: 2080 movel %d0,%a0@ <== NOT EXECUTED 4bcd4: 600e bras 4bce4 <rtems_string_to_unsigned_char+0x84><== NOT EXECUTED
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
4bcd6: 4280 clrl %d0
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4bcd8: 1482 moveb %d2,%a2@
return RTEMS_SUCCESSFUL;
4bcda: 600a bras 4bce6 <rtems_string_to_unsigned_char+0x86>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bcdc: 7009 moveq #9,%d0 4bcde: 6006 bras 4bce6 <rtems_string_to_unsigned_char+0x86>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bce0: 700b moveq #11,%d0 4bce2: 6002 bras 4bce6 <rtems_string_to_unsigned_char+0x86>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4bce4: 700a moveq #10,%d0 <== NOT EXECUTED
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4bce6: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bcec: 4e5e unlk %fp <== NOT EXECUTED
0004bcf0 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
4bcf0: 4e56 ffec linkw %fp,#-20 4bcf4: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 4bcf8: 262e 0008 movel %fp@(8),%d3 4bcfc: 246e 000c moveal %fp@(12),%a2 4bd00: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4bd04: 4a8a tstl %a2
4bd06: 674e beqs 4bd56 <rtems_string_to_unsigned_int+0x66>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bd08: 4eb9 0004 e66c jsr 4e66c <__errno> 4bd0e: 2040 moveal %d0,%a0 4bd10: 4290 clrl %a0@
*n = 0;
4bd12: 4292 clrl %a2@
result = strtoul( s, &end, base );
4bd14: 2f2e 0014 movel %fp@(20),%sp@- 4bd18: 486e fffc pea %fp@(-4) 4bd1c: 2f03 movel %d3,%sp@- 4bd1e: 4eb9 0005 15ae jsr 515ae <strtoul>
if ( endptr )
4bd24: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4bd28: 2400 movel %d0,%d2
if ( endptr )
4bd2a: 4a8b tstl %a3
4bd2c: 6704 beqs 4bd32 <rtems_string_to_unsigned_int+0x42>
*endptr = end;
4bd2e: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bd32: b6ae fffc cmpl %fp@(-4),%d3
4bd36: 6722 beqs 4bd5a <rtems_string_to_unsigned_int+0x6a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bd38: 4eb9 0004 e66c jsr 4e66c <__errno> 4bd3e: 7222 moveq #34,%d1 4bd40: 2040 moveal %d0,%a0 4bd42: b290 cmpl %a0@,%d1
4bd44: 660a bnes 4bd50 <rtems_string_to_unsigned_int+0x60>
(( result == 0 ) || ( result == ULONG_MAX )))
4bd46: 2002 movel %d2,%d0 4bd48: 5380 subql #1,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bd4a: 72fd moveq #-3,%d1 4bd4c: b280 cmpl %d0,%d1
4bd4e: 650e bcss 4bd5e <rtems_string_to_unsigned_int+0x6e><== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4bd50: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bd52: 4280 clrl %d0 4bd54: 600a bras 4bd60 <rtems_string_to_unsigned_int+0x70>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bd56: 7009 moveq #9,%d0 4bd58: 6006 bras 4bd60 <rtems_string_to_unsigned_int+0x70>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bd5a: 700b moveq #11,%d0 4bd5c: 6002 bras 4bd60 <rtems_string_to_unsigned_int+0x70>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4bd5e: 700a moveq #10,%d0
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4bd60: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3 4bd66: 4e5e unlk %fp
...
0004bdfc <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
4bdfc: 4e56 ffec linkw %fp,#-20 4be00: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 4be04: 262e 0008 movel %fp@(8),%d3 4be08: 246e 000c moveal %fp@(12),%a2 4be0c: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4be10: 4a8a tstl %a2
4be12: 674e beqs 4be62 <rtems_string_to_unsigned_long+0x66>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4be14: 4eb9 0004 e66c jsr 4e66c <__errno> 4be1a: 2040 moveal %d0,%a0 4be1c: 4290 clrl %a0@
*n = 0;
4be1e: 4292 clrl %a2@
result = strtoul( s, &end, base );
4be20: 2f2e 0014 movel %fp@(20),%sp@- 4be24: 486e fffc pea %fp@(-4) 4be28: 2f03 movel %d3,%sp@- 4be2a: 4eb9 0005 15ae jsr 515ae <strtoul>
if ( endptr )
4be30: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4be34: 2400 movel %d0,%d2
if ( endptr )
4be36: 4a8b tstl %a3
4be38: 6704 beqs 4be3e <rtems_string_to_unsigned_long+0x42>
*endptr = end;
4be3a: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4be3e: b6ae fffc cmpl %fp@(-4),%d3
4be42: 6722 beqs 4be66 <rtems_string_to_unsigned_long+0x6a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4be44: 4eb9 0004 e66c jsr 4e66c <__errno> 4be4a: 7222 moveq #34,%d1 4be4c: 2040 moveal %d0,%a0 4be4e: b290 cmpl %a0@,%d1
4be50: 660a bnes 4be5c <rtems_string_to_unsigned_long+0x60>
(( result == 0 ) || ( result == ULONG_MAX )))
4be52: 2002 movel %d2,%d0 4be54: 5380 subql #1,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4be56: 72fd moveq #-3,%d1 4be58: b280 cmpl %d0,%d1
4be5a: 650e bcss 4be6a <rtems_string_to_unsigned_long+0x6e><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4be5c: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4be5e: 4280 clrl %d0 4be60: 600a bras 4be6c <rtems_string_to_unsigned_long+0x70>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4be62: 7009 moveq #9,%d0 4be64: 6006 bras 4be6c <rtems_string_to_unsigned_long+0x70>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4be66: 700b moveq #11,%d0 4be68: 6002 bras 4be6c <rtems_string_to_unsigned_long+0x70>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4be6a: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4be6c: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3 4be72: 4e5e unlk %fp
...
0004bd6c <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
4bd6c: 4e56 ffe4 linkw %fp,#-28 4bd70: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 4bd74: 282e 0008 movel %fp@(8),%d4 4bd78: 246e 000c moveal %fp@(12),%a2 4bd7c: 266e 0010 moveal %fp@(16),%a3
unsigned long long result;
char *end;
if ( !n )
4bd80: 4a8a tstl %a2
4bd82: 6764 beqs 4bde8 <rtems_string_to_unsigned_long_long+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bd84: 4eb9 0004 e66c jsr 4e66c <__errno> 4bd8a: 2040 moveal %d0,%a0
*n = 0;
4bd8c: 4280 clrl %d0 4bd8e: 4281 clrl %d1
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bd90: 4290 clrl %a0@
*n = 0;
4bd92: 2480 movel %d0,%a2@ 4bd94: 2541 0004 movel %d1,%a2@(4)
result = strtoull( s, &end, base );
4bd98: 2f2e 0014 movel %fp@(20),%sp@- 4bd9c: 486e fffc pea %fp@(-4) 4bda0: 2f04 movel %d4,%sp@- 4bda2: 4eb9 0005 15d0 jsr 515d0 <strtoull>
if ( endptr )
4bda8: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
4bdac: 2400 movel %d0,%d2 4bdae: 2601 movel %d1,%d3
if ( endptr )
4bdb0: 4a8b tstl %a3
4bdb2: 6704 beqs 4bdb8 <rtems_string_to_unsigned_long_long+0x4c>
*endptr = end;
4bdb4: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bdb8: b8ae fffc cmpl %fp@(-4),%d4
4bdbc: 672e beqs 4bdec <rtems_string_to_unsigned_long_long+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bdbe: 4eb9 0004 e66c jsr 4e66c <__errno> 4bdc4: 7222 moveq #34,%d1 4bdc6: 2040 moveal %d0,%a0 4bdc8: b290 cmpl %a0@,%d1
4bdca: 6612 bnes 4bdde <rtems_string_to_unsigned_long_long+0x72>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4bdcc: 70ff moveq #-1,%d0 4bdce: 72ff moveq #-1,%d1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bdd0: 78ff moveq #-1,%d4 4bdd2: 7afd moveq #-3,%d5
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4bdd4: d283 addl %d3,%d1 4bdd6: d182 addxl %d2,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bdd8: 9a81 subl %d1,%d5 4bdda: 9980 subxl %d0,%d4
4bddc: 6512 bcss 4bdf0 <rtems_string_to_unsigned_long_long+0x84><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
4bdde: 4280 clrl %d0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4bde0: 2482 movel %d2,%a2@ 4bde2: 2543 0004 movel %d3,%a2@(4)
return RTEMS_SUCCESSFUL;
4bde6: 600a bras 4bdf2 <rtems_string_to_unsigned_long_long+0x86>
{
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bde8: 7009 moveq #9,%d0 4bdea: 6006 bras 4bdf2 <rtems_string_to_unsigned_long_long+0x86>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bdec: 700b moveq #11,%d0 4bdee: 6002 bras 4bdf2 <rtems_string_to_unsigned_long_long+0x86>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
4bdf0: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4bdf2: 4cee 0c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a3
4bdf8: 4e5e unlk %fp <== NOT EXECUTED
0004258c <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
4258c: 4e56 fe3c linkw %fp,#-452 42590: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 42594: 2e2e 0008 movel %fp@(8),%d7
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
42598: 2f07 movel %d7,%sp@- 4259a: 4eb9 0005 1094 jsr 51094 <strlen> 425a0: 4297 clrl %sp@ 425a2: 486e ffe8 pea %fp@(-24) 425a6: 42a7 clrl %sp@- 425a8: 2f00 movel %d0,%sp@- 425aa: 2f07 movel %d7,%sp@- 425ac: 4eb9 0004 2fcc jsr 42fcc <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
425b2: 4fef 0014 lea %sp@(20),%sp
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
425b6: 2800 movel %d0,%d4
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
425b8: 6600 01a8 bnew 42762 <rtems_tarfs_load+0x1d6>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
425bc: 202e fff4 movel %fp@(-12),%d0 425c0: 0c80 0006 0ae0 cmpil #396000,%d0
425c6: 6710 beqs 425d8 <rtems_tarfs_load+0x4c>
425c8: 0c80 0006 1334 cmpil #398132,%d0 425ce: 6600 0192 bnew 42762 <rtems_tarfs_load+0x1d6>
425d2: 6004 bras 425d8 <rtems_tarfs_load+0x4c> <== NOT EXECUTED
425d4: 2443 moveal %d3,%a2 425d6: 602e bras 42606 <rtems_tarfs_load+0x7a>
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
425d8: 2c0e movel %fp,%d6
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
425da: 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);
425dc: 240e movel %fp,%d2
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
425de: 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);
425e0: 0686 ffff ff70 addil #-144,%d6 425e6: 4bf9 0005 119c lea 5119c <strncpy>,%a5
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425ec: 47f9 0004 95d4 lea 495d4 <_rtems_octal2ulong>,%a3
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
425f2: 0685 ffff ffd4 addil #-44,%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);
425f8: 0682 ffff fe70 addil #-400,%d2 425fe: 2d44 fe6c movel %d4,%fp@(-404) 42602: 2d47 fe66 movel %d7,%fp@(-410)
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
42606: 260a movel %a2,%d3 42608: 0683 0000 0200 addil #512,%d3 4260e: b6ae 0010 cmpl %fp@(16),%d3 42612: 6200 0152 bhiw 42766 <rtems_tarfs_load+0x1da>
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
42616: 4878 0005 pea 5 <COMPARE>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
4261a: d5ee 000c addal %fp@(12),%a2
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
4261e: 4879 0006 0b28 pea 60b28 <IMFS_ops+0x48> 42624: 486a 0101 pea %a2@(257) 42628: 4eb9 0005 10ac jsr 510ac <strncmp> 4262e: 4fef 000c lea %sp@(12),%sp 42632: 4a80 tstl %d0 42634: 6600 0130 bnew 42766 <rtems_tarfs_load+0x1da>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
42638: 4878 0063 pea 63 <DBL_MANT_DIG+0x2e> 4263c: 2f0a movel %a2,%sp@- 4263e: 2f06 movel %d6,%sp@- 42640: 4e95 jsr %a5@
filename[MAX_NAME_FIELD_SIZE] = '\0';
42642: 4200 clrb %d0 42644: 1d40 ffd3 moveb %d0,%fp@(-45)
linkflag = hdr_ptr[156];
42648: 122a 009c moveb %a2@(156),%d1
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
4264c: 4878 0008 pea 8 <DIVIDE_BY_ZERO> 42650: 486a 0064 pea %a2@(100)
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
42654: 1d41 fe6b moveb %d1,%fp@(-405)
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
42658: 4e93 jsr %a3@
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
4265a: 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);
4265e: 2800 movel %d0,%d4
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
42660: 486a 007c pea %a2@(124) 42664: 4e93 jsr %a3@
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
42666: 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);
4266a: 2840 moveal %d0,%a4
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
4266c: 486a 0094 pea %a2@(148) 42670: 4e93 jsr %a3@
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
42672: 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);
42676: 2e00 movel %d0,%d7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
42678: 2e8a movel %a2,%sp@ 4267a: 4eb9 0004 961a jsr 4961a <_rtems_tar_header_checksum> 42680: 588f addql #4,%sp 42682: be80 cmpl %d0,%d7 42684: 6600 00e0 bnew 42766 <rtems_tarfs_load+0x1da>
* 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) {
42688: 4280 clrl %d0 4268a: 102e fe6b moveb %fp@(-405),%d0 4268e: 7235 moveq #53,%d1 42690: b280 cmpl %d0,%d1
42692: 6656 bnes 426ea <rtems_tarfs_load+0x15e>
strcpy(full_filename, mountpoint);
42694: 2f2e fe66 movel %fp@(-410),%sp@- 42698: 2f02 movel %d2,%sp@- 4269a: 4eb9 0005 0be8 jsr 50be8 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
426a0: 2f02 movel %d2,%sp@- 426a2: 4eb9 0005 1094 jsr 51094 <strlen> 426a8: 4fef 000c lea %sp@(12),%sp 426ac: 722f moveq #47,%d1 426ae: 41f6 0800 lea %fp@(00000000,%d0:l),%a0 426b2: 1028 fe6f moveb %a0@(-401),%d0 426b6: 49c0 extbl %d0 426b8: b280 cmpl %d0,%d1
426ba: 6710 beqs 426cc <rtems_tarfs_load+0x140> <== ALWAYS TAKEN
strcat(full_filename, "/");
426bc: 4879 0005 da59 pea 5da59 <_rodata_start+0x19> <== NOT EXECUTED 426c2: 2f02 movel %d2,%sp@- <== NOT EXECUTED 426c4: 4eb9 0005 0ad0 jsr 50ad0 <strcat> <== NOT EXECUTED 426ca: 508f addql #8,%sp <== NOT EXECUTED
strcat(full_filename, filename);
426cc: 2f06 movel %d6,%sp@- 426ce: 2f02 movel %d2,%sp@- 426d0: 4eb9 0005 0ad0 jsr 50ad0 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
426d6: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca> 426da: 2f02 movel %d2,%sp@- 426dc: 4eb9 0004 3784 jsr 43784 <mkdir> 426e2: 4fef 0010 lea %sp@(16),%sp 426e6: 6000 feec braw 425d4 <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) {
426ea: 7230 moveq #48,%d1 426ec: b280 cmpl %d0,%d1 426ee: 6600 fee4 bnew 425d4 <rtems_tarfs_load+0x48>
const char *name;
loc = root_loc;
426f2: 4878 0014 pea 14 <OPER2> 426f6: 486e ffe8 pea %fp@(-24) 426fa: 2f05 movel %d5,%sp@- 426fc: 4eb9 0005 005c jsr 5005c <memcpy>
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
42702: 486e fffc pea %fp@(-4) 42706: 2f05 movel %d5,%sp@- 42708: 2f06 movel %d6,%sp@- 4270a: 4eb9 0004 a10e jsr 4a10e <IMFS_evaluate_for_make> 42710: 4fef 0018 lea %sp@(24),%sp 42714: 4a80 tstl %d0
42716: 6636 bnes 4274e <rtems_tarfs_load+0x1c2> <== NEVER TAKEN
node = IMFS_create_node(
42718: 42a7 clrl %sp@-
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
4271a: 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(
42720: 08c4 000f bset #15,%d4 42724: 2f04 movel %d4,%sp@- 42726: 2f2e fffc movel %fp@(-4),%sp@- 4272a: 4878 0006 pea 6 <EXTENDSFDF> 4272e: 2f05 movel %d5,%sp@- 42730: 4eb9 0004 9b8e jsr 49b8e <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];
42736: 4fef 0014 lea %sp@(20),%sp
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
4273a: 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];
4273c: 202e 000c movel %fp@(12),%d0 42740: d083 addl %d3,%d0
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
42742: 214c 0050 movel %a4,%a0@(80) 42746: 42a8 004c clrl %a0@(76)
node->info.linearfile.direct = &tar_image[offset];
4274a: 2140 0054 movel %d0,%a0@(84)
}
nblocks = (((file_size) + 511) & ~511) / 512;
4274e: 200c movel %a4,%d0 42750: 0680 0000 01ff addil #511,%d0
offset += 512 * nblocks;
42756: 0280 ffff fe00 andil #-512,%d0 4275c: d680 addl %d0,%d3 4275e: 6000 fe74 braw 425d4 <rtems_tarfs_load+0x48>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
42762: 78ff moveq #-1,%d4 42764: 6004 bras 4276a <rtems_tarfs_load+0x1de> 42766: 282e fe6c movel %fp@(-404),%d4
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
4276a: 2004 movel %d4,%d0 4276c: 4cee 3cfc fe3c moveml %fp@(-452),%d2-%d7/%a2-%a5 42772: 4e5e unlk %fp
...
0004c650 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4c650: 4e56 ffe4 linkw %fp,#-28 4c654: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@ 4c658: 262e 0008 movel %fp@(8),%d3 4c65c: 282e 000c movel %fp@(12),%d4 4c660: 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 )
4c664: 4a8c tstl %a4 4c666: 6700 0104 beqw 4c76c <rtems_task_mode+0x11c>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
4c66a: 2679 0005 ee32 moveal 5ee32 <_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;
4c670: 4a2b 0074 tstb %a3@(116) 4c674: 57c2 seq %d2
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4c676: 246b 00fe moveal %a3@(254),%a2
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4c67a: 49c2 extbl %d2 4c67c: 0282 0000 0100 andil #256,%d2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4c682: 4aab 007a tstl %a3@(122)
4c686: 6704 beqs 4c68c <rtems_task_mode+0x3c>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
4c688: 08c2 0009 bset #9,%d2
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4c68c: 4a2a 0008 tstb %a2@(8) 4c690: 57c5 seq %d5
old_mode |= _ISR_Get_level();
4c692: 4eb9 0004 8b00 jsr 48b00 <_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;
4c698: 49c5 extbl %d5 4c69a: 0285 0000 0400 andil #1024,%d5 4c6a0: 8085 orl %d5,%d0
old_mode |= _ISR_Get_level();
4c6a2: 8082 orl %d2,%d0 4c6a4: 2880 movel %d0,%a4@
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
4c6a6: 0804 0008 btst #8,%d4
4c6aa: 670c beqs 4c6b8 <rtems_task_mode+0x68>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
4c6ac: 0803 0008 btst #8,%d3 4c6b0: 57c0 seq %d0 4c6b2: 4480 negl %d0 4c6b4: 1740 0074 moveb %d0,%a3@(116)
if ( mask & RTEMS_TIMESLICE_MASK ) {
4c6b8: 0804 0009 btst #9,%d4
4c6bc: 671c beqs 4c6da <rtems_task_mode+0x8a>
if ( _Modes_Is_timeslice(mode_set) ) {
4c6be: 0803 0009 btst #9,%d3
4c6c2: 6712 beqs 4c6d6 <rtems_task_mode+0x86>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4c6c4: 41f9 0005 e980 lea 5e980 <_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;
4c6ca: 7001 moveq #1,%d0
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4c6cc: 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;
4c6d0: 2740 007a movel %d0,%a3@(122) 4c6d4: 6004 bras 4c6da <rtems_task_mode+0x8a>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4c6d6: 42ab 007a clrl %a3@(122)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
4c6da: 7007 moveq #7,%d0 4c6dc: c084 andl %d4,%d0
4c6de: 6712 beqs 4c6f2 <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 ) );
4c6e0: 40c0 movew %sr,%d0
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
4c6e2: 7207 moveq #7,%d1 4c6e4: 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 ) );
4c6e6: 0280 0000 f8ff andil #63743,%d0 4c6ec: e189 lsll #8,%d1 4c6ee: 8081 orl %d1,%d0 4c6f0: 46c0 movew %d0,%sr
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
4c6f2: 0804 000a btst #10,%d4
4c6f6: 6740 beqs 4c738 <rtems_task_mode+0xe8>
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4c6f8: 4281 clrl %d1 4c6fa: 122a 0008 moveb %a2@(8),%d1 4c6fe: 4282 clrl %d2
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
4c700: 0803 000a btst #10,%d3 4c704: 57c0 seq %d0 4c706: 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 ) {
4c708: 1400 moveb %d0,%d2 4c70a: b282 cmpl %d2,%d1
4c70c: 672a beqs 4c738 <rtems_task_mode+0xe8>
asr->is_enabled = is_asr_enabled;
4c70e: 1540 0008 moveb %d0,%a2@(8)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
4c712: 203c 0000 0700 movel #1792,%d0 4c718: 40c1 movew %sr,%d1 4c71a: 8081 orl %d1,%d0 4c71c: 46c0 movew %d0,%sr
_signals = information->signals_pending;
4c71e: 202a 0016 movel %a2@(22),%d0
information->signals_pending = information->signals_posted;
4c722: 256a 0012 0016 movel %a2@(18),%a2@(22)
information->signals_posted = _signals;
4c728: 2540 0012 movel %d0,%a2@(18)
_ISR_Enable( _level );
4c72c: 46c1 movew %d1,%sr
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
4c72e: 4aaa 0012 tstl %a2@(18) 4c732: 56c0 sne %d0 4c734: 4480 negl %d0 4c736: 6002 bras 4c73a <rtems_task_mode+0xea> 4c738: 4200 clrb %d0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
4c73a: 7203 moveq #3,%d1 4c73c: b2b9 0005 eb14 cmpl 5eb14 <_System_state_Current>,%d1
4c742: 662c bnes 4c770 <rtems_task_mode+0x120>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
4c744: 2079 0005 ee32 moveal 5ee32 <_Per_CPU_Information+0xc>,%a0
if ( are_signals_pending ||
4c74a: 4a00 tstb %d0
4c74c: 660e bnes 4c75c <rtems_task_mode+0x10c>
4c74e: b1f9 0005 ee36 cmpal 5ee36 <_Per_CPU_Information+0x10>,%a0
4c754: 671a beqs 4c770 <rtems_task_mode+0x120>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
4c756: 4a28 0074 tstb %a0@(116)
4c75a: 6714 beqs 4c770 <rtems_task_mode+0x120> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
4c75c: 7001 moveq #1,%d0 4c75e: 13c0 0005 ee3e moveb %d0,5ee3e <_Per_CPU_Information+0x18>
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
4c764: 4eb9 0004 7984 jsr 47984 <_Thread_Dispatch> 4c76a: 6004 bras 4c770 <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;
4c76c: 7009 moveq #9,%d0 4c76e: 6002 bras 4c772 <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;
4c770: 4280 clrl %d0
}
4c772: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4c778: 4e5e unlk %fp <== NOT EXECUTED
0004952c <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
4952c: 4e56 fffc linkw %fp,#-4 49530: 2f0a movel %a2,%sp@- 49532: 246e 0010 moveal %fp@(16),%a2 49536: 2f02 movel %d2,%sp@- 49538: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
4953c: 670c beqs 4954a <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 ) );
4953e: 4280 clrl %d0 49540: 1039 0006 0952 moveb 60952 <rtems_maximum_priority>,%d0 49546: b082 cmpl %d2,%d0
49548: 654e bcss 49598 <rtems_task_set_priority+0x6c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4954a: 4a8a tstl %a2
4954c: 674e beqs 4959c <rtems_task_set_priority+0x70>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
4954e: 486e fffc pea %fp@(-4) 49552: 2f2e 0008 movel %fp@(8),%sp@- 49556: 4eb9 0004 b580 jsr 4b580 <_Thread_Get>
switch ( location ) {
4955c: 508f addql #8,%sp
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
4955e: 2040 moveal %d0,%a0
switch ( location ) {
49560: 4aae fffc tstl %fp@(-4)
49564: 663a bnes 495a0 <rtems_task_set_priority+0x74>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
49566: 24a8 0014 movel %a0@(20),%a2@
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4956a: 4a82 tstl %d2
4956c: 6720 beqs 4958e <rtems_task_set_priority+0x62>
the_thread->real_priority = new_priority;
4956e: 2142 0018 movel %d2,%a0@(24)
if ( the_thread->resource_count == 0 ||
49572: 4aa8 001c tstl %a0@(28)
49576: 6706 beqs 4957e <rtems_task_set_priority+0x52>
49578: b4a8 0014 cmpl %a0@(20),%d2
4957c: 6410 bccs 4958e <rtems_task_set_priority+0x62> <== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
4957e: 42a7 clrl %sp@- 49580: 2f02 movel %d2,%sp@- 49582: 2f08 movel %a0,%sp@- 49584: 4eb9 0004 b13c jsr 4b13c <_Thread_Change_priority> 4958a: 4fef 000c lea %sp@(12),%sp
}
_Thread_Enable_dispatch();
4958e: 4eb9 0004 b55a jsr 4b55a <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
49594: 4280 clrl %d0 49596: 600a bras 495a2 <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;
49598: 7013 moveq #19,%d0 4959a: 6006 bras 495a2 <rtems_task_set_priority+0x76>
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
4959c: 7009 moveq #9,%d0 4959e: 6002 bras 495a2 <rtems_task_set_priority+0x76>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
495a0: 7004 moveq #4,%d0
}
495a2: 242e fff4 movel %fp@(-12),%d2 495a6: 246e fff8 moveal %fp@(-8),%a2 495aa: 4e5e unlk %fp
...
000468d4 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
468d4: 4e56 fffc linkw %fp,#-4 468d8: 2f0a movel %a2,%sp@- 468da: 246e 0010 moveal %fp@(16),%a2 468de: 2f02 movel %d2,%sp@- 468e0: 242e 000c movel %fp@(12),%d2
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
468e4: 6742 beqs 46928 <rtems_task_variable_get+0x54>
return RTEMS_INVALID_ADDRESS;
if ( !result )
468e6: 4a8a tstl %a2
468e8: 673e beqs 46928 <rtems_task_variable_get+0x54> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
468ea: 486e fffc pea %fp@(-4) 468ee: 2f2e 0008 movel %fp@(8),%sp@- 468f2: 4eb9 0004 86c0 jsr 486c0 <_Thread_Get>
switch (location) {
468f8: 508f addql #8,%sp 468fa: 4aae fffc tstl %fp@(-4)
468fe: 662c bnes 4692c <rtems_task_variable_get+0x58>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
46900: 2240 moveal %d0,%a1 46902: 2069 010a moveal %a1@(266),%a0
while (tvp) {
46906: 6016 bras 4691e <rtems_task_variable_get+0x4a>
if (tvp->ptr == ptr) {
46908: b4a8 0004 cmpl %a0@(4),%d2
4690c: 660e bnes 4691c <rtems_task_variable_get+0x48>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
4690e: 24a8 000c movel %a0@(12),%a2@
_Thread_Enable_dispatch();
46912: 4eb9 0004 869a jsr 4869a <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
46918: 4280 clrl %d0 4691a: 6012 bras 4692e <rtems_task_variable_get+0x5a>
}
tvp = (rtems_task_variable_t *)tvp->next;
4691c: 2050 moveal %a0@,%a0
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
4691e: 4a88 tstl %a0
46920: 66e6 bnes 46908 <rtems_task_variable_get+0x34>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
46922: 4eb9 0004 869a jsr 4869a <_Thread_Enable_dispatch>
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
46928: 7009 moveq #9,%d0 4692a: 6002 bras 4692e <rtems_task_variable_get+0x5a>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4692c: 7004 moveq #4,%d0
}
4692e: 242e fff4 movel %fp@(-12),%d2 46932: 246e fff8 moveal %fp@(-8),%a2 46936: 4e5e unlk %fp
...
0004692c <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
4692c: 4e56 0000 linkw %fp,#0 46930: 2f0a movel %a2,%sp@- 46932: 246e 0008 moveal %fp@(8),%a2
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
46936: 4a39 0005 ff80 tstb 5ff80 <_TOD_Is_set> 4693c: 6700 0096 beqw 469d4 <rtems_task_wake_when+0xa8>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
46940: 4a8a tstl %a2 46942: 6700 0094 beqw 469d8 <rtems_task_wake_when+0xac>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
46946: 42aa 0018 clrl %a2@(24)
if ( !_TOD_Validate( time_buffer ) )
4694a: 2f0a movel %a2,%sp@- 4694c: 4eb9 0004 5de0 jsr 45de0 <_TOD_Validate> 46952: 588f addql #4,%sp 46954: 4a00 tstb %d0 46956: 6700 0084 beqw 469dc <rtems_task_wake_when+0xb0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
4695a: 2f0a movel %a2,%sp@- 4695c: 4eb9 0004 5d44 jsr 45d44 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
46962: 588f addql #4,%sp
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
46964: 2440 moveal %d0,%a2
if ( seconds <= _TOD_Seconds_since_epoch() )
46966: b0b9 0005 fffa cmpl 5fffa <_TOD_Now>,%d0
4696c: 636e blss 469dc <rtems_task_wake_when+0xb0> <== NEVER TAKEN
4696e: 2039 0005 ff70 movel 5ff70 <_Thread_Dispatch_disable_level>,%d0 46974: 5280 addql #1,%d0 46976: 23c0 0005 ff70 movel %d0,5ff70 <_Thread_Dispatch_disable_level>
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
4697c: 4878 0010 pea 10 <INVALID_OPERATION> 46980: 2f39 0006 03da movel 603da <_Per_CPU_Information+0xc>,%sp@- 46986: 4eb9 0004 8e7c jsr 48e7c <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
4698c: 2079 0006 03da moveal 603da <_Per_CPU_Information+0xc>,%a0
NULL
);
_Watchdog_Insert_seconds(
46992: 95f9 0005 fffa subal 5fffa <_TOD_Now>,%a2
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
46998: 223c 0004 8570 movel #296304,%d1
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
4699e: 2028 0008 movel %a0@(8),%d0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
469a2: 42a8 0050 clrl %a0@(80)
the_watchdog->routine = routine; the_watchdog->id = id;
469a6: 2140 0068 movel %d0,%a0@(104)
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
469aa: 2141 0064 movel %d1,%a0@(100)
the_watchdog->id = id; the_watchdog->user_data = user_data;
469ae: 42a8 006c clrl %a0@(108)
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
469b2: 214a 0054 movel %a2,%a0@(84)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
469b6: 4868 0048 pea %a0@(72) 469ba: 4879 0006 0024 pea 60024 <_Watchdog_Seconds_chain> 469c0: 4eb9 0004 9400 jsr 49400 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
469c6: 4eb9 0004 86ea jsr 486ea <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
469cc: 4fef 0010 lea %sp@(16),%sp 469d0: 4280 clrl %d0 469d2: 600a bras 469de <rtems_task_wake_when+0xb2>
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
469d4: 700b moveq #11,%d0 469d6: 6006 bras 469de <rtems_task_wake_when+0xb2>
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
469d8: 7009 moveq #9,%d0 469da: 6002 bras 469de <rtems_task_wake_when+0xb2>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
469dc: 7014 moveq #20,%d0
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
469de: 246e fffc moveal %fp@(-4),%a2 469e2: 4e5e unlk %fp
...
00044f00 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
44f00: 7209 moveq #9,%d1
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
44f02: 4e56 0000 linkw %fp,#0 44f06: 202e 0008 movel %fp@(8),%d0
int baud_index;
switch (termios_baud) {
44f0a: b280 cmpl %d0,%d1 44f0c: 6700 00c4 beqw 44fd2 <rtems_termios_baud_to_index+0xd2>
44f10: 6d50 blts 44f62 <rtems_termios_baud_to_index+0x62>
44f12: 123c 0004 moveb #4,%d1 44f16: b280 cmpl %d0,%d1 44f18: 6700 00a4 beqw 44fbe <rtems_termios_baud_to_index+0xbe>
44f1c: 6d28 blts 44f46 <rtems_termios_baud_to_index+0x46>
44f1e: 123c 0001 moveb #1,%d1 44f22: b280 cmpl %d0,%d1 44f24: 6700 00dc beqw 45002 <rtems_termios_baud_to_index+0x102>
44f28: 6d0a blts 44f34 <rtems_termios_baud_to_index+0x34>
44f2a: 4a80 tstl %d0 44f2c: 6700 0084 beqw 44fb2 <rtems_termios_baud_to_index+0xb2> 44f30: 6000 00cc braw 44ffe <rtems_termios_baud_to_index+0xfe> 44f34: 7202 moveq #2,%d1 44f36: b280 cmpl %d0,%d1
44f38: 677c beqs 44fb6 <rtems_termios_baud_to_index+0xb6>
44f3a: 123c 0003 moveb #3,%d1 44f3e: b280 cmpl %d0,%d1 44f40: 6600 00bc bnew 44ffe <rtems_termios_baud_to_index+0xfe> 44f44: 6074 bras 44fba <rtems_termios_baud_to_index+0xba> 44f46: 7206 moveq #6,%d1 44f48: b280 cmpl %d0,%d1
44f4a: 677a beqs 44fc6 <rtems_termios_baud_to_index+0xc6> 44f4c: 6e74 bgts 44fc2 <rtems_termios_baud_to_index+0xc2>
44f4e: 123c 0007 moveb #7,%d1 44f52: b280 cmpl %d0,%d1
44f54: 6774 beqs 44fca <rtems_termios_baud_to_index+0xca>
44f56: 123c 0008 moveb #8,%d1 44f5a: b280 cmpl %d0,%d1 44f5c: 6600 00a0 bnew 44ffe <rtems_termios_baud_to_index+0xfe> 44f60: 606c bras 44fce <rtems_termios_baud_to_index+0xce> 44f62: 720e moveq #14,%d1 44f64: b280 cmpl %d0,%d1
44f66: 677e beqs 44fe6 <rtems_termios_baud_to_index+0xe6> 44f68: 6d1c blts 44f86 <rtems_termios_baud_to_index+0x86>
44f6a: 123c 000b moveb #11,%d1 44f6e: b280 cmpl %d0,%d1
44f70: 6768 beqs 44fda <rtems_termios_baud_to_index+0xda> 44f72: 6e62 bgts 44fd6 <rtems_termios_baud_to_index+0xd6>
44f74: 123c 000c moveb #12,%d1 44f78: b280 cmpl %d0,%d1
44f7a: 6762 beqs 44fde <rtems_termios_baud_to_index+0xde>
44f7c: 123c 000d moveb #13,%d1 44f80: b280 cmpl %d0,%d1
44f82: 667a bnes 44ffe <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44f84: 605c bras 44fe2 <rtems_termios_baud_to_index+0xe2> 44f86: 0c80 0000 1002 cmpil #4098,%d0
44f8c: 6764 beqs 44ff2 <rtems_termios_baud_to_index+0xf2> 44f8e: 6e10 bgts 44fa0 <rtems_termios_baud_to_index+0xa0>
44f90: 720f moveq #15,%d1 44f92: b280 cmpl %d0,%d1
44f94: 6754 beqs 44fea <rtems_termios_baud_to_index+0xea>
44f96: 0c80 0000 1001 cmpil #4097,%d0
44f9c: 6660 bnes 44ffe <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44f9e: 604e bras 44fee <rtems_termios_baud_to_index+0xee> 44fa0: 0c80 0000 1003 cmpil #4099,%d0
44fa6: 674e beqs 44ff6 <rtems_termios_baud_to_index+0xf6>
44fa8: 0c80 0000 1004 cmpil #4100,%d0
44fae: 664e bnes 44ffe <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44fb0: 6048 bras 44ffa <rtems_termios_baud_to_index+0xfa>
case B0: baud_index = 0; break;
44fb2: 4280 clrl %d0 44fb4: 604e bras 45004 <rtems_termios_baud_to_index+0x104>
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
44fb6: 7002 moveq #2,%d0 44fb8: 604a bras 45004 <rtems_termios_baud_to_index+0x104>
case B110: baud_index = 3; break;
44fba: 7003 moveq #3,%d0 44fbc: 6046 bras 45004 <rtems_termios_baud_to_index+0x104>
case B134: baud_index = 4; break;
44fbe: 7004 moveq #4,%d0 44fc0: 6042 bras 45004 <rtems_termios_baud_to_index+0x104>
case B150: baud_index = 5; break;
44fc2: 7005 moveq #5,%d0 44fc4: 603e bras 45004 <rtems_termios_baud_to_index+0x104>
case B200: baud_index = 6; break;
44fc6: 7006 moveq #6,%d0 44fc8: 603a bras 45004 <rtems_termios_baud_to_index+0x104>
case B300: baud_index = 7; break;
44fca: 7007 moveq #7,%d0 44fcc: 6036 bras 45004 <rtems_termios_baud_to_index+0x104>
case B600: baud_index = 8; break;
44fce: 7008 moveq #8,%d0 44fd0: 6032 bras 45004 <rtems_termios_baud_to_index+0x104>
case B1200: baud_index = 9; break;
44fd2: 7009 moveq #9,%d0 44fd4: 602e bras 45004 <rtems_termios_baud_to_index+0x104>
case B1800: baud_index = 10; break;
44fd6: 700a moveq #10,%d0 44fd8: 602a bras 45004 <rtems_termios_baud_to_index+0x104>
case B2400: baud_index = 11; break;
44fda: 700b moveq #11,%d0 44fdc: 6026 bras 45004 <rtems_termios_baud_to_index+0x104>
case B4800: baud_index = 12; break;
44fde: 700c moveq #12,%d0 44fe0: 6022 bras 45004 <rtems_termios_baud_to_index+0x104>
case B9600: baud_index = 13; break;
44fe2: 700d moveq #13,%d0 44fe4: 601e bras 45004 <rtems_termios_baud_to_index+0x104>
case B19200: baud_index = 14; break;
44fe6: 700e moveq #14,%d0 44fe8: 601a bras 45004 <rtems_termios_baud_to_index+0x104>
case B38400: baud_index = 15; break;
44fea: 700f moveq #15,%d0 44fec: 6016 bras 45004 <rtems_termios_baud_to_index+0x104>
case B57600: baud_index = 16; break;
44fee: 7010 moveq #16,%d0 44ff0: 6012 bras 45004 <rtems_termios_baud_to_index+0x104>
case B115200: baud_index = 17; break;
44ff2: 7011 moveq #17,%d0 44ff4: 600e bras 45004 <rtems_termios_baud_to_index+0x104>
case B230400: baud_index = 18; break;
44ff6: 7012 moveq #18,%d0 44ff8: 600a bras 45004 <rtems_termios_baud_to_index+0x104>
case B460800: baud_index = 19; break;
44ffa: 7013 moveq #19,%d0 44ffc: 6006 bras 45004 <rtems_termios_baud_to_index+0x104>
default: baud_index = -1; break;
44ffe: 70ff moveq #-1,%d0 45000: 6002 bras 45004 <rtems_termios_baud_to_index+0x104>
{
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
45002: 7001 moveq #1,%d0
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
45004: 4e5e unlk %fp <== NOT EXECUTED
00043c0c <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
43c0c: 4e56 fff4 linkw %fp,#-12 43c10: 48d7 1c00 moveml %a2-%a4,%sp@ 43c14: 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(
43c18: 49f9 0004 5854 lea 45854 <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;
43c1e: 2053 moveal %a3@,%a0 43c20: 2468 0034 moveal %a0@(52),%a2
rtems_status_code sc;
sc = rtems_semaphore_obtain(
43c24: 42a7 clrl %sp@- 43c26: 42a7 clrl %sp@- 43c28: 2f39 0005 e8b8 movel 5e8b8 <rtems_termios_ttyMutex>,%sp@- 43c2e: 4e94 jsr %a4@
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
43c30: 4fef 000c lea %sp@(12),%sp 43c34: 4a80 tstl %d0
43c36: 667c bnes 43cb4 <rtems_termios_close+0xa8> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
43c38: 202a 0008 movel %a2@(8),%d0 43c3c: 5380 subql #1,%d0 43c3e: 2540 0008 movel %d0,%a2@(8) 43c42: 6600 011c bnew 43d60 <rtems_termios_close+0x154>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
43c46: 202a 00cc movel %a2@(204),%d0 43c4a: eb88 lsll #5,%d0 43c4c: 0680 0005 e080 addil #385152,%d0 43c52: 2240 moveal %d0,%a1 43c54: 2051 moveal %a1@,%a0 43c56: 4a88 tstl %a0
43c58: 6708 beqs 43c62 <rtems_termios_close+0x56>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
43c5a: 2f0a movel %a2,%sp@- 43c5c: 4e90 jsr %a0@ 43c5e: 588f addql #4,%sp 43c60: 6024 bras 43c86 <rtems_termios_close+0x7a>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
43c62: 42a7 clrl %sp@- 43c64: 42a7 clrl %sp@- 43c66: 2f2a 0018 movel %a2@(24),%sp@- 43c6a: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL) {
43c6c: 4fef 000c lea %sp@(12),%sp 43c70: 4a80 tstl %d0
43c72: 6640 bnes 43cb4 <rtems_termios_close+0xa8> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
43c74: 2f0a movel %a2,%sp@- 43c76: 4eba fb48 jsr %pc@(437c0 <drainOutput>)
rtems_semaphore_release (tty->osem);
43c7a: 2f2a 0018 movel %a2@(24),%sp@- 43c7e: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release> 43c84: 508f addql #8,%sp
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43c86: 7002 moveq #2,%d0 43c88: b0aa 00b4 cmpl %a2@(180),%d0
43c8c: 662e bnes 43cbc <rtems_termios_close+0xb0>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
43c8e: 4878 0001 pea 1 <ADD> 43c92: 49f9 0004 5404 lea 45404 <rtems_event_send>,%a4 43c98: 2f2a 00c4 movel %a2@(196),%sp@- 43c9c: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL)
43c9e: 508f addql #8,%sp 43ca0: 4a80 tstl %d0
43ca2: 6610 bnes 43cb4 <rtems_termios_close+0xa8> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
43ca4: 4878 0001 pea 1 <ADD> 43ca8: 2f2a 00c8 movel %a2@(200),%sp@- 43cac: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL)
43cae: 508f addql #8,%sp 43cb0: 4a80 tstl %d0
43cb2: 6708 beqs 43cbc <rtems_termios_close+0xb0> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
43cb4: 2f00 movel %d0,%sp@- <== NOT EXECUTED 43cb6: 4eb9 0004 5efc jsr 45efc <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (tty->device.lastClose)
43cbc: 206a 009c moveal %a2@(156),%a0 43cc0: 4a88 tstl %a0
43cc2: 6710 beqs 43cd4 <rtems_termios_close+0xc8>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
43cc4: 2f0b movel %a3,%sp@- 43cc6: 2f2a 0010 movel %a2@(16),%sp@- 43cca: 2f2a 000c movel %a2@(12),%sp@- 43cce: 4e90 jsr %a0@ 43cd0: 4fef 000c lea %sp@(12),%sp
if (tty->forw == NULL) {
43cd4: 2052 moveal %a2@,%a0 43cd6: 4a88 tstl %a0
43cd8: 6610 bnes 43cea <rtems_termios_close+0xde>
rtems_termios_ttyTail = tty->back;
43cda: 206a 0004 moveal %a2@(4),%a0 43cde: 23c8 0005 e8bc movel %a0,5e8bc <rtems_termios_ttyTail>
if ( rtems_termios_ttyTail != NULL ) {
43ce4: 670a beqs 43cf0 <rtems_termios_close+0xe4>
rtems_termios_ttyTail->forw = NULL;
43ce6: 4290 clrl %a0@ 43ce8: 6006 bras 43cf0 <rtems_termios_close+0xe4>
}
} else {
tty->forw->back = tty->back;
43cea: 216a 0004 0004 movel %a2@(4),%a0@(4)
}
if (tty->back == NULL) {
43cf0: 206a 0004 moveal %a2@(4),%a0 43cf4: 4a88 tstl %a0
43cf6: 6610 bnes 43d08 <rtems_termios_close+0xfc>
rtems_termios_ttyHead = tty->forw;
43cf8: 2052 moveal %a2@,%a0 43cfa: 23c8 0005 e8c0 movel %a0,5e8c0 <rtems_termios_ttyHead>
if ( rtems_termios_ttyHead != NULL ) {
43d00: 6708 beqs 43d0a <rtems_termios_close+0xfe>
rtems_termios_ttyHead->back = NULL;
43d02: 42a8 0004 clrl %a0@(4) 43d06: 6002 bras 43d0a <rtems_termios_close+0xfe>
}
} else {
tty->back->forw = tty->forw;
43d08: 2092 movel %a2@,%a0@
}
rtems_semaphore_delete (tty->isem);
43d0a: 2f2a 0014 movel %a2@(20),%sp@- 43d0e: 47f9 0004 57b8 lea 457b8 <rtems_semaphore_delete>,%a3 43d14: 4e93 jsr %a3@
rtems_semaphore_delete (tty->osem);
43d16: 2f2a 0018 movel %a2@(24),%sp@- 43d1a: 4e93 jsr %a3@
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
43d1c: 2f2a 008c movel %a2@(140),%sp@- 43d20: 4e93 jsr %a3@
if ((tty->device.pollRead == NULL) ||
43d22: 4fef 000c lea %sp@(12),%sp 43d26: 4aaa 00a0 tstl %a2@(160)
43d2a: 6708 beqs 43d34 <rtems_termios_close+0x128>
43d2c: 7002 moveq #2,%d0 43d2e: b0aa 00b4 cmpl %a2@(180),%d0
43d32: 660c bnes 43d40 <rtems_termios_close+0x134>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
43d34: 2f2a 0068 movel %a2@(104),%sp@- 43d38: 4eb9 0004 57b8 jsr 457b8 <rtems_semaphore_delete> 43d3e: 588f addql #4,%sp
free (tty->rawInBuf.theBuf);
43d40: 2f2a 0058 movel %a2@(88),%sp@- 43d44: 47f9 0004 29ec lea 429ec <free>,%a3 43d4a: 4e93 jsr %a3@
free (tty->rawOutBuf.theBuf);
43d4c: 2f2a 007c movel %a2@(124),%sp@- 43d50: 4e93 jsr %a3@
free (tty->cbuf);
43d52: 2f2a 001c movel %a2@(28),%sp@- 43d56: 4e93 jsr %a3@
free (tty);
43d58: 2f0a movel %a2,%sp@- 43d5a: 4e93 jsr %a3@ 43d5c: 4fef 0010 lea %sp@(16),%sp
} rtems_semaphore_release (rtems_termios_ttyMutex);
43d60: 2f39 0005 e8b8 movel 5e8b8 <rtems_termios_ttyMutex>,%sp@- 43d66: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
43d6c: 4cee 1c00 fff4 moveml %fp@(-12),%a2-%a4 43d72: 4280 clrl %d0
43d74: 4e5e unlk %fp <== NOT EXECUTED
00044f64 <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)
{
44f64: 4e56 0000 linkw %fp,#0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
44f68: 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)
{
44f6c: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
44f70: d1a8 0090 addl %d0,%a0@(144)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
44f74: 7002 moveq #2,%d0 44f76: b0a8 00b4 cmpl %a0@(180),%d0
44f7a: 661c bnes 44f98 <rtems_termios_dequeue_characters+0x34>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
44f7c: 4878 0002 pea 2 <DOUBLE_FLOAT> 44f80: 2f28 00c8 movel %a0@(200),%sp@- 44f84: 4eb9 0004 5404 jsr 45404 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
44f8a: 508f addql #8,%sp 44f8c: 4a80 tstl %d0
44f8e: 672e beqs 44fbe <rtems_termios_dequeue_characters+0x5a><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
44f90: 2f00 movel %d0,%sp@- <== NOT EXECUTED 44f92: 4eb9 0004 5efc jsr 45efc <rtems_fatal_error_occurred> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
44f98: 7005 moveq #5,%d0 44f9a: b0a8 00cc cmpl %a0@(204),%d0
44f9e: 6612 bnes 44fb2 <rtems_termios_dequeue_characters+0x4e>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
44fa0: 2279 0005 e130 moveal 5e130 <rtems_termios_linesw+0xb4>,%a1 44fa6: 4a89 tstl %a1
44fa8: 6714 beqs 44fbe <rtems_termios_dequeue_characters+0x5a><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
44faa: 2f08 movel %a0,%sp@- 44fac: 4e91 jsr %a1@ 44fae: 588f addql #4,%sp 44fb0: 600c bras 44fbe <rtems_termios_dequeue_characters+0x5a>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
44fb2: 2d48 0008 movel %a0,%fp@(8)
}
44fb6: 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);
44fb8: 4ef9 0004 4d48 jmp 44d48 <rtems_termios_refill_transmitter>
}
44fbe: 4280 clrl %d0
44fc0: 4e5e unlk %fp <== NOT EXECUTED
00044a88 <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, char *buf, int len)
{
44a88: 4e56 ffd0 linkw %fp,#-48 44a8c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 44a90: 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) {
44a94: 202a 00cc movel %a2@(204),%d0 44a98: 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, char *buf, int len)
{
44a9a: 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) {
44a9e: 0680 0005 e08c addil #385164,%d0 44aa4: 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, char *buf, int len)
{
44aa6: 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) {
44aaa: 4a90 tstl %a0@
44aac: 6630 bnes 44ade <rtems_termios_enqueue_raw_characters+0x56>
44aae: 2802 movel %d2,%d4 44ab0: 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);
44ab2: 4bea 0030 lea %a2@(48),%a5
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,
44ab6: 49ea 004a lea %a2@(74),%a4
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) {
44aba: 4206 clrb %d6 44abc: 6000 01f4 braw 44cb2 <rtems_termios_enqueue_raw_characters+0x22a>
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
44ac0: 202a 00cc movel %a2@(204),%d0 44ac4: 5382 subql #1,%d2 44ac6: 2f0a movel %a2,%sp@- 44ac8: 121b moveb %a3@+,%d1 44aca: eb88 lsll #5,%d0 44acc: 49c1 extbl %d1 44ace: 0680 0005 e08c addil #385164,%d0 44ad4: 2240 moveal %d0,%a1 44ad6: 2f01 movel %d1,%sp@- 44ad8: 2051 moveal %a1@,%a0 44ada: 4e90 jsr %a0@ 44adc: 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--) {
44ade: 4a82 tstl %d2
44ae0: 66de bnes 44ac0 <rtems_termios_enqueue_raw_characters+0x38>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
44ae2: 4aaa 00e4 tstl %a2@(228) 44ae6: 6600 01e2 bnew 44cca <rtems_termios_enqueue_raw_characters+0x242> 44aea: 206a 00dc moveal %a2@(220),%a0 44aee: 4a88 tstl %a0 44af0: 6700 01d8 beqw 44cca <rtems_termios_enqueue_raw_characters+0x242>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44af4: 2f2a 00e0 movel %a2@(224),%sp@- 44af8: 486a 0030 pea %a2@(48) 44afc: 4e90 jsr %a0@
tty->tty_rcvwakeup = 1;
44afe: 508f addql #8,%sp 44b00: 7001 moveq #1,%d0 44b02: 2540 00e4 movel %d0,%a2@(228) 44b06: 6000 01c4 braw 44ccc <rtems_termios_enqueue_raw_characters+0x244>
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
44b0a: 202a 00b8 movel %a2@(184),%d0
}
return 0;
}
while (len--) {
c = *buf++;
44b0e: 1e1b moveb %a3@+,%d7
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
44b10: 0800 0009 btst #9,%d0
44b14: 6740 beqs 44b56 <rtems_termios_enqueue_raw_characters+0xce>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
44b16: 4283 clrl %d3 44b18: 162a 004a moveb %a2@(74),%d3 44b1c: 4281 clrl %d1 44b1e: 122a 0049 moveb %a2@(73),%d1 44b22: 1007 moveb %d7,%d0 44b24: 49c0 extbl %d0 44b26: b680 cmpl %d0,%d3
44b28: 661e bnes 44b48 <rtems_termios_enqueue_raw_characters+0xc0>
if (c == tty->termios.c_cc[VSTART]) {
44b2a: b280 cmpl %d0,%d1
44b2c: 660a bnes 44b38 <rtems_termios_enqueue_raw_characters+0xb0><== ALWAYS TAKEN
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
44b2e: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44b32: 7210 moveq #16,%d1 <== NOT EXECUTED 44b34: b380 eorl %d1,%d0 <== NOT EXECUTED 44b36: 6008 bras 44b40 <rtems_termios_enqueue_raw_characters+0xb8><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
44b38: 202a 00b8 movel %a2@(184),%d0 44b3c: 7a10 moveq #16,%d5 44b3e: 8085 orl %d5,%d0 44b40: 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, char *buf, int len)
{
44b44: 7c01 moveq #1,%d6 44b46: 6012 bras 44b5a <rtems_termios_enqueue_raw_characters+0xd2>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
44b48: b280 cmpl %d0,%d1
44b4a: 660a bnes 44b56 <rtems_termios_enqueue_raw_characters+0xce><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
44b4c: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44b50: 72ef moveq #-17,%d1 <== NOT EXECUTED 44b52: c081 andl %d1,%d0 <== NOT EXECUTED 44b54: 60ea bras 44b40 <rtems_termios_enqueue_raw_characters+0xb8><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
44b56: 4a06 tstb %d6
44b58: 6750 beqs 44baa <rtems_termios_enqueue_raw_characters+0x122><== ALWAYS TAKEN
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
44b5a: 202a 00b8 movel %a2@(184),%d0 44b5e: 7a30 moveq #48,%d5 44b60: 7220 moveq #32,%d1 44b62: c085 andl %d5,%d0 44b64: b280 cmpl %d0,%d1 44b66: 6600 0148 bnew 44cb0 <rtems_termios_enqueue_raw_characters+0x228>
/* disable interrupts */
rtems_interrupt_disable(level);
44b6a: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED 44b70: 40c3 movew %sr,%d3 <== NOT EXECUTED 44b72: 8083 orl %d3,%d0 <== NOT EXECUTED 44b74: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
44b76: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44b7a: 7adf moveq #-33,%d5 <== NOT EXECUTED 44b7c: c085 andl %d5,%d0 <== NOT EXECUTED 44b7e: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
44b82: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED 44b86: 671c beqs 44ba4 <rtems_termios_enqueue_raw_characters+0x11c><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
44b88: 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)(
44b8c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED 44b90: d0aa 007c addl %a2@(124),%d0 <== NOT EXECUTED 44b94: 2f00 movel %d0,%sp@- <== NOT EXECUTED 44b96: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 44b9a: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED 44b9e: 4e90 jsr %a0@ <== NOT EXECUTED 44ba0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
44ba4: 46c3 movew %d3,%sr <== NOT EXECUTED 44ba6: 6000 0108 braw 44cb0 <rtems_termios_enqueue_raw_characters+0x228><== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
44baa: 222a 0060 movel %a2@(96),%d1 44bae: 5281 addql #1,%d1 44bb0: 202a 0064 movel %a2@(100),%d0 44bb4: 4c40 1003 remul %d0,%d3,%d1
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
44bb8: 203c 0000 0700 movel #1792,%d0 44bbe: 40c1 movew %sr,%d1 44bc0: 8081 orl %d1,%d0 44bc2: 46c0 movew %d0,%sr 44bc4: 2d41 fffc movel %d1,%fp@(-4)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
44bc8: 206a 005c moveal %a2@(92),%a0 44bcc: 202a 0064 movel %a2@(100),%d0 44bd0: 9088 subl %a0,%d0 44bd2: 2240 moveal %d0,%a1 44bd4: d3c3 addal %d3,%a1
% tty->rawInBuf.Size) > tty->highwater) &&
44bd6: 2009 movel %a1,%d0 44bd8: 2a2a 0064 movel %a2@(100),%d5 44bdc: 4c45 0001 remul %d5,%d1,%d0 44be0: 2d45 fff8 movel %d5,%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)
44be4: b2aa 00c0 cmpl %a2@(192),%d1 44be8: 6300 008a blsw 44c74 <rtems_termios_enqueue_raw_characters+0x1ec>
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
44bec: 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) &&
44bf0: 0800 0000 btst #0,%d0 <== NOT EXECUTED 44bf4: 667e bnes 44c74 <rtems_termios_enqueue_raw_characters+0x1ec><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
44bf6: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44bfa: 7a01 moveq #1,%d5 <== NOT EXECUTED 44bfc: 8085 orl %d5,%d0 <== NOT EXECUTED 44bfe: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
44c02: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44c06: 0280 0000 0402 andil #1026,%d0 <== NOT EXECUTED 44c0c: 0c80 0000 0400 cmpil #1024,%d0 <== NOT EXECUTED 44c12: 6632 bnes 44c46 <rtems_termios_enqueue_raw_characters+0x1be><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
44c14: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44c18: 0800 0005 btst #5,%d0 <== NOT EXECUTED 44c1c: 6606 bnes 44c24 <rtems_termios_enqueue_raw_characters+0x19c><== NOT EXECUTED 44c1e: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED 44c22: 6650 bnes 44c74 <rtems_termios_enqueue_raw_characters+0x1ec><== 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;
44c24: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44c28: 7202 moveq #2,%d1 <== NOT EXECUTED 44c2a: 8081 orl %d1,%d0 <== NOT EXECUTED 44c2c: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
44c30: 4878 0001 pea 1 <ADD> <== NOT EXECUTED 44c34: 2f0c movel %a4,%sp@- <== NOT EXECUTED 44c36: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 44c3a: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED 44c3e: 4e90 jsr %a0@ <== NOT EXECUTED 44c40: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED 44c44: 602e bras 44c74 <rtems_termios_enqueue_raw_characters+0x1ec><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
44c46: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44c4a: 0280 0000 0104 andil #260,%d0 <== NOT EXECUTED 44c50: 0c80 0000 0100 cmpil #256,%d0 <== NOT EXECUTED 44c56: 661c bnes 44c74 <rtems_termios_enqueue_raw_characters+0x1ec><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
44c58: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44c5c: 7a04 moveq #4,%d5 <== NOT EXECUTED 44c5e: 8085 orl %d5,%d0 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
44c60: 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;
44c64: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
44c68: 4a88 tstl %a0 <== NOT EXECUTED 44c6a: 6708 beqs 44c74 <rtems_termios_enqueue_raw_characters+0x1ec><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
44c6c: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 44c70: 4e90 jsr %a0@ <== NOT EXECUTED 44c72: 588f addql #4,%sp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
44c74: 202e fffc movel %fp@(-4),%d0 44c78: 46c0 movew %d0,%sr
if (newTail == tty->rawInBuf.Head) {
44c7a: 202a 005c movel %a2@(92),%d0 44c7e: b083 cmpl %d3,%d0
44c80: 6604 bnes 44c86 <rtems_termios_enqueue_raw_characters+0x1fe><== ALWAYS TAKEN
dropped++;
44c82: 5282 addql #1,%d2 <== NOT EXECUTED 44c84: 602a bras 44cb0 <rtems_termios_enqueue_raw_characters+0x228><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
44c86: 206a 0058 moveal %a2@(88),%a0 44c8a: 1187 3800 moveb %d7,%a0@(00000000,%d3:l)
tty->rawInBuf.Tail = newTail;
44c8e: 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 )) {
44c92: 4aaa 00e4 tstl %a2@(228)
44c96: 6618 bnes 44cb0 <rtems_termios_enqueue_raw_characters+0x228><== NEVER TAKEN
44c98: 206a 00dc moveal %a2@(220),%a0 44c9c: 4a88 tstl %a0
44c9e: 6710 beqs 44cb0 <rtems_termios_enqueue_raw_characters+0x228><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44ca0: 2f2a 00e0 movel %a2@(224),%sp@- <== NOT EXECUTED 44ca4: 2f0d movel %a5,%sp@- <== NOT EXECUTED 44ca6: 4e90 jsr %a0@ <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
44ca8: 508f addql #8,%sp <== NOT EXECUTED 44caa: 7201 moveq #1,%d1 <== NOT EXECUTED 44cac: 2541 00e4 movel %d1,%a2@(228) <== NOT EXECUTED
44cb0: 5384 subql #1,%d4
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
44cb2: 4a84 tstl %d4 44cb4: 6600 fe54 bnew 44b0a <rtems_termios_enqueue_raw_characters+0x82>
}
}
}
}
tty->rawInBufDropped += dropped;
44cb8: d5aa 0078 addl %d2,%a2@(120)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
44cbc: 2f2a 0068 movel %a2@(104),%sp@- 44cc0: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return dropped;
44cc6: 588f addql #4,%sp 44cc8: 6002 bras 44ccc <rtems_termios_enqueue_raw_characters+0x244>
*/
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;
44cca: 4282 clrl %d2
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
44ccc: 2002 movel %d2,%d0 44cce: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
44cd4: 4e5e unlk %fp <== NOT EXECUTED
00043da0 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
43da0: 4e56 ffec linkw %fp,#-20 43da4: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 43da8: 266e 0008 moveal %fp@(8),%a3
rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
43dac: 2053 moveal %a3@,%a0 43dae: 2468 0034 moveal %a0@(52),%a2
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
43db2: 286b 0008 moveal %a3@(8),%a4
rtems_status_code sc;
args->ioctl_return = 0;
43db6: 42ab 000c clrl %a3@(12)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
43dba: 42a7 clrl %sp@- 43dbc: 42a7 clrl %sp@- 43dbe: 2f2a 0018 movel %a2@(24),%sp@- 43dc2: 4eb9 0004 5854 jsr 45854 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
43dc8: 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);
43dcc: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
43dce: 6708 beqs 43dd8 <rtems_termios_ioctl+0x38> <== ALWAYS TAKEN
args->ioctl_return = sc;
43dd0: 2740 000c movel %d0,%a3@(12) <== NOT EXECUTED
return sc;
43dd4: 6000 02d0 braw 440a6 <rtems_termios_ioctl+0x306> <== NOT EXECUTED
}
switch (args->command) {
43dd8: 202b 0004 movel %a3@(4),%d0 43ddc: 7204 moveq #4,%d1 43dde: b280 cmpl %d0,%d1 43de0: 6700 0230 beqw 44012 <rtems_termios_ioctl+0x272>
43de4: 6514 bcss 43dfa <rtems_termios_ioctl+0x5a>
43de6: 7602 moveq #2,%d3 43de8: b680 cmpl %d0,%d3
43dea: 6774 beqs 43e60 <rtems_termios_ioctl+0xc0>
43dec: 6500 020a bcsw 43ff8 <rtems_termios_ioctl+0x258> 43df0: 123c 0001 moveb #1,%d1 43df4: b280 cmpl %d0,%d1
43df6: 662c bnes 43e24 <rtems_termios_ioctl+0x84> <== NEVER TAKEN
43df8: 604c bras 43e46 <rtems_termios_ioctl+0xa6> 43dfa: 0c80 4004 667f cmpil #1074030207,%d0 43e00: 6700 026e beqw 44070 <rtems_termios_ioctl+0x2d0>
43e04: 620a bhis 43e10 <rtems_termios_ioctl+0x70>
43e06: 7605 moveq #5,%d3 43e08: b680 cmpl %d0,%d3
43e0a: 6618 bnes 43e24 <rtems_termios_ioctl+0x84>
43e0c: 6000 01f2 braw 44000 <rtems_termios_ioctl+0x260> 43e10: 0c80 4004 741a cmpil #1074033690,%d0 43e16: 6700 024e beqw 44066 <rtems_termios_ioctl+0x2c6> 43e1a: 0c80 8004 741b cmpil #-2147191781,%d0 43e20: 6700 0200 beqw 44022 <rtems_termios_ioctl+0x282>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
43e24: 202a 00cc movel %a2@(204),%d0 43e28: eb88 lsll #5,%d0 43e2a: 0680 0005 e094 addil #385172,%d0 43e30: 2240 moveal %d0,%a1 43e32: 2051 moveal %a1@,%a0 43e34: 4a88 tstl %a0 43e36: 6700 025c beqw 44094 <rtems_termios_ioctl+0x2f4>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
43e3a: 2f0b movel %a3,%sp@- 43e3c: 2f0a movel %a2,%sp@- 43e3e: 4e90 jsr %a0@ 43e40: 2400 movel %d0,%d2 43e42: 6000 01ae braw 43ff2 <rtems_termios_ioctl+0x252>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
43e46: 4878 0024 pea 24 <OPER2+0x10> 43e4a: 486a 0030 pea %a2@(48) 43e4e: 2f2b 0008 movel %a3@(8),%sp@- 43e52: 4eb9 0004 d37c jsr 4d37c <memcpy>
break;
43e58: 4fef 000c lea %sp@(12),%sp 43e5c: 6000 0238 braw 44096 <rtems_termios_ioctl+0x2f6>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
43e60: 4878 0024 pea 24 <OPER2+0x10> 43e64: 2f2b 0008 movel %a3@(8),%sp@- 43e68: 486a 0030 pea %a2@(48) 43e6c: 4eb9 0004 d37c jsr 4d37c <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) &&
43e72: 202a 00b8 movel %a2@(184),%d0 43e76: 4fef 000c lea %sp@(12),%sp 43e7a: 0800 0009 btst #9,%d0
43e7e: 6760 beqs 43ee0 <rtems_termios_ioctl+0x140>
!(tty->termios.c_iflag & IXON)) {
43e80: 202a 0030 movel %a2@(48),%d0 43e84: 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) &&
43e8a: 6654 bnes 43ee0 <rtems_termios_ioctl+0x140>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
43e8c: 202a 00b8 movel %a2@(184),%d0 43e90: 0280 ffff fdef andil #-529,%d0 43e96: 2540 00b8 movel %d0,%a2@(184)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
43e9a: 202a 00b8 movel %a2@(184),%d0 43e9e: 0800 0005 btst #5,%d0
43ea2: 673c beqs 43ee0 <rtems_termios_ioctl+0x140> <== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
43ea4: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED 43eaa: 40c3 movew %sr,%d3 <== NOT EXECUTED 43eac: 8083 orl %d3,%d0 <== NOT EXECUTED 43eae: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
43eb0: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 43eb4: 72df moveq #-33,%d1 <== NOT EXECUTED 43eb6: c081 andl %d1,%d0 <== NOT EXECUTED 43eb8: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
43ebc: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED 43ec0: 671c beqs 43ede <rtems_termios_ioctl+0x13e> <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
43ec2: 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)(
43ec6: 4878 0001 pea 1 <ADD> <== NOT EXECUTED 43eca: d0aa 007c addl %a2@(124),%d0 <== NOT EXECUTED 43ece: 2f00 movel %d0,%sp@- <== NOT EXECUTED 43ed0: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 43ed4: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED 43ed8: 4e90 jsr %a0@ <== NOT EXECUTED 43eda: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
43ede: 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)) {
43ee0: 202a 00b8 movel %a2@(184),%d0 43ee4: 0800 000a btst #10,%d0
43ee8: 6724 beqs 43f0e <rtems_termios_ioctl+0x16e>
43eea: 202a 0030 movel %a2@(48),%d0 43eee: 0280 0000 1000 andil #4096,%d0
43ef4: 6618 bnes 43f0e <rtems_termios_ioctl+0x16e> <== NEVER TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
43ef6: 202a 00b8 movel %a2@(184),%d0
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
43efa: 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);
43efc: 0880 000a bclr #10,%d0 43f00: 2540 00b8 movel %d0,%a2@(184)
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
43f04: 202a 00b8 movel %a2@(184),%d0 43f08: c083 andl %d3,%d0 43f0a: 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)) {
43f0e: 202a 00b8 movel %a2@(184),%d0 43f12: 0800 0008 btst #8,%d0
43f16: 6736 beqs 43f4e <rtems_termios_ioctl+0x1ae> <== ALWAYS TAKEN
43f18: 4aaa 0038 tstl %a2@(56) <== NOT EXECUTED 43f1c: 6d30 blts 43f4e <rtems_termios_ioctl+0x1ae> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
43f1e: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 43f22: 0880 0008 bclr #8,%d0 <== NOT EXECUTED 43f26: 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)) {
43f2a: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 43f2e: 44c0 movew %d0,%ccr <== NOT EXECUTED 43f30: 6610 bnes 43f42 <rtems_termios_ioctl+0x1a2> <== NOT EXECUTED 43f32: 206a 00b0 moveal %a2@(176),%a0 <== NOT EXECUTED 43f36: 4a88 tstl %a0 <== NOT EXECUTED 43f38: 6708 beqs 43f42 <rtems_termios_ioctl+0x1a2> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
43f3a: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 43f3e: 4e90 jsr %a0@ <== NOT EXECUTED 43f40: 588f addql #4,%sp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
43f42: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 43f46: 72fb moveq #-5,%d1 <== NOT EXECUTED 43f48: c081 andl %d1,%d0 <== NOT EXECUTED 43f4a: 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) {
43f4e: 4aaa 0038 tstl %a2@(56)
43f52: 6c0c bges 43f60 <rtems_termios_ioctl+0x1c0> <== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
43f54: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 43f58: 08c0 0008 bset #8,%d0 <== NOT EXECUTED 43f5c: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
43f60: 222a 0030 movel %a2@(48),%d1 43f64: 0801 000c btst #12,%d1
43f68: 670c beqs 43f76 <rtems_termios_ioctl+0x1d6>
tty->flow_ctrl |= FL_MDXOF;
43f6a: 202a 00b8 movel %a2@(184),%d0 43f6e: 08c0 000a bset #10,%d0 43f72: 2540 00b8 movel %d0,%a2@(184)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
43f76: 0801 000a btst #10,%d1
43f7a: 670c beqs 43f88 <rtems_termios_ioctl+0x1e8>
tty->flow_ctrl |= FL_MDXON;
43f7c: 202a 00b8 movel %a2@(184),%d0 43f80: 08c0 0009 bset #9,%d0 43f84: 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) {
43f88: 7002 moveq #2,%d0 43f8a: c0aa 003c andl %a2@(60),%d0
43f8e: 663a bnes 43fca <rtems_termios_ioctl+0x22a>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
43f90: 4283 clrl %d3 43f92: 162a 0046 moveb %a2@(70),%d3
rtems_clock_get_ticks_per_second() / 10;
43f96: 4eb9 0004 5220 jsr 45220 <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] *
43f9c: 4c03 0800 mulsl %d3,%d0
rtems_clock_get_ticks_per_second() / 10;
43fa0: 760a moveq #10,%d3 43fa2: 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] *
43fa6: 2540 0054 movel %d0,%a2@(84)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
43faa: 4a2a 0046 tstb %a2@(70)
43fae: 6714 beqs 43fc4 <rtems_termios_ioctl+0x224>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
43fb0: 42aa 006c clrl %a2@(108)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
43fb4: 2540 0070 movel %d0,%a2@(112)
if (tty->termios.c_cc[VMIN])
43fb8: 4a2a 0047 tstb %a2@(71)
43fbc: 6614 bnes 43fd2 <rtems_termios_ioctl+0x232>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
43fbe: 2540 0074 movel %d0,%a2@(116) 43fc2: 601a bras 43fde <rtems_termios_ioctl+0x23e>
} else {
if (tty->termios.c_cc[VMIN]) {
43fc4: 4a2a 0047 tstb %a2@(71)
43fc8: 670e beqs 43fd8 <rtems_termios_ioctl+0x238> <== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
43fca: 42aa 006c clrl %a2@(108)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
43fce: 42aa 0070 clrl %a2@(112)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
43fd2: 42aa 0074 clrl %a2@(116) 43fd6: 6006 bras 43fde <rtems_termios_ioctl+0x23e>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
43fd8: 7001 moveq #1,%d0 43fda: 2540 006c movel %d0,%a2@(108)
}
}
}
if (tty->device.setAttributes)
43fde: 206a 00a8 moveal %a2@(168),%a0 43fe2: 4a88 tstl %a0 43fe4: 6700 00b0 beqw 44096 <rtems_termios_ioctl+0x2f6>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
43fe8: 486a 0030 pea %a2@(48) 43fec: 2f2a 0010 movel %a2@(16),%sp@- 43ff0: 4e90 jsr %a0@ 43ff2: 508f addql #8,%sp 43ff4: 6000 00a0 braw 44096 <rtems_termios_ioctl+0x2f6>
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
43ff8: 2f0a movel %a2,%sp@- 43ffa: 4eba f7c4 jsr %pc@(437c0 <drainOutput>) 43ffe: 6062 bras 44062 <rtems_termios_ioctl+0x2c2>
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
44000: 2014 movel %a4@,%d0 44002: 222c 0004 movel %a4@(4),%d1 44006: 2540 00d4 movel %d0,%a2@(212) 4400a: 2541 00d8 movel %d1,%a2@(216)
break;
4400e: 6000 0086 braw 44096 <rtems_termios_ioctl+0x2f6>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
44012: 2014 movel %a4@,%d0 44014: 222c 0004 movel %a4@(4),%d1 44018: 2540 00dc movel %d0,%a2@(220) 4401c: 2541 00e0 movel %d1,%a2@(224)
break;
44020: 6074 bras 44096 <rtems_termios_ioctl+0x2f6>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
44022: 202a 00cc movel %a2@(204),%d0 44026: eb88 lsll #5,%d0 44028: 0680 0005 e080 addil #385152,%d0 4402e: 2240 moveal %d0,%a1 44030: 2051 moveal %a1@,%a0 44032: 4a88 tstl %a0
44034: 6708 beqs 4403e <rtems_termios_ioctl+0x29e>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
44036: 2f0a movel %a2,%sp@- 44038: 4e90 jsr %a0@ 4403a: 588f addql #4,%sp 4403c: 2400 movel %d0,%d2
}
tty->t_line=*(int*)(args->buffer);
4403e: 206b 0008 moveal %a3@(8),%a0 44042: 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) {
44044: 41f9 0005 e07c lea 5e07c <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);
4404a: 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) {
4404e: 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 */
44050: 42aa 00d0 clrl %a2@(208)
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
44054: 2070 0800 moveal %a0@(00000000,%d0:l),%a0 44058: 4a88 tstl %a0
4405a: 673a beqs 44096 <rtems_termios_ioctl+0x2f6>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
4405c: 2f0a movel %a2,%sp@- 4405e: 4e90 jsr %a0@ 44060: 2400 movel %d0,%d2 44062: 588f addql #4,%sp 44064: 6030 bras 44096 <rtems_termios_ioctl+0x2f6>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
44066: 206b 0008 moveal %a3@(8),%a0 4406a: 20aa 00cc movel %a2@(204),%a0@
break;
4406e: 6026 bras 44096 <rtems_termios_ioctl+0x2f6>
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
44070: 202a 0060 movel %a2@(96),%d0 <== NOT EXECUTED 44074: 222a 005c movel %a2@(92),%d1 <== NOT EXECUTED 44078: 9081 subl %d1,%d0 <== NOT EXECUTED
if ( rawnc < 0 )
4407a: 6a06 bpls 44082 <rtems_termios_ioctl+0x2e2> <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
4407c: 222a 0064 movel %a2@(100),%d1 <== NOT EXECUTED 44080: d081 addl %d1,%d0 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
44082: 222a 0020 movel %a2@(32),%d1 <== NOT EXECUTED 44086: 92aa 0024 subl %a2@(36),%d1 <== NOT EXECUTED 4408a: d280 addl %d0,%d1 <== NOT EXECUTED 4408c: 206b 0008 moveal %a3@(8),%a0 <== NOT EXECUTED 44090: 2081 movel %d1,%a0@ <== NOT EXECUTED
}
break;
44092: 6002 bras 44096 <rtems_termios_ioctl+0x2f6> <== NOT EXECUTED
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;
44094: 740a moveq #10,%d2 <== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
44096: 2f2a 0018 movel %a2@(24),%sp@- 4409a: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
args->ioctl_return = sc; return sc;
440a0: 588f addql #4,%sp
}
break;
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
440a2: 2742 000c movel %d2,%a3@(12)
return sc; }
440a6: 2002 movel %d2,%d0 440a8: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
440ae: 4e5e unlk %fp <== NOT EXECUTED
0004382a <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
4382a: 4e56 ffd8 linkw %fp,#-40 4382e: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
43832: 42a7 clrl %sp@-
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
43834: 282e 0008 movel %fp@(8),%d4
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
43838: 42a7 clrl %sp@- 4383a: 2f39 0005 e8b8 movel 5e8b8 <rtems_termios_ttyMutex>,%sp@-
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
43840: 2a2e 000c movel %fp@(12),%d5 43844: 2e2e 0010 movel %fp@(16),%d7
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
43848: 4eb9 0004 5854 jsr 45854 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4384e: 4fef 000c lea %sp@(12),%sp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
43852: 2400 movel %d0,%d2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
43854: 6600 038c bnew 43be2 <rtems_termios_open+0x3b8>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
43858: 2879 0005 e8c0 moveal 5e8c0 <rtems_termios_ttyHead>,%a4 4385e: 264c moveal %a4,%a3 43860: 6010 bras 43872 <rtems_termios_open+0x48>
if ((tty->major == major) && (tty->minor == minor))
43862: b8ab 000c cmpl %a3@(12),%d4
43866: 6608 bnes 43870 <rtems_termios_open+0x46>
43868: baab 0010 cmpl %a3@(16),%d5 4386c: 6700 02fc beqw 43b6a <rtems_termios_open+0x340>
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) {
43870: 2653 moveal %a3@,%a3 43872: 4a8b tstl %a3
43874: 66ec bnes 43862 <rtems_termios_open+0x38>
43876: 6000 0376 braw 43bee <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);
4387a: 2f39 0005 e8b8 movel 5e8b8 <rtems_termios_ttyMutex>,%sp@- 43880: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
43886: 588f addql #4,%sp 43888: 6038 bras 438c2 <rtems_termios_open+0x98>
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
4388a: 41f9 0005 d238 lea 5d238 <rtems_termios_raw_input_size>,%a0
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
43890: 4bf9 0004 2cd4 lea 42cd4 <malloc>,%a5
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
43896: 2750 0064 movel %a0@,%a3@(100)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
4389a: 202b 0064 movel %a3@(100),%d0 4389e: 2f00 movel %d0,%sp@- 438a0: 4e95 jsr %a5@
if (tty->rawInBuf.theBuf == NULL) {
438a2: 588f addql #4,%sp
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
438a4: 2600 movel %d0,%d3 438a6: 2740 0058 movel %d0,%a3@(88)
if (tty->rawInBuf.theBuf == NULL) {
438aa: 661c bnes 438c8 <rtems_termios_open+0x9e>
free(tty);
438ac: 2f0b movel %a3,%sp@- 438ae: 4eb9 0004 29ec jsr 429ec <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
438b4: 2f39 0005 e8b8 movel 5e8b8 <rtems_termios_ttyMutex>,%sp@- 438ba: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
438c0: 508f addql #8,%sp 438c2: 741a moveq #26,%d2 438c4: 6000 031c braw 43be2 <rtems_termios_open+0x3b8>
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
438c8: 43f9 0005 d23c lea 5d23c <rtems_termios_raw_output_size>,%a1 438ce: 2751 0088 movel %a1@,%a3@(136)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
438d2: 202b 0088 movel %a3@(136),%d0 438d6: 2f00 movel %d0,%sp@- 438d8: 4e95 jsr %a5@
if (tty->rawOutBuf.theBuf == NULL) {
438da: 588f addql #4,%sp
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
438dc: 2c00 movel %d0,%d6 438de: 2740 007c movel %d0,%a3@(124)
if (tty->rawOutBuf.theBuf == NULL) {
438e2: 6620 bnes 43904 <rtems_termios_open+0xda> <== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
438e4: 2f03 movel %d3,%sp@- <== NOT EXECUTED 438e6: 45f9 0004 29ec lea 429ec <free>,%a2 <== NOT EXECUTED 438ec: 4e92 jsr %a2@ <== NOT EXECUTED
free(tty);
438ee: 2f0b movel %a3,%sp@- <== NOT EXECUTED 438f0: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
438f2: 2f39 0005 e8b8 movel 5e8b8 <rtems_termios_ttyMutex>,%sp@- <== NOT EXECUTED 438f8: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
438fe: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED 43902: 60be bras 438c2 <rtems_termios_open+0x98> <== NOT EXECUTED
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
43904: 2f39 0005 d234 movel 5d234 <rtems_termios_cbufsize>,%sp@- 4390a: 4e95 jsr %a5@
if (tty->cbuf == NULL) {
4390c: 588f addql #4,%sp
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
4390e: 2740 001c movel %d0,%a3@(28)
if (tty->cbuf == NULL) {
43912: 6624 bnes 43938 <rtems_termios_open+0x10e>
free((void *)(tty->rawOutBuf.theBuf));
43914: 2f06 movel %d6,%sp@- 43916: 45f9 0004 29ec lea 429ec <free>,%a2 4391c: 4e92 jsr %a2@
free((void *)(tty->rawInBuf.theBuf));
4391e: 2f03 movel %d3,%sp@- 43920: 4e92 jsr %a2@
free(tty);
43922: 2f0b movel %a3,%sp@- 43924: 4e92 jsr %a2@
rtems_semaphore_release (rtems_termios_ttyMutex);
43926: 2f39 0005 e8b8 movel 5e8b8 <rtems_termios_ttyMutex>,%sp@- 4392c: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
43932: 4fef 0010 lea %sp@(16),%sp 43936: 608a bras 438c2 <rtems_termios_open+0x98>
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
43938: 42ab 00d4 clrl %a3@(212)
tty->tty_snd.sw_arg = NULL;
4393c: 42ab 00d8 clrl %a3@(216)
tty->tty_rcv.sw_pfn = NULL;
43940: 42ab 00dc clrl %a3@(220)
tty->tty_rcv.sw_arg = NULL;
43944: 42ab 00e0 clrl %a3@(224)
tty->tty_rcvwakeup = 0;
43948: 42ab 00e4 clrl %a3@(228)
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
4394c: 268c movel %a4,%a3@
tty->back = NULL;
4394e: 42ab 0004 clrl %a3@(4)
if (rtems_termios_ttyHead != NULL)
43952: 4a8c tstl %a4
43954: 6704 beqs 4395a <rtems_termios_open+0x130>
rtems_termios_ttyHead->back = tty;
43956: 294b 0004 movel %a3,%a4@(4)
rtems_termios_ttyHead = tty;
4395a: 23ca 0005 e8c0 movel %a2,5e8c0 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
43960: 4ab9 0005 e8bc tstl 5e8bc <rtems_termios_ttyTail>
43966: 6606 bnes 4396e <rtems_termios_open+0x144>
rtems_termios_ttyTail = tty;
43968: 23ca 0005 e8bc movel %a2,5e8bc <rtems_termios_ttyTail>
tty->minor = minor;
4396e: 2545 0010 movel %d5,%a2@(16)
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43972: 49f9 0004 561c lea 4561c <rtems_semaphore_create>,%a4
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
tty->major = major;
43978: 2544 000c movel %d4,%a2@(12)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
4397c: 486a 0014 pea %a2@(20)
rtems_build_name ('T', 'R', 'i', c),
43980: 1039 0005 d240 moveb 5d240 <c.6362>,%d0
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43986: 42a7 clrl %sp@- 43988: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
rtems_build_name ('T', 'R', 'i', c),
4398c: 49c0 extbl %d0
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
4398e: 4878 0001 pea 1 <ADD> 43992: 0080 5452 6900 oril #1414686976,%d0 43998: 2f00 movel %d0,%sp@- 4399a: 4e94 jsr %a4@
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)
4399c: 4fef 0014 lea %sp@(20),%sp 439a0: 4a80 tstl %d0 439a2: 6600 0228 bnew 43bcc <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
439a6: 486a 0018 pea %a2@(24)
rtems_build_name ('T', 'R', 'o', c),
439aa: 1039 0005 d240 moveb 5d240 <c.6362>,%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 (
439b0: 42a7 clrl %sp@- 439b2: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
rtems_build_name ('T', 'R', 'o', c),
439b6: 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 (
439b8: 4878 0001 pea 1 <ADD> 439bc: 0080 5452 6f00 oril #1414688512,%d0 439c2: 2f00 movel %d0,%sp@- 439c4: 4e94 jsr %a4@
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)
439c6: 4fef 0014 lea %sp@(20),%sp 439ca: 4a80 tstl %d0 439cc: 6600 01fe bnew 43bcc <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
439d0: 486a 008c pea %a2@(140)
rtems_build_name ('T', 'R', 'x', c),
439d4: 1039 0005 d240 moveb 5d240 <c.6362>,%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 (
439da: 42a7 clrl %sp@- 439dc: 4878 0020 pea 20 <OPER2+0xc>
rtems_build_name ('T', 'R', 'x', c),
439e0: 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 (
439e2: 0080 5452 7800 oril #1414690816,%d0 439e8: 42a7 clrl %sp@- 439ea: 2f00 movel %d0,%sp@- 439ec: 4e94 jsr %a4@
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
439ee: 4fef 0014 lea %sp@(20),%sp 439f2: 4a80 tstl %d0 439f4: 6600 01d6 bnew 43bcc <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
439f8: 42aa 0094 clrl %a2@(148)
/*
* Set callbacks
*/
tty->device = *callbacks;
439fc: 4878 0020 pea 20 <OPER2+0xc> 43a00: 2f2e 0014 movel %fp@(20),%sp@- 43a04: 486a 0098 pea %a2@(152) 43a08: 4eb9 0004 d37c jsr 4d37c <memcpy>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43a0e: 4fef 000c lea %sp@(12),%sp 43a12: 7002 moveq #2,%d0 43a14: b0aa 00b4 cmpl %a2@(180),%d0
43a18: 6662 bnes 43a7c <rtems_termios_open+0x252>
sc = rtems_task_create (
43a1a: 486a 00c8 pea %a2@(200) 43a1e: 49f9 0004 5a0c lea 45a0c <rtems_task_create>,%a4
rtems_build_name ('T', 'x', 'T', c),
43a24: 1039 0005 d240 moveb 5d240 <c.6362>,%d0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
43a2a: 42a7 clrl %sp@- 43a2c: 4878 0500 pea 500 <DBL_MAX_EXP+0xff>
rtems_build_name ('T', 'x', 'T', c),
43a30: 49c0 extbl %d0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
43a32: 4878 0400 pea 400 <D_BIAS+0x2> 43a36: 4878 000a pea a <LASTO> 43a3a: 0080 5478 5400 oril #1417171968,%d0 43a40: 2f00 movel %d0,%sp@- 43a42: 4e94 jsr %a4@
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
43a44: 4fef 0018 lea %sp@(24),%sp 43a48: 4a80 tstl %d0 43a4a: 6600 0180 bnew 43bcc <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
43a4e: 486a 00c4 pea %a2@(196)
rtems_build_name ('R', 'x', 'T', c),
43a52: 1039 0005 d240 moveb 5d240 <c.6362>,%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 (
43a58: 42a7 clrl %sp@- 43a5a: 4878 0500 pea 500 <DBL_MAX_EXP+0xff>
rtems_build_name ('R', 'x', 'T', c),
43a5e: 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 (
43a60: 4878 0400 pea 400 <D_BIAS+0x2> 43a64: 4878 0009 pea 9 <DIVIDE_BY_ZERO+0x1> 43a68: 0080 5278 5400 oril #1383617536,%d0 43a6e: 2f00 movel %d0,%sp@- 43a70: 4e94 jsr %a4@
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
43a72: 4fef 0018 lea %sp@(24),%sp 43a76: 4a80 tstl %d0 43a78: 6600 0152 bnew 43bcc <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
43a7c: 4aaa 00a0 tstl %a2@(160)
43a80: 6708 beqs 43a8a <rtems_termios_open+0x260>
43a82: 7202 moveq #2,%d1 43a84: b2aa 00b4 cmpl %a2@(180),%d1
43a88: 662c bnes 43ab6 <rtems_termios_open+0x28c>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43a8a: 486a 0068 pea %a2@(104)
rtems_build_name ('T', 'R', 'r', c),
43a8e: 1039 0005 d240 moveb 5d240 <c.6362>,%d0
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43a94: 42a7 clrl %sp@- 43a96: 4878 0024 pea 24 <OPER2+0x10>
rtems_build_name ('T', 'R', 'r', c),
43a9a: 49c0 extbl %d0
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43a9c: 0080 5452 7200 oril #1414689280,%d0 43aa2: 42a7 clrl %sp@- 43aa4: 2f00 movel %d0,%sp@- 43aa6: 4eb9 0004 561c jsr 4561c <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)
43aac: 4fef 0014 lea %sp@(20),%sp 43ab0: 4a80 tstl %d0 43ab2: 6600 0118 bnew 43bcc <rtems_termios_open+0x3a2>
/*
* 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;
43ab6: 203c 0000 08bd movel #2237,%d0
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
43abc: 307c 2502 moveaw #9474,%a0
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
43ac0: 327c 1805 moveaw #6149,%a1
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
43ac4: 2540 0038 movel %d0,%a2@(56)
tty->termios.c_lflag =
43ac8: 223c 0000 823b movel #33339,%d1
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
43ace: 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;
tty->termios.c_lflag =
43ad0: 2541 003c movel %d1,%a2@(60)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
43ad4: 1540 0041 moveb %d0,%a2@(65)
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
43ad8: 707f moveq #127,%d0
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;
43ada: 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';
43ade: 1540 0043 moveb %d0,%a2@(67)
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
43ae2: 7004 moveq #4,%d0
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
43ae4: 2548 0030 movel %a0,%a2@(48)
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';
43ae8: 1540 0045 moveb %d0,%a2@(69)
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
43aec: 7011 moveq #17,%d0
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
43aee: 2549 0034 movel %a1,%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';
tty->termios.c_cc[VQUIT] = '\034';
43af2: 721c moveq #28,%d1
tty->termios.c_cc[VERASE] = '\177';
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';
43af4: 1540 0049 moveb %d0,%a2@(73)
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
43af8: 701a moveq #26,%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';
43afa: 1541 0042 moveb %d1,%a2@(66)
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
43afe: 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';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
43b00: 1540 004b moveb %d0,%a2@(75)
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
43b04: 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';
43b06: 1541 0044 moveb %d1,%a2@(68)
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
43b0a: 4201 clrb %d1
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';
43b0c: 1540 004e moveb %d0,%a2@(78)
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
43b10: 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';
43b12: 1541 004c moveb %d1,%a2@(76)
tty->termios.c_cc[VEOL2] = '\000';
43b16: 1541 0051 moveb %d1,%a2@(81)
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
43b1a: 7213 moveq #19,%d1
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';
43b1c: 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;
43b20: 202a 0064 movel %a2@(100),%d0 43b24: e288 lsrl #1,%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';
43b26: 1541 004a moveb %d1,%a2@(74)
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
43b2a: 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;
43b2c: 206a 0064 moveal %a2@(100),%a0
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';
43b30: 1541 004d moveb %d1,%a2@(77)
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;
43b34: 41f0 8a00 lea %a0@(00000000,%a0:l:2),%a0
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';
43b38: 7217 moveq #23,%d1
/* 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;
43b3a: 2540 00bc movel %d0,%a2@(188)
tty->highwater = tty->rawInBuf.Size * 3/4;
43b3e: 2008 movel %a0,%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';
43b40: 1541 004f moveb %d1,%a2@(79)
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;
43b44: e488 lsrl #2,%d0 43b46: 2540 00c0 movel %d0,%a2@(192)
/*
* Bump name characer
*/
if (c++ == 'z')
43b4a: 1039 0005 d240 moveb 5d240 <c.6362>,%d0 43b50: 49c0 extbl %d0 43b52: 2200 movel %d0,%d1 43b54: 5281 addql #1,%d1 43b56: 13c1 0005 d240 moveb %d1,5d240 <c.6362> 43b5c: 727a moveq #122,%d1 43b5e: b280 cmpl %d0,%d1
43b60: 6608 bnes 43b6a <rtems_termios_open+0x340>
c = 'a';
43b62: 7061 moveq #97,%d0 43b64: 13c0 0005 d240 moveb %d0,5d240 <c.6362>
}
args->iop->data1 = tty;
43b6a: 2247 moveal %d7,%a1 43b6c: 2051 moveal %a1@,%a0
if (!tty->refcount++) {
43b6e: 202b 0008 movel %a3@(8),%d0 43b72: 2200 movel %d0,%d1 43b74: 5281 addql #1,%d1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
43b76: 214b 0034 movel %a3,%a0@(52)
if (!tty->refcount++) {
43b7a: 2741 0008 movel %d1,%a3@(8) 43b7e: 4a80 tstl %d0
43b80: 6652 bnes 43bd4 <rtems_termios_open+0x3aa>
if (tty->device.firstOpen)
43b82: 206b 0098 moveal %a3@(152),%a0 43b86: 4a88 tstl %a0
43b88: 670c beqs 43b96 <rtems_termios_open+0x36c>
(*tty->device.firstOpen)(major, minor, arg);
43b8a: 2f07 movel %d7,%sp@- 43b8c: 2f05 movel %d5,%sp@- 43b8e: 2f04 movel %d4,%sp@- 43b90: 4e90 jsr %a0@ 43b92: 4fef 000c lea %sp@(12),%sp
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43b96: 7002 moveq #2,%d0 43b98: b0ab 00b4 cmpl %a3@(180),%d0
43b9c: 6636 bnes 43bd4 <rtems_termios_open+0x3aa>
sc = rtems_task_start(
43b9e: 2f0b movel %a3,%sp@- 43ba0: 487a 1136 pea %pc@(44cd8 <rtems_termios_rxdaemon>) 43ba4: 45f9 0004 5c88 lea 45c88 <rtems_task_start>,%a2 43baa: 2f2b 00c4 movel %a3@(196),%sp@- 43bae: 4e92 jsr %a2@
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
43bb0: 4fef 000c lea %sp@(12),%sp 43bb4: 4a80 tstl %d0
43bb6: 6614 bnes 43bcc <rtems_termios_open+0x3a2> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
43bb8: 2f0b movel %a3,%sp@- 43bba: 487a 1340 pea %pc@(44efc <rtems_termios_txdaemon>) 43bbe: 2f2b 00c8 movel %a3@(200),%sp@- 43bc2: 4e92 jsr %a2@
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
43bc4: 4fef 000c lea %sp@(12),%sp 43bc8: 4a80 tstl %d0
43bca: 6708 beqs 43bd4 <rtems_termios_open+0x3aa> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
43bcc: 2f00 movel %d0,%sp@- 43bce: 4eb9 0004 5efc jsr 45efc <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
43bd4: 2f39 0005 e8b8 movel 5e8b8 <rtems_termios_ttyMutex>,%sp@- 43bda: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
43be0: 588f addql #4,%sp
}
43be2: 2002 movel %d2,%d0 43be4: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5 43bea: 4e5e unlk %fp 43bec: 4e75 rts
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
43bee: 4878 00e8 pea e8 <DBL_MANT_DIG+0xb3> 43bf2: 4878 0001 pea 1 <ADD> 43bf6: 4eb9 0004 2654 jsr 42654 <calloc>
if (tty == NULL) {
43bfc: 508f addql #8,%sp
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
43bfe: 2640 moveal %d0,%a3 43c00: 2440 moveal %d0,%a2
if (tty == NULL) {
43c02: 4a80 tstl %d0 43c04: 6600 fc84 bnew 4388a <rtems_termios_open+0x60> 43c08: 6000 fc70 braw 4387a <rtems_termios_open+0x50>
000440b2 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
440b2: 4e56 ffe0 linkw %fp,#-32 440b6: 202e 0008 movel %fp@(8),%d0 440ba: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@ 440be: 242e 000c movel %fp@(12),%d2
const unsigned char *buf = _buf;
440c2: 2640 moveal %d0,%a3
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
440c4: 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) {
440c8: 4aaa 00b4 tstl %a2@(180)
440cc: 661c bnes 440ea <rtems_termios_puts+0x38>
(*tty->device.write)(tty->minor, (void *)buf, len);
440ce: 2d42 0010 movel %d2,%fp@(16) 440d2: 2d40 000c movel %d0,%fp@(12) 440d6: 2d6a 0010 0008 movel %a2@(16),%fp@(8) 440dc: 226a 00a4 moveal %a2@(164),%a1
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
440e0: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4 440e6: 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, (void *)buf, len);
440e8: 4ed1 jmp %a1@
return;
}
newHead = tty->rawOutBuf.Head;
440ea: 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);
440ee: 2a3c 0000 0700 movel #1792,%d5
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
440f4: 49f9 0004 5854 lea 45854 <rtems_semaphore_obtain>,%a4
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
440fa: 6000 009e braw 4419a <rtems_termios_puts+0xe8>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
440fe: 202a 0088 movel %a2@(136),%d0 44102: 5286 addql #1,%d6 44104: 4c40 6004 remul %d0,%d4,%d6
rtems_interrupt_disable (level);
44108: 2005 movel %d5,%d0
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
4410a: 2c04 movel %d4,%d6
rtems_interrupt_disable (level);
4410c: 40c3 movew %sr,%d3 4410e: 8083 orl %d3,%d0 44110: 46c0 movew %d0,%sr
while (newHead == tty->rawOutBuf.Tail) {
44112: 602a bras 4413e <rtems_termios_puts+0x8c>
tty->rawOutBufState = rob_wait;
44114: 7002 moveq #2,%d0 44116: 2540 0094 movel %d0,%a2@(148)
rtems_interrupt_enable (level);
4411a: 46c3 movew %d3,%sr
sc = rtems_semaphore_obtain(
4411c: 42a7 clrl %sp@- 4411e: 42a7 clrl %sp@- 44120: 2f2a 008c movel %a2@(140),%sp@- 44124: 4e94 jsr %a4@
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
44126: 4fef 000c lea %sp@(12),%sp 4412a: 4a80 tstl %d0
4412c: 6708 beqs 44136 <rtems_termios_puts+0x84> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
4412e: 2f00 movel %d0,%sp@- <== NOT EXECUTED 44130: 4eb9 0004 5efc jsr 45efc <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
44136: 2005 movel %d5,%d0 44138: 40c3 movew %sr,%d3 4413a: 8083 orl %d3,%d0 4413c: 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) {
4413e: 202a 0084 movel %a2@(132),%d0 44142: b084 cmpl %d4,%d0
44144: 67ce beqs 44114 <rtems_termios_puts+0x62>
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++;
44146: 202a 0080 movel %a2@(128),%d0 4414a: 206a 007c moveal %a2@(124),%a0 4414e: 119b 0800 moveb %a3@+,%a0@(00000000,%d0:l)
tty->rawOutBuf.Head = newHead;
44152: 2544 0080 movel %d4,%a2@(128)
if (tty->rawOutBufState == rob_idle) {
44156: 4aaa 0094 tstl %a2@(148)
4415a: 663a bnes 44196 <rtems_termios_puts+0xe4>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
4415c: 202a 00b8 movel %a2@(184),%d0 44160: 0800 0004 btst #4,%d0
44164: 661e bnes 44184 <rtems_termios_puts+0xd2> <== NEVER TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
44166: 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,
4416a: 4878 0001 pea 1 <ADD> 4416e: d0aa 007c addl %a2@(124),%d0 44172: 2f00 movel %d0,%sp@- 44174: 2f2a 0010 movel %a2@(16),%sp@- 44178: 206a 00a4 moveal %a2@(164),%a0 4417c: 4e90 jsr %a0@ 4417e: 4fef 000c lea %sp@(12),%sp 44182: 600c bras 44190 <rtems_termios_puts+0xde>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
44184: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44188: 7220 moveq #32,%d1 <== NOT EXECUTED 4418a: 8081 orl %d1,%d0 <== NOT EXECUTED 4418c: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
44190: 7001 moveq #1,%d0 44192: 2540 0094 movel %d0,%a2@(148)
}
rtems_interrupt_enable (level);
44196: 46c3 movew %d3,%sr
len--;
44198: 5382 subql #1,%d2
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
4419a: 4a82 tstl %d2 4419c: 6600 ff60 bnew 440fe <rtems_termios_puts+0x4c>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
441a0: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
441a6: 4e5e unlk %fp <== NOT EXECUTED
00044796 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
44796: 4e56 ffd4 linkw %fp,#-44 4479a: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4479e: 266e 0008 moveal %fp@(8),%a3
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
447a2: 2053 moveal %a3@,%a0
uint32_t count = args->count;
447a4: 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;
447a8: 2468 0034 moveal %a0@(52),%a2
uint32_t count = args->count; char *buffer = args->buffer;
447ac: 2a6b 000c moveal %a3@(12),%a5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
447b0: 42a7 clrl %sp@- 447b2: 42a7 clrl %sp@- 447b4: 2f2a 0014 movel %a2@(20),%sp@- 447b8: 4eb9 0004 5854 jsr 45854 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
447be: 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);
447c2: 2800 movel %d0,%d4
if (sc != RTEMS_SUCCESSFUL)
447c4: 6600 029a bnew 44a60 <rtems_termios_read+0x2ca>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
447c8: 202a 00cc movel %a2@(204),%d0 447cc: eb88 lsll #5,%d0 447ce: 0680 0005 e084 addil #385156,%d0 447d4: 2240 moveal %d0,%a1 447d6: 2051 moveal %a1@,%a0 447d8: 4a88 tstl %a0
447da: 671e beqs 447fa <rtems_termios_read+0x64>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
447dc: 2f0b movel %a3,%sp@- 447de: 2f0a movel %a2,%sp@- 447e0: 4e90 jsr %a0@ 447e2: 2800 movel %d0,%d4
tty->tty_rcvwakeup = 0;
447e4: 42aa 00e4 clrl %a2@(228)
rtems_semaphore_release (tty->isem);
447e8: 2f2a 0014 movel %a2@(20),%sp@- 447ec: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return sc;
447f2: 4fef 000c lea %sp@(12),%sp 447f6: 6000 0268 braw 44a60 <rtems_termios_read+0x2ca>
}
if (tty->cindex == tty->ccount) {
447fa: 202a 0020 movel %a2@(32),%d0 447fe: b0aa 0024 cmpl %a2@(36),%d0 44802: 6600 0234 bnew 44a38 <rtems_termios_read+0x2a2>
tty->cindex = tty->ccount = 0;
44806: 42aa 0020 clrl %a2@(32)
tty->read_start_column = tty->column;
4480a: 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;
44810: 42aa 0024 clrl %a2@(36)
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
44814: 4aaa 00a0 tstl %a2@(160) 44818: 6700 00da beqw 448f4 <rtems_termios_read+0x15e> 4481c: 4aaa 00b4 tstl %a2@(180) 44820: 6600 00d2 bnew 448f4 <rtems_termios_read+0x15e>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
44824: 7002 moveq #2,%d0 44826: c0aa 003c andl %a2@(60),%d0
4482a: 673e beqs 4486a <rtems_termios_read+0xd4>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
4482c: 49f9 0004 5d34 lea 45d34 <rtems_task_wake_after>,%a4
} else {
if (siproc (n, tty))
44832: 243c 0004 4676 movel #280182,%d2
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
44838: 2f2a 0010 movel %a2@(16),%sp@- 4483c: 206a 00a0 moveal %a2@(160),%a0 44840: 4e90 jsr %a0@
if (n < 0) {
44842: 588f addql #4,%sp 44844: 4a80 tstl %d0
44846: 6c0a bges 44852 <rtems_termios_read+0xbc>
rtems_task_wake_after (1);
44848: 4878 0001 pea 1 <ADD> 4484c: 4e94 jsr %a4@ 4484e: 588f addql #4,%sp 44850: 60e6 bras 44838 <rtems_termios_read+0xa2>
} else {
if (siproc (n, tty))
44852: 2f0a movel %a2,%sp@- 44854: 2042 moveal %d2,%a0 44856: 0280 0000 00ff andil #255,%d0 4485c: 2f00 movel %d0,%sp@- 4485e: 4e90 jsr %a0@ 44860: 508f addql #8,%sp 44862: 4a80 tstl %d0
44864: 67d2 beqs 44838 <rtems_termios_read+0xa2>
44866: 6000 01d0 braw 44a38 <rtems_termios_read+0x2a2>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
4486a: 49f9 0004 5238 lea 45238 <rtems_clock_get_ticks_since_boot>,%a4 44870: 4e94 jsr %a4@
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
44872: 2c3c 0004 5d34 movel #286004,%d6
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
44878: 2400 movel %d0,%d2
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
4487a: 2a3c 0004 4676 movel #280182,%d5
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
44880: 2f2a 0010 movel %a2@(16),%sp@- 44884: 206a 00a0 moveal %a2@(160),%a0 44888: 4e90 jsr %a0@
if (n < 0) {
4488a: 588f addql #4,%sp 4488c: 4a80 tstl %d0
4488e: 6c34 bges 448c4 <rtems_termios_read+0x12e>
if (tty->termios.c_cc[VMIN]) {
44890: 4a2a 0047 tstb %a2@(71)
44894: 670e beqs 448a4 <rtems_termios_read+0x10e> <== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
44896: 4a2a 0046 tstb %a2@(70)
4489a: 671c beqs 448b8 <rtems_termios_read+0x122> <== NEVER TAKEN
4489c: 4aaa 0020 tstl %a2@(32)
448a0: 6716 beqs 448b8 <rtems_termios_read+0x122>
448a2: 6008 bras 448ac <rtems_termios_read+0x116>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
448a4: 4a2a 0046 tstb %a2@(70) <== NOT EXECUTED 448a8: 6700 018e beqw 44a38 <rtems_termios_read+0x2a2> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
448ac: 4e94 jsr %a4@
if ((now - then) > tty->vtimeTicks) {
448ae: 9082 subl %d2,%d0 448b0: b0aa 0054 cmpl %a2@(84),%d0 448b4: 6200 0182 bhiw 44a38 <rtems_termios_read+0x2a2>
break;
}
}
rtems_task_wake_after (1);
448b8: 4878 0001 pea 1 <ADD> 448bc: 2246 moveal %d6,%a1 448be: 4e91 jsr %a1@ 448c0: 588f addql #4,%sp 448c2: 60bc bras 44880 <rtems_termios_read+0xea>
} else {
siproc (n, tty);
448c4: 2f0a movel %a2,%sp@- 448c6: 2045 moveal %d5,%a0 448c8: 0280 0000 00ff andil #255,%d0 448ce: 2f00 movel %d0,%sp@- 448d0: 4e90 jsr %a0@
if (tty->ccount >= tty->termios.c_cc[VMIN])
448d2: 508f addql #8,%sp 448d4: 4281 clrl %d1 448d6: 102a 0047 moveb %a2@(71),%d0 448da: 1200 moveb %d0,%d1 448dc: b2aa 0020 cmpl %a2@(32),%d1 448e0: 6f00 0156 blew 44a38 <rtems_termios_read+0x2a2>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
448e4: 4a00 tstb %d0
448e6: 6798 beqs 44880 <rtems_termios_read+0xea> <== NEVER TAKEN
448e8: 4a2a 0046 tstb %a2@(70)
448ec: 6792 beqs 44880 <rtems_termios_read+0xea> <== NEVER TAKEN
then = rtems_clock_get_ticks_since_boot();
448ee: 4e94 jsr %a4@ 448f0: 2400 movel %d0,%d2 448f2: 608c bras 44880 <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)(
448f4: 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;
448f6: 7401 moveq #1,%d2 448f8: 49fa fd7c lea %pc@(44676 <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)(
448fc: 0687 0000 0049 addil #73,%d7
/*
* Wait for characters
*/
if ( wait ) {
sc = rtems_semaphore_obtain(
44902: 2c3c 0004 5854 movel #284756,%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;
44908: 2a2a 0074 movel %a2@(116),%d5 4490c: 6000 00e2 braw 449f0 <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;
44910: 2a2a 005c movel %a2@(92),%d5 44914: 5285 addql #1,%d5 44916: 202a 0064 movel %a2@(100),%d0
c = tty->rawInBuf.theBuf[newHead];
4491a: 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;
4491e: 4c40 5001 remul %d0,%d1,%d5
c = tty->rawInBuf.theBuf[newHead];
44922: 1030 1800 moveb %a0@(00000000,%d1:l),%d0
tty->rawInBuf.Head = newHead;
44926: 2541 005c movel %d1,%a2@(92)
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
4492a: 1d40 ffff moveb %d0,%fp@(-1)
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
4492e: 202a 0060 movel %a2@(96),%d0 44932: 226a 0064 moveal %a2@(100),%a1 44936: 43f1 0800 lea %a1@(00000000,%d0:l),%a1 4493a: 93c1 subal %d1,%a1
% tty->rawInBuf.Size)
4493c: 2a09 movel %a1,%d5 4493e: 206a 0064 moveal %a2@(100),%a0 44942: 2008 movel %a0,%d0 44944: 4c40 5001 remul %d0,%d1,%d5
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)
44948: b2aa 00bc cmpl %a2@(188),%d1
4494c: 646a bccs 449b8 <rtems_termios_read+0x222> <== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
4494e: 202a 00b8 movel %a2@(184),%d0 44952: 72fe moveq #-2,%d1 44954: c081 andl %d1,%d0 44956: 2540 00b8 movel %d0,%a2@(184)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
4495a: 202a 00b8 movel %a2@(184),%d0 4495e: 0280 0000 0202 andil #514,%d0 44964: 0c80 0000 0202 cmpil #514,%d0
4496a: 6626 bnes 44992 <rtems_termios_read+0x1fc> <== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
4496c: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED 44970: 670a beqs 4497c <rtems_termios_read+0x1e6> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
44972: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44976: 0800 0005 btst #5,%d0 <== NOT EXECUTED 4497a: 6716 beqs 44992 <rtems_termios_read+0x1fc> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
4497c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED 44980: 2f07 movel %d7,%sp@- <== NOT EXECUTED 44982: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 44986: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED 4498a: 4e90 jsr %a0@ <== NOT EXECUTED 4498c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED 44990: 6026 bras 449b8 <rtems_termios_read+0x222> <== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
44992: 202a 00b8 movel %a2@(184),%d0 44996: 0800 0008 btst #8,%d0
4499a: 671c beqs 449b8 <rtems_termios_read+0x222> <== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
4499c: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 449a0: 7afb moveq #-5,%d5 <== NOT EXECUTED 449a2: c085 andl %d5,%d0 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
449a4: 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;
449a8: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
449ac: 4a88 tstl %a0 <== NOT EXECUTED 449ae: 6708 beqs 449b8 <rtems_termios_read+0x222> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
449b0: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 449b4: 4e90 jsr %a0@ <== NOT EXECUTED 449b6: 588f addql #4,%sp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
449b8: 7002 moveq #2,%d0 449ba: 4285 clrl %d5 449bc: 1a2e ffff moveb %fp@(-1),%d5 449c0: c0aa 003c andl %a2@(60),%d0
449c4: 670e beqs 449d4 <rtems_termios_read+0x23e> <== NEVER TAKEN
if (siproc (c, tty))
449c6: 2f0a movel %a2,%sp@- 449c8: 2f05 movel %d5,%sp@- 449ca: 4e94 jsr %a4@ 449cc: 508f addql #8,%sp
wait = 0;
449ce: 4a80 tstl %d0 449d0: 57c0 seq %d0 449d2: 6014 bras 449e8 <rtems_termios_read+0x252>
} else {
siproc (c, tty);
449d4: 2f0a movel %a2,%sp@- <== NOT EXECUTED 449d6: 2f05 movel %d5,%sp@- <== NOT EXECUTED 449d8: 4e94 jsr %a4@ <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
449da: 508f addql #8,%sp <== NOT EXECUTED 449dc: 4280 clrl %d0 <== NOT EXECUTED 449de: 102a 0047 moveb %a2@(71),%d0 <== NOT EXECUTED
wait = 0;
449e2: b0aa 0020 cmpl %a2@(32),%d0 <== NOT EXECUTED 449e6: 5ec0 sgt %d0 <== NOT EXECUTED
449e8: 49c0 extbl %d0 449ea: c480 andl %d0,%d2
}
timeout = tty->rawInBufSemaphoreTimeout;
449ec: 2a2a 0070 movel %a2@(112),%d5
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
449f0: 222a 005c movel %a2@(92),%d1 449f4: 202a 0060 movel %a2@(96),%d0 449f8: b081 cmpl %d1,%d0
449fa: 6710 beqs 44a0c <rtems_termios_read+0x276>
(tty->ccount < (CBUFSIZE-1))) {
449fc: 2039 0005 d234 movel 5d234 <rtems_termios_cbufsize>,%d0 44a02: 5380 subql #1,%d0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
44a04: b0aa 0020 cmpl %a2@(32),%d0 44a08: 6e00 ff06 bgtw 44910 <rtems_termios_read+0x17a>
}
/*
* Wait for characters
*/
if ( wait ) {
44a0c: 4a82 tstl %d2
44a0e: 6728 beqs 44a38 <rtems_termios_read+0x2a2>
sc = rtems_semaphore_obtain(
44a10: 2f05 movel %d5,%sp@- 44a12: 2f2a 006c movel %a2@(108),%sp@- 44a16: 2046 moveal %d6,%a0 44a18: 2f2a 0068 movel %a2@(104),%sp@- 44a1c: 4e90 jsr %a0@
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
44a1e: 4fef 000c lea %sp@(12),%sp 44a22: 4a80 tstl %d0
44a24: 67ca beqs 449f0 <rtems_termios_read+0x25a> <== ALWAYS TAKEN
44a26: 6010 bras 44a38 <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++];
44a28: 206a 001c moveal %a2@(28),%a0
count--;
44a2c: 5383 subql #1,%d3
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
44a2e: 1af0 0800 moveb %a0@(00000000,%d0:l),%a5@+ 44a32: 5280 addql #1,%d0 44a34: 2540 0024 movel %d0,%a2@(36)
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
44a38: 4a83 tstl %d3
44a3a: 670a beqs 44a46 <rtems_termios_read+0x2b0>
44a3c: 202a 0024 movel %a2@(36),%d0 44a40: b0aa 0020 cmpl %a2@(32),%d0
44a44: 6de2 blts 44a28 <rtems_termios_read+0x292>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
44a46: 202b 0010 movel %a3@(16),%d0 44a4a: 9083 subl %d3,%d0 44a4c: 2740 0018 movel %d0,%a3@(24)
tty->tty_rcvwakeup = 0;
44a50: 42aa 00e4 clrl %a2@(228)
rtems_semaphore_release (tty->isem);
44a54: 2f2a 0014 movel %a2@(20),%sp@- 44a58: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return sc;
44a5e: 588f addql #4,%sp
}
44a60: 2004 movel %d4,%d0 44a62: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
44a68: 4e5e unlk %fp <== NOT EXECUTED
00044d48 <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)
{
44d48: 4e56 fff4 linkw %fp,#-12 44d4c: 48d7 040c moveml %d2-%d3/%a2,%sp@ 44d50: 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))
44d54: 202a 00b8 movel %a2@(184),%d0 44d58: 0280 0000 0403 andil #1027,%d0 44d5e: 0c80 0000 0401 cmpil #1025,%d0
44d64: 663c bnes 44da2 <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);
44d66: 4878 0001 pea 1 <ADD> <== NOT EXECUTED 44d6a: 486a 004a pea %a2@(74) <== NOT EXECUTED 44d6e: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 44d72: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED 44d76: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_interrupt_disable(level);
44d78: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED 44d7e: 40c1 movew %sr,%d1 <== NOT EXECUTED 44d80: 8081 orl %d1,%d0 <== NOT EXECUTED 44d82: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->t_dqlen--;
tty->flow_ctrl |= FL_ISNTXOF;
44d84: 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--;
44d86: 53aa 0090 subql #1,%a2@(144) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
44d8a: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44d8e: 8082 orl %d2,%d0 <== NOT EXECUTED 44d90: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
rtems_interrupt_enable(level);
44d94: 46c1 movew %d1,%sr <== NOT EXECUTED 44d96: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
nToSend = 1;
44d9a: 143c 0001 moveb #1,%d2 <== NOT EXECUTED 44d9e: 6000 0150 braw 44ef0 <rtems_termios_refill_transmitter+0x1a8><== NOT EXECUTED
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
44da2: 202a 00b8 movel %a2@(184),%d0 44da6: 7203 moveq #3,%d1 44da8: 7402 moveq #2,%d2 44daa: c081 andl %d1,%d0 44dac: b480 cmpl %d0,%d2
44dae: 663a bnes 44dea <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);
44db0: 4878 0001 pea 1 <ADD> <== NOT EXECUTED 44db4: 486a 0049 pea %a2@(73) <== NOT EXECUTED 44db8: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 44dbc: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED 44dc0: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_interrupt_disable(level);
44dc2: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED 44dc8: 40c1 movew %sr,%d1 <== NOT EXECUTED 44dca: 8081 orl %d1,%d0 <== NOT EXECUTED 44dcc: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->t_dqlen--;
tty->flow_ctrl &= ~FL_ISNTXOF;
44dce: 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--;
44dd0: 53aa 0090 subql #1,%a2@(144) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
44dd4: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44dd8: c082 andl %d2,%d0 <== NOT EXECUTED 44dda: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
rtems_interrupt_enable(level);
44dde: 46c1 movew %d1,%sr <== NOT EXECUTED
nToSend = 1;
44de0: 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);
44de2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED 44de6: 6000 0108 braw 44ef0 <rtems_termios_refill_transmitter+0x1a8><== NOT EXECUTED
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
44dea: 222a 0080 movel %a2@(128),%d1 44dee: 202a 0084 movel %a2@(132),%d0 44df2: b081 cmpl %d1,%d0
44df4: 661a bnes 44e10 <rtems_termios_refill_transmitter+0xc8>
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
44df6: 7002 moveq #2,%d0 44df8: b0aa 0094 cmpl %a2@(148),%d0 44dfc: 6600 00f0 bnew 44eee <rtems_termios_refill_transmitter+0x1a6>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
44e00: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED 44e04: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release> <== NOT EXECUTED 44e0a: 588f addql #4,%sp <== NOT EXECUTED 44e0c: 6000 00e0 braw 44eee <rtems_termios_refill_transmitter+0x1a6><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
44e10: 203c 0000 0700 movel #1792,%d0 44e16: 40c1 movew %sr,%d1 44e18: 8081 orl %d1,%d0 44e1a: 46c0 movew %d0,%sr
len = tty->t_dqlen;
44e1c: 206a 0090 moveal %a2@(144),%a0
tty->t_dqlen = 0;
44e20: 42aa 0090 clrl %a2@(144)
rtems_interrupt_enable(level);
44e24: 46c1 movew %d1,%sr
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
44e26: 222a 0084 movel %a2@(132),%d1 44e2a: d288 addl %a0,%d1 44e2c: 202a 0088 movel %a2@(136),%d0 44e30: 4c40 1003 remul %d0,%d3,%d1
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
44e34: 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;
44e36: 2543 0084 movel %d3,%a2@(132)
if (tty->rawOutBufState == rob_wait) {
44e3a: b2aa 0094 cmpl %a2@(148),%d1
44e3e: 660c bnes 44e4c <rtems_termios_refill_transmitter+0x104>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
44e40: 2f2a 008c movel %a2@(140),%sp@- 44e44: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release> 44e4a: 588f addql #4,%sp
}
if (newTail == tty->rawOutBuf.Head) {
44e4c: 202a 0080 movel %a2@(128),%d0 44e50: b083 cmpl %d3,%d0
44e52: 661c bnes 44e70 <rtems_termios_refill_transmitter+0x128>
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
44e54: 206a 00d4 moveal %a2@(212),%a0
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
44e58: 42aa 0094 clrl %a2@(148)
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
44e5c: 4a88 tstl %a0 44e5e: 6700 0086 beqw 44ee6 <rtems_termios_refill_transmitter+0x19e>
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
44e62: 2f2a 00d8 movel %a2@(216),%sp@- <== NOT EXECUTED 44e66: 486a 0030 pea %a2@(48) <== NOT EXECUTED 44e6a: 4e90 jsr %a0@ <== NOT EXECUTED 44e6c: 508f addql #8,%sp <== NOT EXECUTED 44e6e: 6076 bras 44ee6 <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))
44e70: 202a 00b8 movel %a2@(184),%d0 44e74: 0280 0000 0210 andil #528,%d0 44e7a: 0c80 0000 0210 cmpil #528,%d0
44e80: 6622 bnes 44ea4 <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);
44e82: 303c 0700 movew #1792,%d0 <== NOT EXECUTED 44e86: 40c1 movew %sr,%d1 <== NOT EXECUTED 44e88: 8081 orl %d1,%d0 <== NOT EXECUTED 44e8a: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
44e8c: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED 44e90: 7420 moveq #32,%d2 <== NOT EXECUTED 44e92: 8082 orl %d2,%d0 <== NOT EXECUTED 44e94: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
44e98: 7001 moveq #1,%d0 <== NOT EXECUTED 44e9a: 2540 0094 movel %d0,%a2@(148) <== NOT EXECUTED
rtems_interrupt_enable(level);
44e9e: 46c1 movew %d1,%sr <== NOT EXECUTED
nToSend = 0;
44ea0: 4202 clrb %d2 <== NOT EXECUTED 44ea2: 6044 bras 44ee8 <rtems_termios_refill_transmitter+0x1a0><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
44ea4: 202a 0080 movel %a2@(128),%d0 44ea8: b083 cmpl %d3,%d0
44eaa: 6406 bccs 44eb2 <rtems_termios_refill_transmitter+0x16a>
nToSend = tty->rawOutBuf.Size - newTail;
44eac: 242a 0088 movel %a2@(136),%d2 44eb0: 6004 bras 44eb6 <rtems_termios_refill_transmitter+0x16e>
else
nToSend = tty->rawOutBuf.Head - newTail;
44eb2: 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)) {
44eb6: 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;
44eba: 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)) {
44ebc: 0280 0000 0600 andil #1536,%d0
44ec2: 6702 beqs 44ec6 <rtems_termios_refill_transmitter+0x17e>
nToSend = 1;
44ec4: 7401 moveq #1,%d2
}
tty->rawOutBufState = rob_busy; /*apm*/
44ec6: 7201 moveq #1,%d1 44ec8: 2541 0094 movel %d1,%a2@(148)
(*tty->device.write)(
44ecc: 2f02 movel %d2,%sp@- 44ece: 202a 007c movel %a2@(124),%d0 44ed2: d083 addl %d3,%d0 44ed4: 2f00 movel %d0,%sp@- 44ed6: 2f2a 0010 movel %a2@(16),%sp@- 44eda: 206a 00a4 moveal %a2@(164),%a0 44ede: 4e90 jsr %a0@ 44ee0: 4fef 000c lea %sp@(12),%sp 44ee4: 6002 bras 44ee8 <rtems_termios_refill_transmitter+0x1a0>
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
44ee6: 4282 clrl %d2
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
44ee8: 2543 0084 movel %d3,%a2@(132) 44eec: 6002 bras 44ef0 <rtems_termios_refill_transmitter+0x1a8>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
44eee: 4282 clrl %d2
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
44ef0: 2002 movel %d2,%d0 44ef2: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
44ef8: 4e5e unlk %fp <== NOT EXECUTED
00044cd8 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
44cd8: 4e56 ffe0 linkw %fp,#-32 44cdc: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44ce0: 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);
44ce2: 240e movel %fp,%d2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44ce4: 5d83 subql #6,%d3 44ce6: 4bf9 0004 52a0 lea 452a0 <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);
44cec: 49f9 0004 5b30 lea 45b30 <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);
44cf2: 5382 subql #1,%d2 44cf4: 47f9 0004 4a88 lea 44a88 <rtems_termios_enqueue_raw_characters>,%a3
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
44cfa: 246e 0008 moveal %fp@(8),%a2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44cfe: 2f03 movel %d3,%sp@- 44d00: 42a7 clrl %sp@- 44d02: 4878 0002 pea 2 <DOUBLE_FLOAT> 44d06: 4878 0003 pea 3 <DIVIDE> 44d0a: 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) {
44d0c: 4fef 0010 lea %sp@(16),%sp 44d10: 7001 moveq #1,%d0 44d12: c0ae fffa andl %fp@(-6),%d0
44d16: 670a beqs 44d22 <rtems_termios_rxdaemon+0x4a> <== ALWAYS TAKEN
tty->rxTaskId = 0;
44d18: 42aa 00c4 clrl %a2@(196) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
44d1c: 42a7 clrl %sp@- <== NOT EXECUTED 44d1e: 4e94 jsr %a4@ <== NOT EXECUTED 44d20: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
44d22: 2f2a 0010 movel %a2@(16),%sp@- 44d26: 206a 00a0 moveal %a2@(160),%a0 44d2a: 4e90 jsr %a0@
if (c != EOF) {
44d2c: 588f addql #4,%sp 44d2e: 72ff moveq #-1,%d1 44d30: b280 cmpl %d0,%d1
44d32: 67ca beqs 44cfe <rtems_termios_rxdaemon+0x26>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44d34: 4878 0001 pea 1 <ADD>
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
44d38: 1d40 ffff moveb %d0,%fp@(-1)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44d3c: 2f02 movel %d2,%sp@- 44d3e: 2f0a movel %a2,%sp@- 44d40: 4e93 jsr %a3@ 44d42: 4fef 000c lea %sp@(12),%sp 44d46: 60b6 bras 44cfe <rtems_termios_rxdaemon+0x26>
00044efc <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
44efc: 4e56 ffe8 linkw %fp,#-24 44f00: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44f04: 240e movel %fp,%d2 44f06: 5982 subql #4,%d2 44f08: 4bf9 0004 52a0 lea 452a0 <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);
44f0e: 49f9 0004 5b30 lea 45b30 <rtems_task_delete>,%a4
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
44f14: 47f9 0004 4d48 lea 44d48 <rtems_termios_refill_transmitter>,%a3
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
44f1a: 246e 0008 moveal %fp@(8),%a2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44f1e: 2f02 movel %d2,%sp@- 44f20: 42a7 clrl %sp@- 44f22: 4878 0002 pea 2 <DOUBLE_FLOAT> 44f26: 4878 0003 pea 3 <DIVIDE> 44f2a: 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) {
44f2c: 4fef 0010 lea %sp@(16),%sp 44f30: 7001 moveq #1,%d0 44f32: c0ae fffc andl %fp@(-4),%d0
44f36: 670a beqs 44f42 <rtems_termios_txdaemon+0x46> <== ALWAYS TAKEN
tty->txTaskId = 0;
44f38: 42aa 00c8 clrl %a2@(200) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
44f3c: 42a7 clrl %sp@- <== NOT EXECUTED 44f3e: 4e94 jsr %a4@ <== NOT EXECUTED 44f40: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
44f42: 202a 00cc movel %a2@(204),%d0 44f46: eb88 lsll #5,%d0 44f48: 0680 0005 e090 addil #385168,%d0 44f4e: 2240 moveal %d0,%a1 44f50: 2051 moveal %a1@,%a0 44f52: 4a88 tstl %a0
44f54: 6706 beqs 44f5c <rtems_termios_txdaemon+0x60> <== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
44f56: 2f0a movel %a2,%sp@- <== NOT EXECUTED 44f58: 4e90 jsr %a0@ <== NOT EXECUTED 44f5a: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
44f5c: 2f0a movel %a2,%sp@- 44f5e: 4e93 jsr %a3@
}
44f60: 588f addql #4,%sp 44f62: 60ba bras 44f1e <rtems_termios_txdaemon+0x22>
000446de <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
446de: 4e56 ffe8 linkw %fp,#-24 446e2: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@ 446e6: 246e 0008 moveal %fp@(8),%a2
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
446ea: 2052 moveal %a2@,%a0 446ec: 2668 0034 moveal %a0@(52),%a3
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
446f0: 42a7 clrl %sp@- 446f2: 42a7 clrl %sp@- 446f4: 2f2b 0018 movel %a3@(24),%sp@- 446f8: 4eb9 0004 5854 jsr 45854 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
446fe: 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);
44702: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
44704: 6600 0084 bnew 4478a <rtems_termios_write+0xac>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
44708: 202b 00cc movel %a3@(204),%d0 4470c: eb88 lsll #5,%d0 4470e: 0680 0005 e088 addil #385160,%d0 44714: 2240 moveal %d0,%a1 44716: 2051 moveal %a1@,%a0 44718: 4a88 tstl %a0
4471a: 6718 beqs 44734 <rtems_termios_write+0x56>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
4471c: 2f0a movel %a2,%sp@- 4471e: 2f0b movel %a3,%sp@- 44720: 4e90 jsr %a0@
rtems_semaphore_release (tty->osem);
44722: 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);
44726: 2400 movel %d0,%d2
rtems_semaphore_release (tty->osem);
44728: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return sc;
4472e: 4fef 000c lea %sp@(12),%sp 44732: 6056 bras 4478a <rtems_termios_write+0xac>
}
if (tty->termios.c_oflag & OPOST) {
44734: 7001 moveq #1,%d0 44736: c0ab 0034 andl %a3@(52),%d0
4473a: 6728 beqs 44764 <rtems_termios_write+0x86> <== NEVER TAKEN
uint32_t count = args->count;
4473c: 262a 0010 movel %a2@(16),%d3
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
44740: 4bfa fa68 lea %pc@(441aa <oproc>),%a5
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
44744: 286a 000c moveal %a2@(12),%a4
while (count--)
44748: 600e bras 44758 <rtems_termios_write+0x7a>
oproc (*buffer++, tty);
4474a: 4280 clrl %d0 4474c: 101c moveb %a4@+,%d0 4474e: 5383 subql #1,%d3 44750: 2f0b movel %a3,%sp@- 44752: 2f00 movel %d0,%sp@- 44754: 4e95 jsr %a5@ 44756: 508f addql #8,%sp
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
44758: 4a83 tstl %d3
4475a: 66ee bnes 4474a <rtems_termios_write+0x6c>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
4475c: 256a 0010 0018 movel %a2@(16),%a2@(24) 44762: 601a bras 4477e <rtems_termios_write+0xa0>
} else {
rtems_termios_puts (args->buffer, args->count, tty);
44764: 2f0b movel %a3,%sp@- <== NOT EXECUTED 44766: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED 4476a: 2f2a 000c movel %a2@(12),%sp@- <== NOT EXECUTED 4476e: 4eb9 0004 40b2 jsr 440b2 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
44774: 256a 0010 0018 movel %a2@(16),%a2@(24) <== NOT EXECUTED 4477a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
} rtems_semaphore_release (tty->osem);
4477e: 2f2b 0018 movel %a3@(24),%sp@- 44782: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
return sc;
44788: 588f addql #4,%sp
}
4478a: 2002 movel %d2,%d0 4478c: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
44792: 4e5e unlk %fp <== NOT EXECUTED
00051c5c <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
51c5c: 4e56 fffc linkw %fp,#-4
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
51c60: 486e fffc pea %fp@(-4) 51c64: 2f2e 0008 movel %fp@(8),%sp@- 51c68: 4879 0007 7d9e pea 77d9e <_Timer_Information> 51c6e: 4eb9 0005 46c4 jsr 546c4 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
51c74: 4fef 000c lea %sp@(12),%sp 51c78: 4aae fffc tstl %fp@(-4)
51c7c: 6620 bnes 51c9e <rtems_timer_cancel+0x42>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
51c7e: 7204 moveq #4,%d1 51c80: 2040 moveal %d0,%a0 51c82: b2a8 0038 cmpl %a0@(56),%d1
51c86: 670c beqs 51c94 <rtems_timer_cancel+0x38> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
51c88: 4868 0010 pea %a0@(16) 51c8c: 4eb9 0005 6260 jsr 56260 <_Watchdog_Remove> 51c92: 588f addql #4,%sp
_Thread_Enable_dispatch();
51c94: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
51c9a: 4280 clrl %d0 51c9c: 6002 bras 51ca0 <rtems_timer_cancel+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
51c9e: 7004 moveq #4,%d0
}
51ca0: 4e5e unlk %fp <== NOT EXECUTED
00051f98 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
51f98: 4e56 fffc linkw %fp,#-4 51f9c: 2f0b movel %a3,%sp@- 51f9e: 2f0a movel %a2,%sp@- 51fa0: 486e fffc pea %fp@(-4) 51fa4: 2f2e 0008 movel %fp@(8),%sp@- 51fa8: 4879 0007 7d9e pea 77d9e <_Timer_Information> 51fae: 4eb9 0005 46c4 jsr 546c4 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
51fb4: 4fef 000c lea %sp@(12),%sp 51fb8: 2440 moveal %d0,%a2 51fba: 4aae fffc tstl %fp@(-4)
51fbe: 6656 bnes 52016 <rtems_timer_reset+0x7e> <== NEVER TAKEN
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
51fc0: 202a 0038 movel %a2@(56),%d0
51fc4: 661c bnes 51fe2 <rtems_timer_reset+0x4a>
_Watchdog_Remove( &the_timer->Ticker );
51fc6: 45ea 0010 lea %a2@(16),%a2 51fca: 2f0a movel %a2,%sp@- 51fcc: 4eb9 0005 6260 jsr 56260 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
51fd2: 2f0a movel %a2,%sp@- 51fd4: 4879 0007 75dc pea 775dc <_Watchdog_Ticks_chain> 51fda: 4eb9 0005 6138 jsr 56138 <_Watchdog_Insert> 51fe0: 6020 bras 52002 <rtems_timer_reset+0x6a>
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51fe2: 7201 moveq #1,%d1 51fe4: b280 cmpl %d0,%d1
51fe6: 6622 bnes 5200a <rtems_timer_reset+0x72> <== NEVER TAKEN
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
51fe8: 486a 0010 pea %a2@(16)
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
Timer_server_Control *timer_server = _Timer_server;
51fec: 2679 0007 7dd8 moveal 77dd8 <_Timer_server>,%a3
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
51ff2: 4eb9 0005 6260 jsr 56260 <_Watchdog_Remove>
(*timer_server->schedule_operation)( timer_server, the_timer );
51ff8: 2f0a movel %a2,%sp@- 51ffa: 2f0b movel %a3,%sp@- 51ffc: 206b 0004 moveal %a3@(4),%a0 52000: 4e90 jsr %a0@ 52002: 4fef 000c lea %sp@(12),%sp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
52006: 95ca subal %a2,%a2 52008: 6004 bras 5200e <rtems_timer_reset+0x76>
/*
* Must be dormant or time of day timer (e.g. TIMER_DORMANT,
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
5200a: 347c 000b moveaw #11,%a2
}
_Thread_Enable_dispatch();
5200e: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
return status;
52014: 6004 bras 5201a <rtems_timer_reset+0x82>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
52016: 347c 0004 moveaw #4,%a2
}
5201a: 200a movel %a2,%d0 5201c: 246e fff4 moveal %fp@(-12),%a2 52020: 266e fff8 moveal %fp@(-8),%a3
52024: 4e5e unlk %fp <== NOT EXECUTED
000520e4 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
520e4: 4e56 ffe8 linkw %fp,#-24 520e8: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 520ec: 262e 0008 movel %fp@(8),%d3 520f0: 242e 000c movel %fp@(12),%d2 520f4: 282e 0010 movel %fp@(16),%d4
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
520f8: 2679 0007 7dd8 moveal 77dd8 <_Timer_server>,%a3
if ( !timer_server )
520fe: 4a8b tstl %a3 52100: 6700 0098 beqw 5219a <rtems_timer_server_fire_when+0xb6>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
52104: 4a39 0007 752c tstb 7752c <_TOD_Is_set> 5210a: 6700 0092 beqw 5219e <rtems_timer_server_fire_when+0xba>
return RTEMS_NOT_DEFINED;
if ( !routine )
5210e: 4a84 tstl %d4 52110: 6700 0090 beqw 521a2 <rtems_timer_server_fire_when+0xbe>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
52114: 2f02 movel %d2,%sp@- 52116: 4eb9 0004 f5a4 jsr 4f5a4 <_TOD_Validate> 5211c: 588f addql #4,%sp 5211e: 4a00 tstb %d0 52120: 6700 0084 beqw 521a6 <rtems_timer_server_fire_when+0xc2>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
52124: 2f02 movel %d2,%sp@- 52126: 4eb9 0004 f508 jsr 4f508 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
5212c: 588f addql #4,%sp
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
5212e: 2400 movel %d0,%d2
if ( seconds <= _TOD_Seconds_since_epoch() )
52130: b0b9 0007 75a6 cmpl 775a6 <_TOD_Now>,%d0
52136: 636e blss 521a6 <rtems_timer_server_fire_when+0xc2>
52138: 486e fffc pea %fp@(-4) 5213c: 2f03 movel %d3,%sp@- 5213e: 4879 0007 7d9e pea 77d9e <_Timer_Information> 52144: 4eb9 0005 46c4 jsr 546c4 <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
5214a: 4fef 000c lea %sp@(12),%sp 5214e: 2440 moveal %d0,%a2 52150: 4aae fffc tstl %fp@(-4)
52154: 6654 bnes 521aa <rtems_timer_server_fire_when+0xc6>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
52156: 486a 0010 pea %a2@(16) 5215a: 4eb9 0005 6260 jsr 56260 <_Watchdog_Remove>
the_watchdog->user_data = user_data;
52160: 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();
52166: 94b9 0007 75a6 subl 775a6 <_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;
5216c: 7003 moveq #3,%d0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
5216e: 42aa 0018 clrl %a2@(24) 52172: 2540 0038 movel %d0,%a2@(56)
the_watchdog->routine = routine;
52176: 2544 002c movel %d4,%a2@(44)
the_watchdog->id = id;
5217a: 2543 0030 movel %d3,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
5217e: 2542 001c movel %d2,%a2@(28)
(*timer_server->schedule_operation)( timer_server, the_timer );
52182: 2f0a movel %a2,%sp@- 52184: 2f0b movel %a3,%sp@- 52186: 206b 0004 moveal %a3@(4),%a0 5218a: 4e90 jsr %a0@
_Thread_Enable_dispatch();
5218c: 4eb9 0005 526e jsr 5526e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
52192: 4fef 000c lea %sp@(12),%sp 52196: 4280 clrl %d0 52198: 6012 bras 521ac <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;
5219a: 700e moveq #14,%d0 5219c: 600e bras 521ac <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
5219e: 700b moveq #11,%d0 <== NOT EXECUTED 521a0: 600a bras 521ac <rtems_timer_server_fire_when+0xc8><== NOT EXECUTED
if ( !routine )
return RTEMS_INVALID_ADDRESS;
521a2: 7009 moveq #9,%d0 521a4: 6006 bras 521ac <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;
521a6: 7014 moveq #20,%d0 521a8: 6002 bras 521ac <rtems_timer_server_fire_when+0xc8>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
521aa: 7004 moveq #4,%d0
}
521ac: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3 521b2: 4e5e unlk %fp
...
000426b8 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
426b8: 4e56 fff0 linkw %fp,#-16 426bc: 48d7 041c moveml %d2-%d4/%a2,%sp@ 426c0: 242e 0008 movel %fp@(8),%d2
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
426c4: 0802 001d btst #29,%d2
426c8: 672e beqs 426f8 <rtems_verror+0x40>
if (rtems_panic_in_progress++)
426ca: 2039 0005 e870 movel 5e870 <rtems_panic_in_progress>,%d0 426d0: 2200 movel %d0,%d1 426d2: 5281 addql #1,%d1 426d4: 23c1 0005 e870 movel %d1,5e870 <rtems_panic_in_progress> 426da: 4a80 tstl %d0
426dc: 670e beqs 426ec <rtems_verror+0x34> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
426de: 2039 0005 e9c8 movel 5e9c8 <_Thread_Dispatch_disable_level>,%d0<== NOT EXECUTED 426e4: 5280 addql #1,%d0 <== NOT EXECUTED 426e6: 23c0 0005 e9c8 movel %d0,5e9c8 <_Thread_Dispatch_disable_level><== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
426ec: 7002 moveq #2,%d0 426ee: b0b9 0005 e870 cmpl 5e870 <rtems_panic_in_progress>,%d0 426f4: 6d00 0100 bltw 427f6 <rtems_verror+0x13e>
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
426f8: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0
status = error_flag & ~RTEMS_ERROR_MASK;
426fe: 2802 movel %d2,%d4
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
42700: 2f28 0008 movel %a0@(8),%sp@-
status = error_flag & ~RTEMS_ERROR_MASK;
42704: 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 */
4270a: 4eb9 0004 ce3a jsr 4ce3a <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
42710: 588f addql #4,%sp 42712: 0802 001e btst #30,%d2
42716: 670c beqs 42724 <rtems_verror+0x6c>
local_errno = errno;
42718: 4eb9 0004 cad0 jsr 4cad0 <__errno> 4271e: 2040 moveal %d0,%a0 42720: 2610 movel %a0@,%d3 42722: 6002 bras 42726 <rtems_verror+0x6e>
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
42724: 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);
42726: 2f2e 0010 movel %fp@(16),%sp@- 4272a: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0 42730: 2f2e 000c movel %fp@(12),%sp@- 42734: 2f28 000c movel %a0@(12),%sp@- 42738: 4eb9 0005 3eda jsr 53eda <vfprintf>
if (status)
4273e: 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);
42742: 2400 movel %d0,%d2
if (status)
42744: 4a84 tstl %d4
42746: 6726 beqs 4276e <rtems_verror+0xb6>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
42748: 2f04 movel %d4,%sp@- 4274a: 4eb9 0004 26a0 jsr 426a0 <rtems_status_text> 42750: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0 42756: 2f00 movel %d0,%sp@- 42758: 4879 0005 bc05 pea 5bc05 <IMFS_ops+0x4f> 4275e: 2f28 000c movel %a0@(12),%sp@- 42762: 4eb9 0004 d262 jsr 4d262 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
42768: 4fef 0010 lea %sp@(16),%sp 4276c: d480 addl %d0,%d2
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
4276e: 4a83 tstl %d3
42770: 6756 beqs 427c8 <rtems_verror+0x110>
if ((local_errno > 0) && *strerror(local_errno))
42772: 6f36 bles 427aa <rtems_verror+0xf2>
42774: 2f03 movel %d3,%sp@- 42776: 45f9 0004 daf8 lea 4daf8 <strerror>,%a2 4277c: 4e92 jsr %a2@ 4277e: 588f addql #4,%sp 42780: 2040 moveal %d0,%a0 42782: 4a10 tstb %a0@
42784: 6724 beqs 427aa <rtems_verror+0xf2> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
42786: 2f03 movel %d3,%sp@- 42788: 4e92 jsr %a2@ 4278a: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0 42790: 2f00 movel %d0,%sp@- 42792: 4879 0005 bc13 pea 5bc13 <IMFS_ops+0x5d> 42798: 2f28 000c movel %a0@(12),%sp@- 4279c: 4eb9 0004 d262 jsr 4d262 <fprintf> 427a2: 4fef 0010 lea %sp@(16),%sp 427a6: d480 addl %d0,%d2 427a8: 601e bras 427c8 <rtems_verror+0x110>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
427aa: 2f03 movel %d3,%sp@- 427ac: 4879 0005 bc20 pea 5bc20 <IMFS_ops+0x6a> 427b2: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0 427b8: 2f28 000c movel %a0@(12),%sp@- 427bc: 4eb9 0004 d262 jsr 4d262 <fprintf> 427c2: 4fef 000c lea %sp@(12),%sp 427c6: d480 addl %d0,%d2
}
chars_written += fprintf(stderr, "\n");
427c8: 4879 0005 b847 pea 5b847 <rtems_filesystem_mount_table_size+0x2f9> 427ce: 2079 0005 d30c moveal 5d30c <_impure_ptr>,%a0 427d4: 2f28 000c movel %a0@(12),%sp@- 427d8: 4eb9 0004 d262 jsr 4d262 <fprintf>
(void) fflush(stderr);
427de: 2079 0005 d30c moveal 5d30c <_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");
427e4: d480 addl %d0,%d2
(void) fflush(stderr);
427e6: 2f28 000c movel %a0@(12),%sp@- 427ea: 4eb9 0004 ce3a jsr 4ce3a <fflush>
return chars_written;
427f0: 4fef 000c lea %sp@(12),%sp 427f4: 6002 bras 427f8 <rtems_verror+0x140>
if (rtems_panic_in_progress++)
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
427f6: 4282 clrl %d2 <== NOT EXECUTED
chars_written += fprintf(stderr, "\n");
(void) fflush(stderr);
return chars_written;
}
427f8: 2002 movel %d2,%d0 427fa: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
42800: 4e5e unlk %fp <== NOT EXECUTED
00043030 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
43030: 4e56 ffe4 linkw %fp,#-28 43034: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@ 43038: 246e 0008 moveal %fp@(8),%a2
int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0;
4303c: 4283 clrl %d3
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
4303e: 283c 7fff ffff movel #2147483647,%d4
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
43044: 4282 clrl %d2
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
43046: 47f9 0004 f400 lea 4f400 <__srget_r>,%a3 4304c: 202a 0004 movel %a2@(4),%d0 43050: 5380 subql #1,%d0 43052: 2540 0004 movel %d0,%a2@(4)
43056: 6c0e bges 43066 <scanInt+0x36> <== ALWAYS TAKEN
43058: 2f0a movel %a2,%sp@- <== NOT EXECUTED 4305a: 2f39 0005 ec1c movel 5ec1c <_impure_ptr>,%sp@- <== NOT EXECUTED 43060: 4e93 jsr %a3@ <== NOT EXECUTED 43062: 508f addql #8,%sp <== NOT EXECUTED 43064: 600a bras 43070 <scanInt+0x40> <== NOT EXECUTED
43066: 2052 moveal %a2@,%a0 43068: 4280 clrl %d0 4306a: 1010 moveb %a0@,%d0 4306c: 5288 addql #1,%a0 4306e: 2488 movel %a0,%a2@
if (c == ':')
43070: 723a moveq #58,%d1 43072: b280 cmpl %d0,%d1
43074: 6750 beqs 430c6 <scanInt+0x96>
break;
if (sign == 0) {
43076: 4a83 tstl %d3
43078: 660e bnes 43088 <scanInt+0x58>
if (c == '-') {
4307a: 7c2d moveq #45,%d6 4307c: bc80 cmpl %d0,%d6
4307e: 6606 bnes 43086 <scanInt+0x56>
sign = -1;
limit++;
43080: 5284 addql #1,%d4
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
43082: 76ff moveq #-1,%d3
limit++;
continue;
43084: 60c6 bras 4304c <scanInt+0x1c>
}
sign = 1;
43086: 7601 moveq #1,%d3
}
if (!isdigit(c))
43088: 2079 0005 ec18 moveal 5ec18 <__ctype_ptr__>,%a0 4308e: 1230 0801 moveb %a0@(00000001,%d0:l),%d1 43092: 49c1 extbl %d1 43094: 44c1 movew %d1,%ccr
43096: 6640 bnes 430d8 <scanInt+0xa8>
return 0;
d = c - '0';
if ((i > (limit / 10))
43098: 2204 movel %d4,%d1 4309a: 7c0a moveq #10,%d6 4309c: 4c46 1005 remul %d6,%d5,%d1 430a0: 4c46 1001 remul %d6,%d1,%d1 430a4: b282 cmpl %d2,%d1
430a6: 6530 bcss 430d8 <scanInt+0xa8>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
430a8: 0680 ffff ffd0 addil #-48,%d0
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
430ae: b282 cmpl %d2,%d1
430b0: 6604 bnes 430b6 <scanInt+0x86>
430b2: ba80 cmpl %d0,%d5
430b4: 6522 bcss 430d8 <scanInt+0xa8> <== ALWAYS TAKEN
return 0;
i = i * 10 + d;
430b6: 2202 movel %d2,%d1 430b8: e789 lsll #3,%d1 430ba: 2241 moveal %d1,%a1 430bc: 41f1 2a00 lea %a1@(00000000,%d2:l:2),%a0 430c0: 2400 movel %d0,%d2 430c2: d488 addl %a0,%d2 430c4: 6086 bras 4304c <scanInt+0x1c>
} if (sign == 0)
430c6: 4a83 tstl %d3
430c8: 670e beqs 430d8 <scanInt+0xa8> <== NEVER TAKEN
return 0;
*val = i * sign;
430ca: 4c02 3800 mulsl %d2,%d3
return 1;
430ce: 7001 moveq #1,%d0
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
430d0: 206e 000c moveal %fp@(12),%a0 430d4: 2083 movel %d3,%a0@
return 1;
430d6: 6002 bras 430da <scanInt+0xaa>
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
430d8: 4280 clrl %d0
*val = i * sign; return 1; }
430da: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
430e0: 4e5e unlk %fp <== NOT EXECUTED
00043172 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
43172: 4e56 ffe4 linkw %fp,#-28 43176: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
4317a: 42a7 clrl %sp@- 4317c: 280e movel %fp,%d4 4317e: 0684 0000 0014 addil #20,%d4 43184: 260e movel %fp,%d3 43186: 0683 0000 0010 addil #16,%d3 4318c: 47fa ff56 lea %pc@(430e4 <scanString>),%a3 43190: 2f04 movel %d4,%sp@-
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
43192: 246e 000c moveal %fp@(12),%a2
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
43196: 2f03 movel %d3,%sp@-
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
43198: 242e 0008 movel %fp@(8),%d2
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
4319c: 2f0a movel %a2,%sp@- 4319e: 2f02 movel %d2,%sp@- 431a0: 4e93 jsr %a3@ 431a2: 4fef 0014 lea %sp@(20),%sp 431a6: 4a80 tstl %d0 431a8: 6700 00b6 beqw 43260 <scangr+0xee>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
431ac: 42a7 clrl %sp@- 431ae: 2f04 movel %d4,%sp@- 431b0: 2f03 movel %d3,%sp@- 431b2: 486a 0004 pea %a2@(4) 431b6: 2f02 movel %d2,%sp@- 431b8: 4e93 jsr %a3@ 431ba: 4fef 0014 lea %sp@(20),%sp 431be: 4a80 tstl %d0 431c0: 6700 009e beqw 43260 <scangr+0xee>
|| !scanInt(fp, &grgid)
431c4: 486e fffc pea %fp@(-4) 431c8: 2f02 movel %d2,%sp@- 431ca: 4eba fe64 jsr %pc@(43030 <scanInt>) 431ce: 508f addql #8,%sp 431d0: 4a80 tstl %d0 431d2: 6700 008c beqw 43260 <scangr+0xee>
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
431d6: 4878 0001 pea 1 <ADD> 431da: 2f04 movel %d4,%sp@- 431dc: 2f03 movel %d3,%sp@- 431de: 486e fff8 pea %fp@(-8) 431e2: 2f02 movel %d2,%sp@- 431e4: 4e93 jsr %a3@ 431e6: 4fef 0014 lea %sp@(20),%sp 431ea: 4a80 tstl %d0
431ec: 6772 beqs 43260 <scangr+0xee> <== NEVER TAKEN
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431ee: 222e fff8 movel %fp@(-8),%d1 431f2: 7001 moveq #1,%d0 431f4: 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;
431f6: 356e fffe 0008 movew %fp@(-2),%a2@(8)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431fc: 600a bras 43208 <scangr+0x96>
if(*cp == ',')
431fe: 49c2 extbl %d2 43200: 762c moveq #44,%d3 43202: b682 cmpl %d2,%d3
43204: 6602 bnes 43208 <scangr+0x96>
memcount++;
43206: 5280 addql #1,%d0
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
43208: 1418 moveb %a0@+,%d2
4320a: 66f2 bnes 431fe <scangr+0x8c>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
4320c: e588 lsll #2,%d0 4320e: 0680 0000 0013 addil #19,%d0 43214: b0ae 0014 cmpl %fp@(20),%d0
43218: 6246 bhis 43260 <scangr+0xee> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
4321a: 202e 0010 movel %fp@(16),%d0 4321e: 74f0 moveq #-16,%d2 43220: 0680 0000 000f addil #15,%d0 43226: c082 andl %d2,%d0 43228: 2540 000a movel %d0,%a2@(10)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
4322c: 2040 moveal %d0,%a0
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
4322e: 7001 moveq #1,%d0
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
43230: 2081 movel %d1,%a0@ 43232: 206e fff8 moveal %fp@(-8),%a0
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
43236: 6018 bras 43250 <scangr+0xde>
if(*cp == ',') {
43238: 49c1 extbl %d1 4323a: 742c moveq #44,%d2 4323c: b481 cmpl %d1,%d2
4323e: 6610 bnes 43250 <scangr+0xde>
*cp = '\0';
43240: 4203 clrb %d3 43242: 1143 ffff moveb %d3,%a0@(-1)
grp->gr_mem[memcount++] = cp + 1;
43246: 226a 000a moveal %a2@(10),%a1 4324a: 2388 0c00 movel %a0,%a1@(00000000,%d0:l:4) 4324e: 5280 addql #1,%d0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
43250: 1218 moveb %a0@+,%d1
43252: 66e4 bnes 43238 <scangr+0xc6>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
43254: 206a 000a moveal %a2@(10),%a0 43258: 42b0 0c00 clrl %a0@(00000000,%d0:l:4)
return 1;
4325c: 7001 moveq #1,%d0 4325e: 6002 bras 43262 <scangr+0xf0>
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
43260: 4280 clrl %d0
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
43262: 4cee 0c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a3
43268: 4e5e unlk %fp <== NOT EXECUTED
0004326c <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
4326c: 4e56 ffe0 linkw %fp,#-32 43270: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
43274: 42a7 clrl %sp@- 43276: 280e movel %fp,%d4 43278: 0684 0000 0014 addil #20,%d4 4327e: 260e movel %fp,%d3 43280: 0683 0000 0010 addil #16,%d3 43286: 47fa fe5c lea %pc@(430e4 <scanString>),%a3 4328a: 2f04 movel %d4,%sp@-
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
4328c: 246e 000c moveal %fp@(12),%a2
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
43290: 2f03 movel %d3,%sp@-
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
43292: 242e 0008 movel %fp@(8),%d2
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
43296: 2f0a movel %a2,%sp@- 43298: 2f02 movel %d2,%sp@- 4329a: 4e93 jsr %a3@ 4329c: 4fef 0014 lea %sp@(20),%sp 432a0: 4a80 tstl %d0 432a2: 6700 00a4 beqw 43348 <scanpw+0xdc>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
432a6: 42a7 clrl %sp@- 432a8: 2f04 movel %d4,%sp@- 432aa: 2f03 movel %d3,%sp@- 432ac: 486a 0004 pea %a2@(4) 432b0: 2f02 movel %d2,%sp@- 432b2: 4e93 jsr %a3@ 432b4: 4fef 0014 lea %sp@(20),%sp 432b8: 4a80 tstl %d0 432ba: 6700 008c beqw 43348 <scanpw+0xdc>
|| !scanInt(fp, &pwuid)
432be: 486e fffc pea %fp@(-4) 432c2: 49fa fd6c lea %pc@(43030 <scanInt>),%a4 432c6: 2f02 movel %d2,%sp@- 432c8: 4e94 jsr %a4@ 432ca: 508f addql #8,%sp 432cc: 4a80 tstl %d0
432ce: 6778 beqs 43348 <scanpw+0xdc> || !scanInt(fp, &pwgid)
432d0: 486e fff8 pea %fp@(-8) 432d4: 2f02 movel %d2,%sp@- 432d6: 4e94 jsr %a4@ 432d8: 508f addql #8,%sp 432da: 4a80 tstl %d0
432dc: 676a beqs 43348 <scanpw+0xdc> || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
432de: 42a7 clrl %sp@- 432e0: 2f04 movel %d4,%sp@- 432e2: 2f03 movel %d3,%sp@- 432e4: 486a 000c pea %a2@(12) 432e8: 2f02 movel %d2,%sp@- 432ea: 4e93 jsr %a3@ 432ec: 4fef 0014 lea %sp@(20),%sp 432f0: 4a80 tstl %d0
432f2: 6754 beqs 43348 <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
432f4: 42a7 clrl %sp@- 432f6: 2f04 movel %d4,%sp@- 432f8: 2f03 movel %d3,%sp@- 432fa: 486a 0010 pea %a2@(16) 432fe: 2f02 movel %d2,%sp@- 43300: 4e93 jsr %a3@ 43302: 4fef 0014 lea %sp@(20),%sp 43306: 4a80 tstl %d0
43308: 673e beqs 43348 <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
4330a: 42a7 clrl %sp@- 4330c: 2f04 movel %d4,%sp@- 4330e: 2f03 movel %d3,%sp@- 43310: 486a 0014 pea %a2@(20) 43314: 2f02 movel %d2,%sp@- 43316: 4e93 jsr %a3@ 43318: 4fef 0014 lea %sp@(20),%sp 4331c: 4a80 tstl %d0
4331e: 6728 beqs 43348 <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
43320: 4878 0001 pea 1 <ADD> 43324: 2f04 movel %d4,%sp@- 43326: 2f03 movel %d3,%sp@- 43328: 486a 0018 pea %a2@(24) 4332c: 2f02 movel %d2,%sp@- 4332e: 4e93 jsr %a3@ 43330: 4fef 0014 lea %sp@(20),%sp 43334: 4a80 tstl %d0
43336: 6710 beqs 43348 <scanpw+0xdc>
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
43338: 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;
4333a: 356e fffe 0008 movew %fp@(-2),%a2@(8)
pwd->pw_gid = pwgid;
43340: 356e fffa 000a movew %fp@(-6),%a2@(10)
return 1;
43346: 6002 bras 4334a <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;
43348: 4280 clrl %d0
pwd->pw_uid = pwuid; pwd->pw_gid = pwgid; return 1; }
4334a: 4cee 1c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a4
43350: 4e5e unlk %fp <== NOT EXECUTED
00045ff0 <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
45ff0: 7004 moveq #4,%d0
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
45ff2: 4e56 0000 linkw %fp,#0 45ff6: 222e 0008 movel %fp@(8),%d1
switch ( policy ) {
45ffa: b081 cmpl %d1,%d0
45ffc: 650c bcss 4600a <sched_get_priority_max+0x1a> <== NEVER TAKEN
45ffe: 103c 0001 moveb #1,%d0 46002: e3a8 lsll %d1,%d0 46004: 7217 moveq #23,%d1 46006: c081 andl %d1,%d0
46008: 6610 bnes 4601a <sched_get_priority_max+0x2a> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
4600a: 4eb9 0004 d690 jsr 4d690 <__errno> 46010: 2040 moveal %d0,%a0 46012: 7016 moveq #22,%d0 46014: 2080 movel %d0,%a0@ 46016: 70ff moveq #-1,%d0 46018: 600a bras 46024 <sched_get_priority_max+0x34>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
4601a: 4280 clrl %d0 4601c: 1039 0005 e126 moveb 5e126 <rtems_maximum_priority>,%d0 46022: 5380 subql #1,%d0
}
46024: 4e5e unlk %fp <== NOT EXECUTED
00046028 <sched_get_priority_min>:
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
46028: 7004 moveq #4,%d0
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
4602a: 4e56 0000 linkw %fp,#0 4602e: 222e 0008 movel %fp@(8),%d1
switch ( policy ) {
46032: b081 cmpl %d1,%d0
46034: 650c bcss 46042 <sched_get_priority_min+0x1a>
46036: 103c 0001 moveb #1,%d0 4603a: e3a8 lsll %d1,%d0 4603c: 7217 moveq #23,%d1 4603e: c081 andl %d1,%d0
46040: 6610 bnes 46052 <sched_get_priority_min+0x2a> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
46042: 4eb9 0004 d690 jsr 4d690 <__errno> 46048: 2040 moveal %d0,%a0 4604a: 7016 moveq #22,%d0 4604c: 2080 movel %d0,%a0@ 4604e: 70ff moveq #-1,%d0 46050: 6002 bras 46054 <sched_get_priority_min+0x2c>
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
46052: 7001 moveq #1,%d0
}
46054: 4e5e unlk %fp <== NOT EXECUTED
00046058 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
46058: 4e56 0000 linkw %fp,#0 4605c: 2f03 movel %d3,%sp@- 4605e: 262e 0008 movel %fp@(8),%d3 46062: 2f02 movel %d2,%sp@- 46064: 242e 000c movel %fp@(12),%d2
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
46068: 4a83 tstl %d3
4606a: 6718 beqs 46084 <sched_rr_get_interval+0x2c> <== NEVER TAKEN
4606c: 4eb9 0004 3100 jsr 43100 <getpid> 46072: b083 cmpl %d3,%d0
46074: 670e beqs 46084 <sched_rr_get_interval+0x2c>
rtems_set_errno_and_return_minus_one( ESRCH );
46076: 4eb9 0004 d690 jsr 4d690 <__errno> 4607c: 7203 moveq #3,%d1 4607e: 2040 moveal %d0,%a0 46080: 2081 movel %d1,%a0@ 46082: 6010 bras 46094 <sched_rr_get_interval+0x3c>
if ( !interval )
46084: 4a82 tstl %d2
46086: 6610 bnes 46098 <sched_rr_get_interval+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
46088: 4eb9 0004 d690 jsr 4d690 <__errno> 4608e: 2040 moveal %d0,%a0 46090: 7016 moveq #22,%d0 46092: 2080 movel %d0,%a0@ 46094: 70ff moveq #-1,%d0 46096: 6012 bras 460aa <sched_rr_get_interval+0x52>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
46098: 2f02 movel %d2,%sp@- 4609a: 2f39 0005 f9a0 movel 5f9a0 <_Thread_Ticks_per_timeslice>,%sp@- 460a0: 4eb9 0004 934c jsr 4934c <_Timespec_From_ticks>
return 0;
460a6: 508f addql #8,%sp 460a8: 4280 clrl %d0
}
460aa: 242e fff8 movel %fp@(-8),%d2 460ae: 262e fffc movel %fp@(-4),%d3 460b2: 4e5e unlk %fp
...
00048694 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
48694: 4e56 ffe0 linkw %fp,#-32
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
48698: 2039 0006 3934 movel 63934 <_Thread_Dispatch_disable_level>,%d0 4869e: 5280 addql #1,%d0 486a0: 48d7 043c moveml %d2-%d5/%a2,%sp@ 486a4: 242e 0008 movel %fp@(8),%d2 486a8: 282e 000c movel %fp@(12),%d4 486ac: 23c0 0006 3934 movel %d0,63934 <_Thread_Dispatch_disable_level>
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
486b2: 2a04 movel %d4,%d5 486b4: 0285 0000 0200 andil #512,%d5
486ba: 6706 beqs 486c2 <sem_open+0x2e>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
486bc: 262e 0014 movel %fp@(20),%d3 486c0: 6002 bras 486c4 <sem_open+0x30>
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
486c2: 4283 clrl %d3
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 );
486c4: 486e fffc pea %fp@(-4) 486c8: 2f02 movel %d2,%sp@- 486ca: 4eb9 0004 e204 jsr 4e204 <_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 ) {
486d0: 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 );
486d2: 2440 moveal %d0,%a2
* 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 ) {
486d4: 4a80 tstl %d0
486d6: 671c beqs 486f4 <sem_open+0x60>
/*
* 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) ) ) {
486d8: 7002 moveq #2,%d0 486da: b08a cmpl %a2,%d0
486dc: 6604 bnes 486e2 <sem_open+0x4e> <== NEVER TAKEN
486de: 4a85 tstl %d5
486e0: 665e bnes 48740 <sem_open+0xac>
_Thread_Enable_dispatch();
486e2: 4eb9 0004 b10a jsr 4b10a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
486e8: 4eb9 0005 093c jsr 5093c <__errno> 486ee: 2040 moveal %d0,%a0 486f0: 208a movel %a2,%a0@ 486f2: 6076 bras 4876a <sem_open+0xd6> 486f4: 45f9 0004 b10a lea 4b10a <_Thread_Enable_dispatch>,%a2
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
486fa: 0284 0000 0a00 andil #2560,%d4 48700: 0c84 0000 0a00 cmpil #2560,%d4
48706: 6610 bnes 48718 <sem_open+0x84>
_Thread_Enable_dispatch();
48708: 4e92 jsr %a2@
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
4870a: 4eb9 0005 093c jsr 5093c <__errno> 48710: 2040 moveal %d0,%a0 48712: 7011 moveq #17,%d0 48714: 2080 movel %d0,%a0@ 48716: 6052 bras 4876a <sem_open+0xd6> 48718: 486e fff4 pea %fp@(-12) 4871c: 2f2e fffc movel %fp@(-4),%sp@- 48720: 4879 0006 3b4a pea 63b4a <_POSIX_Semaphore_Information> 48726: 4eb9 0004 a554 jsr 4a554 <_Objects_Get>
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
4872c: 2040 moveal %d0,%a0 4872e: 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 );
48732: 2d40 fff8 movel %d0,%fp@(-8)
the_semaphore->open_count += 1;
_Thread_Enable_dispatch();
48736: 4e92 jsr %a2@
_Thread_Enable_dispatch();
48738: 4e92 jsr %a2@
goto return_id;
4873a: 4fef 000c lea %sp@(12),%sp 4873e: 6022 bras 48762 <sem_open+0xce>
/*
* 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(
48740: 486e fff8 pea %fp@(-8) 48744: 2f03 movel %d3,%sp@- 48746: 42a7 clrl %sp@- 48748: 2f02 movel %d2,%sp@- 4874a: 4eb9 0004 e0c0 jsr 4e0c0 <_POSIX_Semaphore_Create_support> 48750: 2400 movel %d0,%d2
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
48752: 4eb9 0004 b10a jsr 4b10a <_Thread_Enable_dispatch>
if ( status == -1 )
48758: 4fef 0010 lea %sp@(16),%sp 4875c: 70ff moveq #-1,%d0 4875e: b082 cmpl %d2,%d0
48760: 6708 beqs 4876a <sem_open+0xd6>
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
48762: 202e fff8 movel %fp@(-8),%d0 48766: 5080 addql #8,%d0
#endif return id;
48768: 6002 bras 4876c <sem_open+0xd8>
*/
_Thread_Enable_dispatch();
if ( status == -1 )
return SEM_FAILED;
4876a: 70ff moveq #-1,%d0
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
4876c: 4cee 043c ffe0 moveml %fp@(-32),%d2-%d5/%a2 48772: 4e5e unlk %fp
...
00045ee4 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
45ee4: 4e56 ffec linkw %fp,#-20 45ee8: 222e 0010 movel %fp@(16),%d1 45eec: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 45ef0: 242e 0008 movel %fp@(8),%d2 45ef4: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
if ( oact )
45ef8: 4a81 tstl %d1
45efa: 6722 beqs 45f1e <sigaction+0x3a>
*oact = _POSIX_signals_Vectors[ sig ];
45efc: 2602 movel %d2,%d3 45efe: 2002 movel %d2,%d0 45f00: 4878 000c pea c <OPER1> 45f04: e58b lsll #2,%d3 45f06: e988 lsll #4,%d0 45f08: 9083 subl %d3,%d0 45f0a: 0680 0006 0b04 addil #396036,%d0 45f10: 2f00 movel %d0,%sp@- 45f12: 2f01 movel %d1,%sp@- 45f14: 4eb9 0004 e210 jsr 4e210 <memcpy> 45f1a: 4fef 000c lea %sp@(12),%sp
if ( !sig )
45f1e: 4a82 tstl %d2
45f20: 6710 beqs 45f32 <sigaction+0x4e>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
45f22: 2002 movel %d2,%d0 45f24: 5380 subql #1,%d0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
45f26: 721f moveq #31,%d1 45f28: b280 cmpl %d0,%d1
45f2a: 6506 bcss 45f32 <sigaction+0x4e>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
45f2c: 7009 moveq #9,%d0 45f2e: b082 cmpl %d2,%d0
45f30: 6610 bnes 45f42 <sigaction+0x5e>
rtems_set_errno_and_return_minus_one( EINVAL );
45f32: 4eb9 0004 d94c jsr 4d94c <__errno> 45f38: 2040 moveal %d0,%a0 45f3a: 7016 moveq #22,%d0 45f3c: 2080 movel %d0,%a0@ 45f3e: 70ff moveq #-1,%d0 45f40: 6060 bras 45fa2 <sigaction+0xbe>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
45f42: 4a8a tstl %a2
45f44: 675a beqs 45fa0 <sigaction+0xbc> <== 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 );
45f46: 203c 0000 0700 movel #1792,%d0 45f4c: 40c3 movew %sr,%d3 45f4e: 8083 orl %d3,%d0 45f50: 46c0 movew %d0,%sr 45f52: 780c moveq #12,%d4 45f54: 4c02 4800 mulsl %d2,%d4 45f58: 47f9 0004 e210 lea 4e210 <memcpy>,%a3
if ( act->sa_handler == SIG_DFL ) {
45f5e: 4aaa 0008 tstl %a2@(8)
45f62: 661e bnes 45f82 <sigaction+0x9e>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
45f64: 4878 000c pea c <OPER1> 45f68: 2004 movel %d4,%d0 45f6a: 0680 0005 e066 addil #385126,%d0 45f70: 2f00 movel %d0,%sp@- 45f72: 0684 0006 0b04 addil #396036,%d4 45f78: 2f04 movel %d4,%sp@- 45f7a: 4e93 jsr %a3@ 45f7c: 4fef 000c lea %sp@(12),%sp 45f80: 601c bras 45f9e <sigaction+0xba>
} else {
_POSIX_signals_Clear_process_signals( sig );
45f82: 2f02 movel %d2,%sp@-
_POSIX_signals_Vectors[ sig ] = *act;
45f84: 0684 0006 0b04 addil #396036,%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 );
45f8a: 4eb9 0004 b0c8 jsr 4b0c8 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
45f90: 4878 000c pea c <OPER1> 45f94: 2f0a movel %a2,%sp@- 45f96: 2f04 movel %d4,%sp@- 45f98: 4e93 jsr %a3@ 45f9a: 4fef 0010 lea %sp@(16),%sp
}
_ISR_Enable( level );
45f9e: 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;
45fa0: 4280 clrl %d0
}
45fa2: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
45fa8: 4e5e unlk %fp <== NOT EXECUTED
000462d0 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
462d0: 4e56 ffd8 linkw %fp,#-40 462d4: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@ 462d8: 266e 0008 moveal %fp@(8),%a3 462dc: 246e 000c moveal %fp@(12),%a2 462e0: 242e 0010 movel %fp@(16),%d2
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
462e4: 4a8b tstl %a3
462e6: 6730 beqs 46318 <sigtimedwait+0x48>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
462e8: 4a82 tstl %d2
462ea: 673c beqs 46328 <sigtimedwait+0x58>
if ( !_Timespec_Is_valid( timeout ) )
462ec: 2f02 movel %d2,%sp@- 462ee: 4eb9 0004 962c jsr 4962c <_Timespec_Is_valid> 462f4: 588f addql #4,%sp 462f6: 4a00 tstb %d0
462f8: 6610 bnes 4630a <sigtimedwait+0x3a>
rtems_set_errno_and_return_minus_one( EINVAL );
462fa: 4eb9 0004 dec8 jsr 4dec8 <__errno> 46300: 7616 moveq #22,%d3 46302: 2240 moveal %d0,%a1 46304: 2283 movel %d3,%a1@ 46306: 6000 0144 braw 4644c <sigtimedwait+0x17c>
interval = _Timespec_To_ticks( timeout );
4630a: 2f02 movel %d2,%sp@- 4630c: 4eb9 0004 9698 jsr 49698 <_Timespec_To_ticks>
if ( !interval )
46312: 588f addql #4,%sp 46314: 4a80 tstl %d0
46316: 6612 bnes 4632a <sigtimedwait+0x5a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
46318: 4eb9 0004 dec8 jsr 4dec8 <__errno> 4631e: 7416 moveq #22,%d2 46320: 2040 moveal %d0,%a0 46322: 2082 movel %d2,%a0@ 46324: 6000 0126 braw 4644c <sigtimedwait+0x17c>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
46328: 4280 clrl %d0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
4632a: 4a8a tstl %a2
4632c: 6604 bnes 46332 <sigtimedwait+0x62>
4632e: 45ee fff4 lea %fp@(-12),%a2
the_thread = _Thread_Executing;
46332: 2079 0006 0ea2 moveal 60ea2 <_Per_CPU_Information+0xc>,%a0
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
46338: 223c 0000 0700 movel #1792,%d1
the_info = ( info ) ? info : &signal_information;
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4633e: 2868 0102 moveal %a0@(258),%a4
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
46342: 40c3 movew %sr,%d3 46344: 8283 orl %d3,%d1 46346: 46c1 movew %d1,%sr
if ( *set & api->signals_pending ) {
46348: 2413 movel %a3@,%d2 4634a: 2802 movel %d2,%d4 4634c: 222c 00d4 movel %a4@(212),%d1 46350: c881 andl %d1,%d4
46352: 672a beqs 4637e <sigtimedwait+0xae>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
46354: 2f01 movel %d1,%sp@- 46356: 4eb9 0004 6284 jsr 46284 <_POSIX_signals_Get_lowest> 4635c: 2480 movel %d0,%a2@
_POSIX_signals_Clear_signals(
4635e: 4297 clrl %sp@ 46360: 42a7 clrl %sp@- 46362: 2f0a movel %a2,%sp@- 46364: 2f00 movel %d0,%sp@- 46366: 2f0c movel %a4,%sp@- 46368: 4eb9 0004 b70c jsr 4b70c <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
4636e: 46c3 movew %d3,%sr
the_info->si_code = SI_USER;
46370: 7001 moveq #1,%d0
the_info->si_value.sival_int = 0;
46372: 42aa 0008 clrl %a2@(8)
return the_info->si_signo;
46376: 2412 movel %a2@,%d2
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
46378: 2540 0004 movel %d0,%a2@(4) 4637c: 6036 bras 463b4 <sigtimedwait+0xe4>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
4637e: 2239 0006 10c8 movel 610c8 <_POSIX_signals_Pending>,%d1 46384: 4bf9 0004 b70c lea 4b70c <_POSIX_signals_Clear_signals>,%a5 4638a: c481 andl %d1,%d2
4638c: 672e beqs 463bc <sigtimedwait+0xec>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
4638e: 2f01 movel %d1,%sp@- 46390: 4eb9 0004 6284 jsr 46284 <_POSIX_signals_Get_lowest> 46396: 2400 movel %d0,%d2
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
46398: 4297 clrl %sp@ 4639a: 4878 0001 pea 1 <ADD> 4639e: 2f0a movel %a2,%sp@- 463a0: 2f00 movel %d0,%sp@- 463a2: 2f0c movel %a4,%sp@- 463a4: 4e95 jsr %a5@
_ISR_Enable( level );
463a6: 46c3 movew %d3,%sr
the_info->si_signo = signo;
the_info->si_code = SI_USER;
463a8: 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;
463aa: 2482 movel %d2,%a2@
the_info->si_code = SI_USER;
463ac: 2541 0004 movel %d1,%a2@(4)
the_info->si_value.sival_int = 0;
463b0: 42aa 0008 clrl %a2@(8)
return signo;
463b4: 4fef 0014 lea %sp@(20),%sp 463b8: 6000 0094 braw 4644e <sigtimedwait+0x17e>
}
the_info->si_signo = -1;
463bc: 72ff moveq #-1,%d1 463be: 2481 movel %d1,%a2@ 463c0: 2239 0006 0a38 movel 60a38 <_Thread_Dispatch_disable_level>,%d1 463c6: 5281 addql #1,%d1 463c8: 23c1 0006 0a38 movel %d1,60a38 <_Thread_Dispatch_disable_level>
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
463ce: 7204 moveq #4,%d1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
463d0: 43f9 0006 1060 lea 61060 <_POSIX_signals_Wait_queue>,%a1
the_thread->Wait.return_code = EINTR;
463d6: 2141 0034 movel %d1,%a0@(52)
the_thread->Wait.option = *set;
463da: 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;
463de: 123c 0001 moveb #1,%d1
the_thread->Wait.return_argument = the_info;
463e2: 214a 0028 movel %a2,%a0@(40)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
463e6: 2149 0044 movel %a1,%a0@(68) 463ea: 23c1 0006 1090 movel %d1,61090 <_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 );
463f0: 46c3 movew %d3,%sr
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
463f2: 4879 0004 938c pea 4938c <_Thread_queue_Timeout> 463f8: 2f00 movel %d0,%sp@- 463fa: 4879 0006 1060 pea 61060 <_POSIX_signals_Wait_queue> 46400: 4eb9 0004 9078 jsr 49078 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
46406: 4eb9 0004 8c4a jsr 48c4a <_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 );
4640c: 42a7 clrl %sp@- 4640e: 42a7 clrl %sp@- 46410: 2f0a movel %a2,%sp@- 46412: 2f12 movel %a2@,%sp@- 46414: 2f0c movel %a4,%sp@- 46416: 4e95 jsr %a5@
/* 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)
46418: 2079 0006 0ea2 moveal 60ea2 <_Per_CPU_Information+0xc>,%a0 4641e: 4fef 0020 lea %sp@(32),%sp 46422: 7004 moveq #4,%d0 46424: b0a8 0034 cmpl %a0@(52),%d0
46428: 6610 bnes 4643a <sigtimedwait+0x16a>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
4642a: 2412 movel %a2@,%d2 4642c: 2202 movel %d2,%d1 4642e: 5381 subql #1,%d1 46430: 103c 0001 moveb #1,%d0 46434: e3a8 lsll %d1,%d0 46436: c093 andl %a3@,%d0
46438: 6614 bnes 4644e <sigtimedwait+0x17e>
errno = _Thread_Executing->Wait.return_code;
4643a: 4eb9 0004 dec8 jsr 4dec8 <__errno> 46440: 2079 0006 0ea2 moveal 60ea2 <_Per_CPU_Information+0xc>,%a0 46446: 2240 moveal %d0,%a1 46448: 22a8 0034 movel %a0@(52),%a1@
return -1;
4644c: 74ff moveq #-1,%d2
}
return the_info->si_signo;
}
4644e: 2002 movel %d2,%d0 46450: 4cee 3c1c ffd8 moveml %fp@(-40),%d2-%d4/%a2-%a5 46456: 4e5e unlk %fp
...
00047ff4 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
47ff4: 4e56 0000 linkw %fp,#0 47ff8: 2f0a movel %a2,%sp@- 47ffa: 246e 000c moveal %fp@(12),%a2
int status;
status = sigtimedwait( set, NULL, NULL );
47ffe: 42a7 clrl %sp@- 48000: 42a7 clrl %sp@- 48002: 2f2e 0008 movel %fp@(8),%sp@- 48006: 4eb9 0004 7e50 jsr 47e50 <sigtimedwait>
if ( status != -1 ) {
4800c: 4fef 000c lea %sp@(12),%sp 48010: 72ff moveq #-1,%d1 48012: b280 cmpl %d0,%d1
48014: 6708 beqs 4801e <sigwait+0x2a>
if ( sig )
48016: 4a8a tstl %a2
48018: 6710 beqs 4802a <sigwait+0x36> <== NEVER TAKEN
*sig = status;
4801a: 2480 movel %d0,%a2@ 4801c: 600c bras 4802a <sigwait+0x36>
return 0;
}
return errno;
4801e: 4eb9 0004 f698 jsr 4f698 <__errno> 48024: 2040 moveal %d0,%a0 48026: 2010 movel %a0@,%d0 48028: 6002 bras 4802c <sigwait+0x38>
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
4802a: 4280 clrl %d0
}
return errno;
}
4802c: 246e fffc moveal %fp@(-4),%a2
48030: 4e5e unlk %fp <== NOT EXECUTED
00044676 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
44676: 4e56 0000 linkw %fp,#0 4467a: 2f0a movel %a2,%sp@- 4467c: 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)) {
44680: 202a 003c movel %a2@(60),%d0
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
44684: 2f02 movel %d2,%sp@- 44686: 4282 clrl %d2 44688: 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)) {
4468c: 0280 0000 0e78 andil #3704,%d0
44692: 6734 beqs 446c8 <siproc+0x52> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44694: 42a7 clrl %sp@- 44696: 42a7 clrl %sp@- 44698: 2f2a 0018 movel %a2@(24),%sp@- 4469c: 4eb9 0004 5854 jsr 45854 <rtems_semaphore_obtain>
i = iproc (c, tty);
446a2: 2f0a movel %a2,%sp@- 446a4: 2f02 movel %d2,%sp@- 446a6: 4eba fe66 jsr %pc@(4450e <iproc>)
rtems_semaphore_release (tty->osem);
446aa: 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);
446ae: 2400 movel %d0,%d2
rtems_semaphore_release (tty->osem);
446b0: 4eb9 0004 595c jsr 4595c <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
446b6: 246e fffc moveal %fp@(-4),%a2 446ba: 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);
446bc: 4fef 0018 lea %sp@(24),%sp
}
else {
i = iproc (c, tty);
}
return i;
}
446c0: 242e fff8 movel %fp@(-8),%d2 446c4: 4e5e unlk %fp 446c6: 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);
446c8: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED
} return i; }
446cc: 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);
446d0: 2d42 0008 movel %d2,%fp@(8) <== NOT EXECUTED
} return i; }
446d4: 242e fff8 movel %fp@(-8),%d2 <== NOT EXECUTED 446d8: 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);
446da: 6000 fe32 braw 4450e <iproc> <== NOT EXECUTED
0004596c <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
4596c: 4e56 ffdc linkw %fp,#-36 45970: 48d7 040c moveml %d2-%d3/%a2,%sp@ 45974: 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 ) )
45978: 240e movel %fp,%d2 4597a: 0682 ffff ffec addil #-20,%d2 45980: 2f0a movel %a2,%sp@-
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
45982: 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 ) )
45986: 4eb9 0005 0e94 jsr 50e94 <strlen> 4598c: 7201 moveq #1,%d1 4598e: 2e81 movel %d1,%sp@ 45990: 2f02 movel %d2,%sp@- 45992: 42a7 clrl %sp@- 45994: 2f00 movel %d0,%sp@- 45996: 2f0a movel %a2,%sp@- 45998: 4eb9 0004 46bc jsr 446bc <rtems_filesystem_evaluate_path> 4599e: 4fef 0014 lea %sp@(20),%sp 459a2: 4a80 tstl %d0
459a4: 6638 bnes 459de <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));
459a6: 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;
459aa: 246e fffc moveal %fp@(-4),%a2
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
459ae: 42a7 clrl %sp@- 459b0: 2f03 movel %d3,%sp@- 459b2: 4eb9 0004 fcc4 jsr 4fcc4 <memset>
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
459b8: 206a 0028 moveal %a2@(40),%a0 459bc: 2f03 movel %d3,%sp@- 459be: 486a 001c pea %a2@(28) 459c2: 2068 0044 moveal %a0@(68),%a0 459c6: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
459c8: 2f02 movel %d2,%sp@- 459ca: 2d40 ffe8 movel %d0,%fp@(-24) 459ce: 4eb9 0004 4788 jsr 44788 <rtems_filesystem_freenode>
return result;
459d4: 202e ffe8 movel %fp@(-24),%d0 459d8: 4fef 0018 lea %sp@(24),%sp 459dc: 6002 bras 459e0 <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;
459de: 70ff moveq #-1,%d0 <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
rtems_filesystem_freenode( &loc );
return result;
}
459e0: 4cee 040c ffdc moveml %fp@(-36),%d2-%d3/%a2 459e6: 4e5e unlk %fp
...
0004488c <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
4488c: 4e56 0000 linkw %fp,#0 44890: 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;
44894: 2028 00fa movel %a0@(250),%d0
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
44898: 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 ) {
4489a: 4a80 tstl %d0
4489c: 6728 beqs 448c6 <sync_per_thread+0x3a> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
4489e: 2279 0006 0892 moveal 60892 <_Per_CPU_Information+0xc>,%a1 448a4: 2429 00fa movel %a1@(250),%d2
_Thread_Executing->libc_reent = this_reent;
448a8: 2340 00fa movel %d0,%a1@(250)
_fwalk (t->libc_reent, sync_wrapper);
448ac: 487a 0020 pea %pc@(448ce <sync_wrapper>) 448b0: 2f28 00fa movel %a0@(250),%sp@- 448b4: 4eb9 0004 e954 jsr 4e954 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
448ba: 2079 0006 0892 moveal 60892 <_Per_CPU_Information+0xc>,%a0 448c0: 508f addql #8,%sp 448c2: 2142 00fa movel %d2,%a0@(250)
} }
448c6: 242e fffc movel %fp@(-4),%d2
448ca: 4e5e unlk %fp <== NOT EXECUTED
0004aca8 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
4aca8: 4e56 0000 linkw %fp,#0 4acac: 202e 000c movel %fp@(12),%d0 4acb0: 2f03 movel %d3,%sp@- 4acb2: 262e 0010 movel %fp@(16),%d3 4acb6: 2f02 movel %d2,%sp@- 4acb8: 242e 0008 movel %fp@(8),%d2
switch (opt) {
4acbc: 4a80 tstl %d0
4acbe: 672c beqs 4acec <tcsetattr+0x44>
4acc0: 7201 moveq #1,%d1 4acc2: b280 cmpl %d0,%d1
4acc4: 6710 beqs 4acd6 <tcsetattr+0x2e>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
4acc6: 4eb9 0004 e3a0 jsr 4e3a0 <__errno> 4accc: 2040 moveal %d0,%a0 4acce: 20bc 0000 0086 movel #134,%a0@ 4acd4: 6034 bras 4ad0a <tcsetattr+0x62>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
4acd6: 42a7 clrl %sp@- 4acd8: 4878 0003 pea 3 <DIVIDE> 4acdc: 2f02 movel %d2,%sp@- 4acde: 4eb9 0004 a9ac jsr 4a9ac <ioctl> 4ace4: 4fef 000c lea %sp@(12),%sp 4ace8: 4a80 tstl %d0
4acea: 6d1e blts 4ad0a <tcsetattr+0x62> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4acec: 2d43 0010 movel %d3,%fp@(16) 4acf0: 7002 moveq #2,%d0 4acf2: 2d42 0008 movel %d2,%fp@(8)
} }
4acf6: 242e fff8 movel %fp@(-8),%d2 4acfa: 262e fffc movel %fp@(-4),%d3
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4acfe: 2d40 000c movel %d0,%fp@(12)
} }
4ad02: 4e5e unlk %fp
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4ad04: 4ef9 0004 a9ac jmp 4a9ac <ioctl>
} }
4ad0a: 242e fff8 movel %fp@(-8),%d2 4ad0e: 70ff moveq #-1,%d0 4ad10: 262e fffc movel %fp@(-4),%d3
4ad14: 4e5e unlk %fp <== NOT EXECUTED
000454f4 <timer_create>:
timer_t *timerid
)
{
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
454f4: 7001 moveq #1,%d0
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
454f6: 4e56 0000 linkw %fp,#0 454fa: 2f0b movel %a3,%sp@- 454fc: 266e 0010 moveal %fp@(16),%a3 45500: 2f0a movel %a2,%sp@- 45502: 246e 000c moveal %fp@(12),%a2
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
45506: b0ae 0008 cmpl %fp@(8),%d0
4550a: 6620 bnes 4552c <timer_create+0x38>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
4550c: 4a8b tstl %a3
4550e: 671c beqs 4552c <timer_create+0x38>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
45510: 4a8a tstl %a2
45512: 6726 beqs 4553a <timer_create+0x46>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
45514: 2012 movel %a2@,%d0 45516: 7201 moveq #1,%d1 45518: 5380 subql #1,%d0 4551a: b280 cmpl %d0,%d1
4551c: 650e bcss 4552c <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 )
4551e: 202a 0004 movel %a2@(4),%d0
45522: 6708 beqs 4552c <timer_create+0x38> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
45524: 5380 subql #1,%d0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
45526: 721f moveq #31,%d1 45528: b280 cmpl %d0,%d1
4552a: 640e bccs 4553a <timer_create+0x46> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
4552c: 4eb9 0004 d3b4 jsr 4d3b4 <__errno> 45532: 7216 moveq #22,%d1 45534: 2040 moveal %d0,%a0 45536: 2081 movel %d1,%a0@ 45538: 6034 bras 4556e <timer_create+0x7a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
4553a: 2039 0005 f548 movel 5f548 <_Thread_Dispatch_disable_level>,%d0 45540: 5280 addql #1,%d0 45542: 23c0 0005 f548 movel %d0,5f548 <_Thread_Dispatch_disable_level>
* 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 );
45548: 4879 0005 f798 pea 5f798 <_POSIX_Timer_Information> 4554e: 4eb9 0004 71b0 jsr 471b0 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
45554: 588f addql #4,%sp 45556: 2040 moveal %d0,%a0 45558: 4a80 tstl %d0
4555a: 6616 bnes 45572 <timer_create+0x7e>
_Thread_Enable_dispatch();
4555c: 4eb9 0004 813a jsr 4813a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
45562: 4eb9 0004 d3b4 jsr 4d3b4 <__errno> 45568: 2040 moveal %d0,%a0 4556a: 700b moveq #11,%d0 4556c: 2080 movel %d0,%a0@ 4556e: 70ff moveq #-1,%d0 45570: 606a bras 455dc <timer_create+0xe8>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
45572: 7002 moveq #2,%d0 45574: 1140 003c moveb %d0,%a0@(60)
ptimer->thread_id = _Thread_Executing->Object.id;
45578: 2279 0005 f9b2 moveal 5f9b2 <_Per_CPU_Information+0xc>,%a1 4557e: 2169 0008 0038 movel %a1@(8),%a0@(56)
if ( evp != NULL ) {
45584: 4a8a tstl %a2
45586: 6710 beqs 45598 <timer_create+0xa4>
ptimer->inf.sigev_notify = evp->sigev_notify;
45588: 2152 003e movel %a2@,%a0@(62)
ptimer->inf.sigev_signo = evp->sigev_signo;
4558c: 216a 0004 0042 movel %a2@(4),%a0@(66)
ptimer->inf.sigev_value = evp->sigev_value;
45592: 216a 0008 0046 movel %a2@(8),%a0@(70)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45598: 2028 0008 movel %a0@(8),%d0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
4559c: 4281 clrl %d1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4559e: 2279 0005 f7b0 moveal 5f7b0 <_POSIX_Timer_Information+0x18>,%a1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
455a4: 3200 movew %d0,%d1
}
ptimer->overrun = 0;
455a6: 42a8 0066 clrl %a0@(102)
ptimer->timer_data.it_value.tv_sec = 0;
455aa: 42a8 005a clrl %a0@(90)
ptimer->timer_data.it_value.tv_nsec = 0;
455ae: 42a8 005e clrl %a0@(94)
ptimer->timer_data.it_interval.tv_sec = 0;
455b2: 42a8 0052 clrl %a0@(82)
ptimer->timer_data.it_interval.tv_nsec = 0;
455b6: 42a8 0056 clrl %a0@(86)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
455ba: 42a8 0018 clrl %a0@(24)
the_watchdog->routine = routine;
455be: 42a8 002c clrl %a0@(44)
the_watchdog->id = id;
455c2: 42a8 0030 clrl %a0@(48)
the_watchdog->user_data = user_data;
455c6: 42a8 0034 clrl %a0@(52)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
455ca: 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;
455ce: 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;
455d2: 2680 movel %d0,%a3@
_Thread_Enable_dispatch();
455d4: 4eb9 0004 813a jsr 4813a <_Thread_Enable_dispatch>
return 0;
455da: 4280 clrl %d0
}
455dc: 246e fff8 moveal %fp@(-8),%a2 455e0: 266e fffc moveal %fp@(-4),%a3
455e4: 4e5e unlk %fp <== NOT EXECUTED
000456ba <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
456ba: 4e56 ffe8 linkw %fp,#-24 456be: 48d7 041c moveml %d2-%d4/%a2,%sp@ 456c2: 262e 0008 movel %fp@(8),%d3
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
456c6: 4ab9 0006 09d8 tstl 609d8 <_POSIX_signals_Ualarm_timer+0x1c>
456cc: 6620 bnes 456ee <ualarm+0x34>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
456ce: 42b9 0006 09c4 clrl 609c4 <_POSIX_signals_Ualarm_timer+0x8>
the_watchdog->routine = routine;
456d4: 203c 0004 5678 movel #284280,%d0
the_watchdog->id = id;
456da: 42b9 0006 09dc clrl 609dc <_POSIX_signals_Ualarm_timer+0x20>
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
456e0: 23c0 0006 09d8 movel %d0,609d8 <_POSIX_signals_Ualarm_timer+0x1c>
the_watchdog->id = id; the_watchdog->user_data = user_data;
456e6: 42b9 0006 09e0 clrl 609e0 <_POSIX_signals_Ualarm_timer+0x24> 456ec: 6056 bras 45744 <ualarm+0x8a>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
456ee: 4879 0006 09bc pea 609bc <_POSIX_signals_Ualarm_timer> 456f4: 4eb9 0004 8e34 jsr 48e34 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
456fa: 588f addql #4,%sp 456fc: 7201 moveq #1,%d1 456fe: 5580 subql #2,%d0 45700: b280 cmpl %d0,%d1
45702: 6540 bcss 45744 <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);
45704: 2039 0006 09d0 movel 609d0 <_POSIX_signals_Ualarm_timer+0x14>,%d0 4570a: d0b9 0006 09c8 addl 609c8 <_POSIX_signals_Ualarm_timer+0xc>,%d0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
45710: 486e fff8 pea %fp@(-8) 45714: 90b9 0006 09d4 subl 609d4 <_POSIX_signals_Ualarm_timer+0x18>,%d0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
4571a: 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 );
45720: 2f00 movel %d0,%sp@- 45722: 4eb9 0004 894c jsr 4894c <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
45728: 202e fff8 movel %fp@(-8),%d0 4572c: 4c04 0800 mulsl %d4,%d0
remaining += tp.tv_nsec / 1000;
45730: 283c 0000 03e8 movel #1000,%d4 45736: 508f addql #8,%sp 45738: 242e fffc movel %fp@(-4),%d2 4573c: 4c44 2802 remsl %d4,%d2,%d2 45740: d480 addl %d0,%d2 45742: 6002 bras 45746 <ualarm+0x8c>
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
45744: 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 ) {
45746: 4a83 tstl %d3
45748: 674e beqs 45798 <ualarm+0xde>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
4574a: 283c 0000 03e8 movel #1000,%d4
ticks = _Timespec_To_ticks( &tp );
45750: 45f9 0004 89cc lea 489cc <_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;
45756: 223c 000f 4240 movel #1000000,%d1 4575c: 4c41 3000 remul %d1,%d0,%d3 45760: 4c41 3003 remul %d1,%d3,%d3 45764: 2d43 fff8 movel %d3,%fp@(-8)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
45768: 4c00 4800 mulsl %d0,%d4
ticks = _Timespec_To_ticks( &tp );
4576c: 260e movel %fp,%d3 4576e: 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;
45770: 2d44 fffc movel %d4,%fp@(-4)
ticks = _Timespec_To_ticks( &tp );
45774: 2f03 movel %d3,%sp@- 45776: 4e92 jsr %a2@
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
45778: 2f03 movel %d3,%sp@- 4577a: 4e92 jsr %a2@
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4577c: 4879 0006 09bc pea 609bc <_POSIX_signals_Ualarm_timer> 45782: 4879 0006 0268 pea 60268 <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
45788: 23c0 0006 09c8 movel %d0,609c8 <_POSIX_signals_Ualarm_timer+0xc>
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4578e: 4eb9 0004 8d0c jsr 48d0c <_Watchdog_Insert> 45794: 4fef 0010 lea %sp@(16),%sp
}
return remaining;
}
45798: 2002 movel %d2,%d0 4579a: 4cee 041c ffe8 moveml %fp@(-24),%d2-%d4/%a2
457a0: 4e5e unlk %fp <== NOT EXECUTED
00045d54 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
45d54: 4e56 ffbc linkw %fp,#-68 45d58: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 45d5c: 246e 0008 moveal %fp@(8),%a2
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
45d60: 2f0a movel %a2,%sp@- 45d62: 4eb9 0004 3608 jsr 43608 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
45d68: 588f addql #4,%sp
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
45d6a: 2a00 movel %d0,%d5 45d6c: 200e movel %fp,%d0 45d6e: 0680 ffff ffe8 addil #-24,%d0
if ( parentpathlen == 0 )
45d74: 4a85 tstl %d5
45d76: 6616 bnes 45d8e <unlink+0x3a>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
45d78: 2f00 movel %d0,%sp@- 45d7a: 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;
45d7e: 4204 clrb %d4
*/
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
45d80: 2f0a movel %a2,%sp@- 45d82: 4eb9 0004 4454 jsr 44454 <rtems_filesystem_get_start_loc> 45d88: 4fef 000c lea %sp@(12),%sp 45d8c: 601e bras 45dac <unlink+0x58>
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
45d8e: 42a7 clrl %sp@- 45d90: 2f00 movel %d0,%sp@- 45d92: 4878 0002 pea 2 <DOUBLE_FLOAT> 45d96: 2f05 movel %d5,%sp@- 45d98: 2f0a movel %a2,%sp@- 45d9a: 4eb9 0004 35bc jsr 435bc <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
45da0: 4fef 0014 lea %sp@(20),%sp 45da4: 4a80 tstl %d0 45da6: 6600 00c2 bnew 45e6a <unlink+0x116>
return -1;
free_parentloc = true;
45daa: 7801 moveq #1,%d4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
45dac: 4878 0014 pea 14 <OPER2> 45db0: 260e movel %fp,%d3 45db2: 0683 ffff ffe8 addil #-24,%d3 45db8: 240e movel %fp,%d2 45dba: 0682 ffff ffd4 addil #-44,%d2
name = path + parentpathlen;
45dc0: d5c5 addal %d5,%a2
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
45dc2: 47f9 0005 1634 lea 51634 <strlen>,%a3
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
45dc8: 2f03 movel %d3,%sp@- 45dca: 2f02 movel %d2,%sp@- 45dcc: 4eb9 0005 0b3c jsr 50b3c <memcpy>
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
45dd2: 2f0a movel %a2,%sp@- 45dd4: 4e93 jsr %a3@ 45dd6: 2e80 movel %d0,%sp@ 45dd8: 2f0a movel %a2,%sp@- 45dda: 4eb9 0004 364a jsr 4364a <rtems_filesystem_prefix_separators> 45de0: d5c0 addal %d0,%a2
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
45de2: 2f0a movel %a2,%sp@- 45de4: 4e93 jsr %a3@ 45de6: 4297 clrl %sp@ 45de8: 2f02 movel %d2,%sp@- 45dea: 42a7 clrl %sp@- 45dec: 2f00 movel %d0,%sp@- 45dee: 2f0a movel %a2,%sp@- 45df0: 4eb9 0004 354c jsr 4354c <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
45df6: 4fef 0028 lea %sp@(40),%sp 45dfa: 4a80 tstl %d0
45dfc: 6710 beqs 45e0e <unlink+0xba>
if ( free_parentloc )
45dfe: 4a04 tstb %d4
45e00: 6768 beqs 45e6a <unlink+0x116> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
45e02: 2f03 movel %d3,%sp@- 45e04: 4eb9 0004 3688 jsr 43688 <rtems_filesystem_freenode> 45e0a: 588f addql #4,%sp 45e0c: 605c bras 45e6a <unlink+0x116>
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
45e0e: 206e ffe0 moveal %fp@(-32),%a0 45e12: 45f9 0004 3688 lea 43688 <rtems_filesystem_freenode>,%a2 45e18: 2f02 movel %d2,%sp@- 45e1a: 2068 0010 moveal %a0@(16),%a0 45e1e: 4e90 jsr %a0@ 45e20: 588f addql #4,%sp 45e22: 7201 moveq #1,%d1 45e24: b280 cmpl %d0,%d1
45e26: 661e bnes 45e46 <unlink+0xf2>
rtems_filesystem_freenode( &loc );
45e28: 2f02 movel %d2,%sp@- 45e2a: 4e92 jsr %a2@
if ( free_parentloc )
45e2c: 588f addql #4,%sp 45e2e: 4a04 tstb %d4
45e30: 6706 beqs 45e38 <unlink+0xe4>
rtems_filesystem_freenode( &parentloc );
45e32: 2f03 movel %d3,%sp@- 45e34: 4e92 jsr %a2@ 45e36: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( EISDIR );
45e38: 4eb9 0005 0290 jsr 50290 <__errno> 45e3e: 2040 moveal %d0,%a0 45e40: 7015 moveq #21,%d0 45e42: 2080 movel %d0,%a0@ 45e44: 6024 bras 45e6a <unlink+0x116>
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
45e46: 2f02 movel %d2,%sp@- 45e48: 206e ffe0 moveal %fp@(-32),%a0 45e4c: 2f03 movel %d3,%sp@- 45e4e: 2068 000c moveal %a0@(12),%a0 45e52: 4e90 jsr %a0@ 45e54: 2a00 movel %d0,%d5
rtems_filesystem_freenode( &loc );
45e56: 2f02 movel %d2,%sp@- 45e58: 4e92 jsr %a2@
if ( free_parentloc )
45e5a: 4fef 000c lea %sp@(12),%sp 45e5e: 4a04 tstb %d4
45e60: 670a beqs 45e6c <unlink+0x118>
rtems_filesystem_freenode( &parentloc );
45e62: 2f03 movel %d3,%sp@- 45e64: 4e92 jsr %a2@ 45e66: 588f addql #4,%sp 45e68: 6002 bras 45e6c <unlink+0x118>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
45e6a: 7aff moveq #-1,%d5
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
45e6c: 2005 movel %d5,%d0 45e6e: 4cee 0c3c ffbc moveml %fp@(-68),%d2-%d5/%a2-%a3
45e74: 4e5e unlk %fp <== NOT EXECUTED
000460c8 <unmount>:
*/
int unmount(
const char *path
)
{
460c8: 4e56 ffe0 linkw %fp,#-32 460cc: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 460d0: 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 ) )
460d4: 7401 moveq #1,%d2 460d6: 2f0a movel %a2,%sp@- 460d8: 4eb9 0004 eecc jsr 4eecc <strlen> 460de: 2e82 movel %d2,%sp@ 460e0: 240e movel %fp,%d2 460e2: 0682 ffff ffec addil #-20,%d2 460e8: 2f02 movel %d2,%sp@- 460ea: 42a7 clrl %sp@- 460ec: 2f00 movel %d0,%sp@- 460ee: 2f0a movel %a2,%sp@- 460f0: 4eb9 0004 35a8 jsr 435a8 <rtems_filesystem_evaluate_path> 460f6: 4fef 0014 lea %sp@(20),%sp 460fa: 4a80 tstl %d0 460fc: 6600 00e8 bnew 461e6 <unmount+0x11e>
return -1;
mt_entry = loc.mt_entry;
46100: 246e fffc moveal %fp@(-4),%a2 46104: 47f9 0004 3674 lea 43674 <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 ){
4610a: 202e ffec movel %fp@(-20),%d0 4610e: b0aa 001c cmpl %a2@(28),%d0
46112: 6716 beqs 4612a <unmount+0x62>
rtems_filesystem_freenode( &loc );
46114: 2f02 movel %d2,%sp@- 46116: 4e93 jsr %a3@
rtems_set_errno_and_return_minus_one( EACCES );
46118: 4eb9 0004 d9d8 jsr 4d9d8 <__errno> 4611e: 588f addql #4,%sp 46120: 720d moveq #13,%d1 46122: 2040 moveal %d0,%a0 46124: 2081 movel %d1,%a0@ 46126: 6000 00be braw 461e6 <unmount+0x11e>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
4612a: 2f02 movel %d2,%sp@- 4612c: 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 )
4612e: 2079 0005 f258 moveal 5f258 <rtems_current_user_env>,%a0 46134: 588f addql #4,%sp 46136: b5e8 0014 cmpal %a0@(20),%a2
4613a: 6724 beqs 46160 <unmount+0x98>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
4613c: 2f2a 002c movel %a2@(44),%sp@- 46140: 487a ff6e pea %pc@(460b0 <is_fs_below_mount_point>) 46144: 4eb9 0004 3e7e jsr 43e7e <rtems_filesystem_mount_iterate> 4614a: 508f addql #8,%sp 4614c: 4a00 tstb %d0
4614e: 6610 bnes 46160 <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 )
46150: 2f0a movel %a2,%sp@- 46152: 4eb9 0004 39c0 jsr 439c0 <rtems_libio_is_open_files_in_fs> 46158: 588f addql #4,%sp 4615a: 7201 moveq #1,%d1 4615c: b280 cmpl %d0,%d1
4615e: 660e bnes 4616e <unmount+0xa6>
rtems_set_errno_and_return_minus_one( EBUSY );
46160: 4eb9 0004 d9d8 jsr 4d9d8 <__errno> 46166: 2040 moveal %d0,%a0 46168: 7010 moveq #16,%d0 4616a: 2080 movel %d0,%a0@ 4616c: 6078 bras 461e6 <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 )
4616e: 206a 0014 moveal %a2@(20),%a0 46172: 2f0a movel %a2,%sp@- 46174: 2068 0028 moveal %a0@(40),%a0 46178: 4e90 jsr %a0@ 4617a: 588f addql #4,%sp 4617c: 4a80 tstl %d0
4617e: 6666 bnes 461e6 <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){
46180: 206a 0028 moveal %a2@(40),%a0 46184: 2f0a movel %a2,%sp@- 46186: 2068 002c moveal %a0@(44),%a0 4618a: 4e90 jsr %a0@ 4618c: 588f addql #4,%sp 4618e: 4a80 tstl %d0
46190: 671a beqs 461ac <unmount+0xe4> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
46192: 206a 0014 moveal %a2@(20),%a0 <== NOT EXECUTED 46196: 2f0a movel %a2,%sp@- <== NOT EXECUTED 46198: 2068 0020 moveal %a0@(32),%a0 <== NOT EXECUTED 4619c: 4e90 jsr %a0@ <== NOT EXECUTED 4619e: 588f addql #4,%sp <== NOT EXECUTED 461a0: 4a80 tstl %d0 <== NOT EXECUTED 461a2: 6742 beqs 461e6 <unmount+0x11e> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
461a4: 42a7 clrl %sp@- <== NOT EXECUTED 461a6: 4eb9 0004 70e0 jsr 470e0 <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 );
461ac: 42a7 clrl %sp@- 461ae: 42a7 clrl %sp@- 461b0: 2f39 0006 091c movel 6091c <rtems_libio_semaphore>,%sp@- 461b6: 4eb9 0004 6a84 jsr 46a84 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
461bc: 2f0a movel %a2,%sp@- 461be: 4eb9 0004 7424 jsr 47424 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
461c4: 2f39 0006 091c movel 6091c <rtems_libio_semaphore>,%sp@- 461ca: 4eb9 0004 6b8c jsr 46b8c <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 );
461d0: 486a 0008 pea %a2@(8) 461d4: 4e93 jsr %a3@
free( mt_entry );
461d6: 2f0a movel %a2,%sp@- 461d8: 4eb9 0004 3688 jsr 43688 <free>
return 0;
461de: 4fef 001c lea %sp@(28),%sp 461e2: 4280 clrl %d0 461e4: 6002 bras 461e8 <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;
461e6: 70ff moveq #-1,%d0
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
461e8: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3 461ee: 4e5e unlk %fp
...
0005ab9c <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
5ab9c: 4e56 fff4 linkw %fp,#-12 5aba0: 202e 0008 movel %fp@(8),%d0 5aba4: 222e 000c movel %fp@(12),%d1 5aba8: 206e 0010 moveal %fp@(16),%a0 5abac: 48d7 040c moveml %d2-%d3/%a2,%sp@
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
5abb0: b0b9 0005 cff4 cmpl 5cff4 <rtems_libio_number_iops>,%d0
5abb6: 641a bccs 5abd2 <write+0x36> iop = rtems_libio_iop( fd );
5abb8: 2400 movel %d0,%d2 5abba: ed88 lsll #6,%d0 5abbc: e78a lsll #3,%d2 5abbe: 2479 0005 e874 moveal 5e874 <rtems_libio_iops>,%a2 5abc4: 9082 subl %d2,%d0 5abc6: d5c0 addal %d0,%a2
rtems_libio_check_is_open( iop );
5abc8: 202a 0014 movel %a2@(20),%d0 5abcc: 0800 0008 btst #8,%d0
5abd0: 660e bnes 5abe0 <write+0x44>
5abd2: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5abd8: 7209 moveq #9,%d1 5abda: 2040 moveal %d0,%a0 5abdc: 2081 movel %d1,%a0@ 5abde: 6018 bras 5abf8 <write+0x5c>
rtems_libio_check_buffer( buffer );
5abe0: 4a81 tstl %d1
5abe2: 6708 beqs 5abec <write+0x50> <== NEVER TAKEN
rtems_libio_check_count( count );
5abe4: 4a88 tstl %a0
5abe6: 6742 beqs 5ac2a <write+0x8e> rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
5abe8: 44c0 movew %d0,%ccr
5abea: 6710 beqs 5abfc <write+0x60>
5abec: 4eb9 0004 cad0 jsr 4cad0 <__errno> 5abf2: 2040 moveal %d0,%a0 5abf4: 7016 moveq #22,%d0 5abf6: 2080 movel %d0,%a0@ 5abf8: 70ff moveq #-1,%d0 5abfa: 6030 bras 5ac2c <write+0x90>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
5abfc: 226a 0020 moveal %a2@(32),%a1 5ac00: 2f08 movel %a0,%sp@- 5ac02: 2f01 movel %d1,%sp@- 5ac04: 2f0a movel %a2,%sp@- 5ac06: 2069 000c moveal %a1@(12),%a0 5ac0a: 4e90 jsr %a0@
if ( rc > 0 )
5ac0c: 4fef 000c lea %sp@(12),%sp 5ac10: 4a80 tstl %d0
5ac12: 6f18 bles 5ac2c <write+0x90>
iop->offset += rc;
5ac14: 2400 movel %d0,%d2 5ac16: 5bc1 smi %d1 5ac18: 49c1 extbl %d1 5ac1a: d5aa 0010 addl %d2,%a2@(16) 5ac1e: 262a 000c movel %a2@(12),%d3 5ac22: d781 addxl %d1,%d3 5ac24: 2543 000c movel %d3,%a2@(12) 5ac28: 6002 bras 5ac2c <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 );
5ac2a: 4280 clrl %d0
if ( rc > 0 )
iop->offset += rc;
return rc;
}
5ac2c: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 5ac32: 4e5e unlk %fp
...
000461e0 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
461e0: 4e56 ffe4 linkw %fp,#-28 461e4: 202e 0008 movel %fp@(8),%d0 461e8: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@ 461ec: 246e 000c moveal %fp@(12),%a2 461f0: 262e 0010 movel %fp@(16),%d3
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
461f4: b0b9 0005 da64 cmpl 5da64 <rtems_libio_number_iops>,%d0
461fa: 641a bccs 46216 <writev+0x36> iop = rtems_libio_iop( fd );
461fc: 2200 movel %d0,%d1 461fe: ed88 lsll #6,%d0 46200: e789 lsll #3,%d1 46202: 2679 0005 f2e4 moveal 5f2e4 <rtems_libio_iops>,%a3 46208: 9081 subl %d1,%d0 4620a: d7c0 addal %d0,%a3
rtems_libio_check_is_open( iop );
4620c: 202b 0014 movel %a3@(20),%d0 46210: 0800 0008 btst #8,%d0
46214: 6610 bnes 46226 <writev+0x46>
46216: 4eb9 0004 d74c jsr 4d74c <__errno> 4621c: 7209 moveq #9,%d1 4621e: 2040 moveal %d0,%a0 46220: 2081 movel %d1,%a0@ 46222: 6000 00a4 braw 462c8 <writev+0xe8>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
46226: 44c0 movew %d0,%ccr
46228: 6636 bnes 46260 <writev+0x80> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
4622a: 4a8a tstl %a2
4622c: 6732 beqs 46260 <writev+0x80> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
4622e: 4a83 tstl %d3
46230: 6f2e bles 46260 <writev+0x80> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
46232: 0c83 0000 0400 cmpil #1024,%d3
46238: 6e26 bgts 46260 <writev+0x80> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
4623a: 204a moveal %a2,%a0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
4623c: 93c9 subal %a1,%a1 4623e: 4281 clrl %d1 46240: 7001 moveq #1,%d0 46242: 6002 bras 46246 <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++ ) {
46244: 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 )
46246: 4a90 tstl %a0@
46248: 6716 beqs 46260 <writev+0x80> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
4624a: 2428 0004 movel %a0@(4),%d2
all_zeros = false;
4624e: 57c4 seq %d4
/* check for wrap */
old = total;
total += iov[v].iov_len;
46250: 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;
46252: c084 andl %d4,%d0
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
46254: b282 cmpl %d2,%d1
46256: 6e08 bgts 46260 <writev+0x80>
46258: 0c82 0000 7fff cmpil #32767,%d2
4625e: 6f0e bles 4626e <writev+0x8e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
46260: 4eb9 0004 d74c jsr 4d74c <__errno> 46266: 2040 moveal %d0,%a0 46268: 7016 moveq #22,%d0 4626a: 2080 movel %d0,%a0@ 4626c: 605a bras 462c8 <writev+0xe8>
* 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++ ) {
4626e: 5289 addql #1,%a1 46270: 5088 addql #8,%a0 46272: b689 cmpl %a1,%d3
46274: 6ece bgts 46244 <writev+0x64> <== NEVER TAKEN
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
46276: 4a00 tstb %d0
46278: 664a bnes 462c4 <writev+0xe4>
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
4627a: 588a addql #4,%a2 4627c: 4284 clrl %d4 4627e: 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 )
46280: 2012 movel %a2@,%d0
46282: 6736 beqs 462ba <writev+0xda> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
46284: 206b 0020 moveal %a3@(32),%a0 46288: 2f00 movel %d0,%sp@- 4628a: 2f2a fffc movel %a2@(-4),%sp@- 4628e: 2f0b movel %a3,%sp@- 46290: 2068 000c moveal %a0@(12),%a0 46294: 4e90 jsr %a0@
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
46296: 4fef 000c lea %sp@(12),%sp 4629a: 4a80 tstl %d0
4629c: 6d2a blts 462c8 <writev+0xe8> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
4629e: 6716 beqs 462b6 <writev+0xd6> <== NEVER TAKEN
iop->offset += bytes;
total += bytes;
462a0: d480 addl %d0,%d2
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
462a2: 2c00 movel %d0,%d6 462a4: 5bc5 smi %d5 462a6: 49c5 extbl %d5 462a8: ddab 0010 addl %d6,%a3@(16) 462ac: 222b 000c movel %a3@(12),%d1 462b0: d385 addxl %d5,%d1 462b2: 2741 000c movel %d1,%a3@(12)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
462b6: b092 cmpl %a2@,%d0
462b8: 6610 bnes 462ca <writev+0xea> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
462ba: 5284 addql #1,%d4 462bc: 508a addql #8,%a2 462be: b684 cmpl %d4,%d3
462c0: 6ebe bgts 46280 <writev+0xa0>
462c2: 6006 bras 462ca <writev+0xea>
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
462c4: 4282 clrl %d2 462c6: 6002 bras 462ca <writev+0xea>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
462c8: 74ff moveq #-1,%d2
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
462ca: 2002 movel %d2,%d0 462cc: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3 462d2: 4e5e unlk %fp
...