RTEMS 4.11Annotated Report
Mon Sep 12 17:25:15 2011
00049014 <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 ) {
49014: 7206 moveq #6,%d1
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
49016: 4e56 0000 linkw %fp,#0
4901a: 206e 0008 moveal %fp@(8),%a0
4901e: 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 ) {
49020: 2450 moveal %a0@,%a2
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
49022: 2268 0010 moveal %a0@(16),%a1
switch( node->type ) {
49026: 202a 0048 movel %a2@(72),%d0
4902a: 5380 subql #1,%d0
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
4902c: 2269 0034 moveal %a1@(52),%a1
switch( node->type ) {
49030: b280 cmpl %d0,%d1
49032: 6546 bcss 4907a <IMFS_Set_handlers+0x66> <== NEVER TAKEN
49034: 303b 0a08 movew %pc@(4903e <IMFS_Set_handlers+0x2a>,%d0:l:2),%d0
49038: 48c0 extl %d0
4903a: 4efb 0802 jmp %pc@(4903e <IMFS_Set_handlers+0x2a>,%d0:l)
4903e: 000e .short 0x000e <== NOT EXECUTED
49040: 0016 .short 0x0016 <== NOT EXECUTED
49042: 0022 .short 0x0022 <== NOT EXECUTED
49044: 0022 .short 0x0022 <== NOT EXECUTED
49046: 002e .short 0x002e <== NOT EXECUTED
49048: 002e .short 0x002e <== NOT EXECUTED
4904a: 0036 .short 0x0036 <== NOT EXECUTED
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
4904c: 2169 000c 0008 movel %a1@(12),%a0@(8)
break;
49052: 6026 bras 4907a <IMFS_Set_handlers+0x66>
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
49054: 203c 0005 b40e movel #373774,%d0
4905a: 2140 0008 movel %d0,%a0@(8)
break;
4905e: 601a bras 4907a <IMFS_Set_handlers+0x66>
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
49060: 223c 0005 b47e movel #373886,%d1
49066: 2141 0008 movel %d1,%a0@(8)
break;
4906a: 600e bras 4907a <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;
4906c: 2169 0008 0008 movel %a1@(8),%a0@(8)
break;
49072: 6006 bras 4907a <IMFS_Set_handlers+0x66>
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
49074: 2169 0010 0008 movel %a1@(16),%a0@(8)
break;
}
return 0;
}
4907a: 245f moveal %sp@+,%a2
4907c: 4280 clrl %d0
4907e: 4e5e unlk %fp <== NOT EXECUTED
00048e04 <IMFS_allocate_node>:
IMFS_jnode_t *IMFS_allocate_node(
IMFS_jnode_types_t type,
const char *name,
mode_t mode
)
{
48e04: 4e56 fff8 linkw %fp,#-8
48e08: 2f0a movel %a2,%sp@-
struct timeval tv;
/*
* Allocate an IMFS jnode
*/
node = calloc( 1, sizeof( IMFS_jnode_t ) );
48e0a: 4878 0060 pea 60 <DBL_MANT_DIG+0x2b>
48e0e: 4878 0001 pea 1 <ADD>
48e12: 4eb9 0004 27cc jsr 427cc <calloc>
if ( !node )
48e18: 508f addql #8,%sp
struct timeval tv;
/*
* Allocate an IMFS jnode
*/
node = calloc( 1, sizeof( IMFS_jnode_t ) );
48e1a: 2440 moveal %d0,%a2
if ( !node )
48e1c: 4a80 tstl %d0
48e1e: 674e beqs 48e6e <IMFS_allocate_node+0x6a> <== NEVER TAKEN
/*
* Fill in the basic information
*/
node->st_nlink = 1;
node->type = type;
strncpy( node->name, name, IMFS_NAME_MAX );
48e20: 4878 0020 pea 20 <OPER2+0xc>
48e24: 2f2e 000c movel %fp@(12),%sp@-
/*
* Fill in the basic information
*/
node->st_nlink = 1;
node->type = type;
48e28: 256e 0008 0048 movel %fp@(8),%a2@(72)
strncpy( node->name, name, IMFS_NAME_MAX );
48e2e: 486a 000c pea %a2@(12)
return NULL;
/*
* Fill in the basic information
*/
node->st_nlink = 1;
48e32: 7001 moveq #1,%d0
48e34: 3540 0032 movew %d0,%a2@(50)
node->type = type;
strncpy( node->name, name, IMFS_NAME_MAX );
48e38: 4eb9 0004 d3bc jsr 4d3bc <strncpy>
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode;
48e3e: 256e 0010 002e movel %fp@(16),%a2@(46)
#endif
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
48e44: 42a7 clrl %sp@-
48e46: 486e fff8 pea %fp@(-8)
node->st_mode = mode;
#if defined(RTEMS_POSIX_API)
node->st_uid = geteuid();
node->st_gid = getegid();
#else
node->st_uid = 0;
48e4a: 4240 clrw %d0
48e4c: 3540 0038 movew %d0,%a2@(56)
node->st_gid = 0;
48e50: 3540 003a movew %d0,%a2@(58)
#endif
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
48e54: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
node->stat_atime = (time_t) tv.tv_sec;
48e5a: 202e fff8 movel %fp@(-8),%d0
node->stat_mtime = (time_t) tv.tv_sec;
node->stat_ctime = (time_t) tv.tv_sec;
return node;
48e5e: 4fef 0014 lea %sp@(20),%sp
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
node->stat_atime = (time_t) tv.tv_sec;
48e62: 2540 003c movel %d0,%a2@(60)
node->stat_mtime = (time_t) tv.tv_sec;
48e66: 2540 0040 movel %d0,%a2@(64)
node->stat_ctime = (time_t) tv.tv_sec;
48e6a: 2540 0044 movel %d0,%a2@(68)
return node;
}
48e6e: 200a movel %a2,%d0
48e70: 246e fff4 moveal %fp@(-12),%a2
48e74: 4e5e unlk %fp <== NOT EXECUTED
00048e78 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
48e78: 4e56 ffec linkw %fp,#-20
48e7c: 206e 0008 moveal %fp@(8),%a0
48e80: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
48e84: 242e 000c movel %fp@(12),%d2
48e88: 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 )
48e8c: 4a88 tstl %a0
48e8e: 6700 00ee beqw 48f7e <IMFS_create_node+0x106>
return NULL;
parent = parent_loc->node_access;
48e92: 2850 moveal %a0@,%a4
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
48e94: 7007 moveq #7,%d0
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
48e96: 2068 0010 moveal %a0@(16),%a0
48e9a: 2668 0034 moveal %a0@(52),%a3
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
48e9e: b082 cmpl %d2,%d0
48ea0: 660e bnes 48eb0 <IMFS_create_node+0x38>
48ea2: 223c 0005 b39e movel #373662,%d1
48ea8: b2ab 0010 cmpl %a3@(16),%d1
48eac: 6700 00d0 beqw 48f7e <IMFS_create_node+0x106>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
48eb0: 2079 0005 c130 moveal 5c130 <rtems_current_user_env>,%a0
48eb6: 2028 002c movel %a0@(44),%d0
48eba: 4680 notl %d0
48ebc: c0ae 0014 andl %fp@(20),%d0
48ec0: 2f00 movel %d0,%sp@-
48ec2: 2f2e 0010 movel %fp@(16),%sp@-
48ec6: 2f02 movel %d2,%sp@-
48ec8: 4eb9 0004 8e04 jsr 48e04 <IMFS_allocate_node>
if ( !node )
48ece: 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 );
48ed2: 2a40 moveal %d0,%a5
if ( !node )
48ed4: 4a80 tstl %d0
48ed6: 6700 00a8 beqw 48f80 <IMFS_create_node+0x108>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
48eda: 7001 moveq #1,%d0
48edc: b082 cmpl %d2,%d0
48ede: 6616 bnes 48ef6 <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 );
48ee0: 41ed 0050 lea %a5@(80),%a0
48ee4: 2b48 004c movel %a0,%a5@(76)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
48ee8: 41ed 004c lea %a5@(76),%a0
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
48eec: 42ad 0050 clrl %a5@(80)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
48ef0: 2b48 0054 movel %a0,%a5@(84)
48ef4: 6066 bras 48f5c <IMFS_create_node+0xe4>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
48ef6: 7003 moveq #3,%d0
48ef8: b082 cmpl %d2,%d0
48efa: 6706 beqs 48f02 <IMFS_create_node+0x8a>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
48efc: 7204 moveq #4,%d1
48efe: b282 cmpl %d2,%d1
48f00: 6606 bnes 48f08 <IMFS_create_node+0x90>
node->info.sym_link.name = info->sym_link.name;
48f02: 2b52 004c movel %a2@,%a5@(76)
48f06: 6054 bras 48f5c <IMFS_create_node+0xe4>
} else if ( type == IMFS_DEVICE ) {
48f08: 7002 moveq #2,%d0
48f0a: b082 cmpl %d2,%d0
48f0c: 660c bnes 48f1a <IMFS_create_node+0xa2>
node->info.device.major = info->device.major;
48f0e: 2b52 004c movel %a2@,%a5@(76)
node->info.device.minor = info->device.minor;
48f12: 2b6a 0004 0050 movel %a2@(4),%a5@(80)
48f18: 6042 bras 48f5c <IMFS_create_node+0xe4>
} else if ( type == IMFS_LINEAR_FILE ) {
48f1a: 7206 moveq #6,%d1
48f1c: b282 cmpl %d2,%d1
48f1e: 6612 bnes 48f32 <IMFS_create_node+0xba>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
48f20: 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;
48f24: 4280 clrl %d0
48f26: 4281 clrl %d1
48f28: 2b40 004c movel %d0,%a5@(76)
48f2c: 2b41 0050 movel %d1,%a5@(80)
48f30: 602a bras 48f5c <IMFS_create_node+0xe4>
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
48f32: 7205 moveq #5,%d1
48f34: b282 cmpl %d2,%d1
48f36: 661a bnes 48f52 <IMFS_create_node+0xda>
node->info.file.size = 0;
node->info.file.indirect = 0;
48f38: 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;
48f3c: 4280 clrl %d0
48f3e: 4281 clrl %d1
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
48f40: 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;
48f44: 2b40 004c movel %d0,%a5@(76)
48f48: 2b41 0050 movel %d1,%a5@(80)
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
48f4c: 42ad 005c clrl %a5@(92)
48f50: 600a bras 48f5c <IMFS_create_node+0xe4>
} else if ( type == IMFS_FIFO ) {
48f52: 7207 moveq #7,%d1
48f54: b282 cmpl %d2,%d1
48f56: 6604 bnes 48f5c <IMFS_create_node+0xe4> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
48f58: 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;
48f5c: 202b 0004 movel %a3@(4),%d0
48f60: 5280 addql #1,%d0
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
48f62: 2b4c 0008 movel %a4,%a5@(8)
node->st_ino = ++fs_info->ino_count;
48f66: 2740 0004 movel %d0,%a3@(4)
48f6a: 2b40 0034 movel %d0,%a5@(52)
48f6e: 2f0d movel %a5,%sp@-
48f70: 486c 004c pea %a4@(76)
48f74: 4eb9 0004 635c jsr 4635c <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
48f7a: 508f addql #8,%sp
48f7c: 6002 bras 48f80 <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;
48f7e: 9bcd subal %a5,%a5
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
48f80: 200d movel %a5,%d0
48f82: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
48f88: 4e5e unlk %fp <== NOT EXECUTED
00049100 <IMFS_eval_path>:
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
49100: 70f8 moveq #-8,%d0
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
49102: 4e56 ffac linkw %fp,#-84
49106: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4910a: 262e 0010 movel %fp@(16),%d3
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
4910e: c083 andl %d3,%d0
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
49110: 286e 0008 moveal %fp@(8),%a4
49114: 246e 0014 moveal %fp@(20),%a2
int i = 0;
49118: 42ae fff8 clrl %fp@(-8)
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
4911c: 4a80 tstl %d0
4911e: 6710 beqs 49130 <IMFS_eval_path+0x30> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
49120: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
49126: 7c05 moveq #5,%d6 <== NOT EXECUTED
49128: 2040 moveal %d0,%a0 <== NOT EXECUTED
4912a: 2086 movel %d6,%a0@ <== NOT EXECUTED
4912c: 6000 0248 braw 49376 <IMFS_eval_path+0x276> <== NOT EXECUTED
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
49130: 280e movel %fp,%d4
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
49132: 2a0e movel %fp,%d5
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
49134: 0684 ffff ffd7 addil #-41,%d4
4913a: 2e3c 0004 981c movel #301084,%d7
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
49140: 4bf9 0004 9082 lea 49082 <IMFS_evaluate_permission>,%a5
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
49146: 0685 0000 000c addil #12,%d5
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
4914c: 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 );
4914e: 486e fffc pea %fp@(-4)
49152: 200c movel %a4,%d0
49154: d0ae fff8 addl %fp@(-8),%d0
49158: 2047 moveal %d7,%a0
4915a: 2f04 movel %d4,%sp@-
4915c: 2f2e 000c movel %fp@(12),%sp@-
49160: 2f00 movel %d0,%sp@-
49162: 4e90 jsr %a0@
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
49164: 4fef 0010 lea %sp@(16),%sp
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
49168: 2400 movel %d0,%d2
pathnamelen -= len;
4916a: 202e fffc movel %fp@(-4),%d0
4916e: 91ae 000c subl %d0,%fp@(12)
i += len;
49172: d1ae fff8 addl %d0,%fp@(-8)
if ( !pathloc->node_access )
49176: 4a92 tstl %a2@
49178: 6700 00ea beqw 49264 <IMFS_eval_path+0x164>
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
4917c: 4a82 tstl %d2
4917e: 6718 beqs 49198 <IMFS_eval_path+0x98>
if ( node->type == IMFS_DIRECTORY )
49180: 7001 moveq #1,%d0
49182: b0ab 0048 cmpl %a3@(72),%d0
49186: 6610 bnes 49198 <IMFS_eval_path+0x98>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
49188: 4878 0001 pea 1 <ADD>
4918c: 2f0a movel %a2,%sp@-
4918e: 4e95 jsr %a5@
49190: 508f addql #8,%sp
49192: 4a80 tstl %d0
49194: 6700 01d4 beqw 4936a <IMFS_eval_path+0x26a>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
49198: 2652 moveal %a2@,%a3
switch( type ) {
4919a: 7003 moveq #3,%d0
4919c: b082 cmpl %d2,%d0
4919e: 6762 beqs 49202 <IMFS_eval_path+0x102>
491a0: 7204 moveq #4,%d1
491a2: b282 cmpl %d2,%d1
491a4: 6700 0144 beqw 492ea <IMFS_eval_path+0x1ea>
491a8: 7c02 moveq #2,%d6
491aa: bc82 cmpl %d2,%d6
491ac: 6600 014a bnew 492f8 <IMFS_eval_path+0x1f8>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
491b0: 2079 0005 c130 moveal 5c130 <rtems_current_user_env>,%a0
491b6: b7e8 0018 cmpal %a0@(24),%a3
491ba: 6792 beqs 4914e <IMFS_eval_path+0x4e>
static inline bool rtems_filesystem_is_root_location(
const rtems_filesystem_location_info_t *loc
)
{
return loc->mt_entry->mt_fs_root.node_access == loc->node_access;
491bc: 206a 0010 moveal %a2@(16),%a0
/*
* Am I at the root of this mounted filesystem?
*/
if ( rtems_filesystem_is_root_location( pathloc ) ) {
491c0: b7e8 001c cmpal %a0@(28),%a3
491c4: 6630 bnes 491f6 <IMFS_eval_path+0xf6>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
491c6: 4878 0014 pea 14 <OPER2>
491ca: 4868 0008 pea %a0@(8)
491ce: 2f0a movel %a2,%sp@-
491d0: 4eb9 0004 c854 jsr 4c854 <memcpy>
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),
491d6: 206a 000c moveal %a2@(12),%a0
491da: 202e fffc movel %fp@(-4),%d0
491de: 2200 movel %d0,%d1
491e0: d2ae 000c addl %fp@(12),%d1
491e4: 2f0a movel %a2,%sp@-
491e6: 2c2e fff8 movel %fp@(-8),%d6
491ea: 9c80 subl %d0,%d6
491ec: 2006 movel %d6,%d0
491ee: 2f03 movel %d3,%sp@-
491f0: 2f01 movel %d1,%sp@-
491f2: 6000 014c braw 49340 <IMFS_eval_path+0x240>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
491f6: 266b 0008 moveal %a3@(8),%a3
491fa: 4a8b tstl %a3
491fc: 6600 00e6 bnew 492e4 <IMFS_eval_path+0x1e4>
49200: 6062 bras 49264 <IMFS_eval_path+0x164>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
49202: 202b 0048 movel %a3@(72),%d0
49206: 7203 moveq #3,%d1
49208: b280 cmpl %d0,%d1
4920a: 6610 bnes 4921c <IMFS_eval_path+0x11c>
IMFS_evaluate_hard_link( pathloc, 0 );
4920c: 42a7 clrl %sp@-
4920e: 2f0a movel %a2,%sp@-
49210: 4eb9 0004 90ba jsr 490ba <IMFS_evaluate_hard_link>
node = pathloc->node_access;
49216: 2652 moveal %a2@,%a3
49218: 508f addql #8,%sp
4921a: 601e bras 4923a <IMFS_eval_path+0x13a>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
4921c: 7c04 moveq #4,%d6
4921e: bc80 cmpl %d0,%d6
49220: 6618 bnes 4923a <IMFS_eval_path+0x13a>
result = IMFS_evaluate_sym_link( pathloc, 0 );
49222: 42a7 clrl %sp@-
49224: 2f0a movel %a2,%sp@-
49226: 4eb9 0004 9384 jsr 49384 <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
4922c: 2652 moveal %a2@,%a3
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
4922e: 2400 movel %d0,%d2
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
if ( result == -1 )
49230: 508f addql #8,%sp
49232: 70ff moveq #-1,%d0
49234: b082 cmpl %d2,%d0
49236: 6700 0140 beqw 49378 <IMFS_eval_path+0x278>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
4923a: 7201 moveq #1,%d1
4923c: b2ab 0048 cmpl %a3@(72),%d1
49240: 6710 beqs 49252 <IMFS_eval_path+0x152>
rtems_set_errno_and_return_minus_one( ENOTDIR );
49242: 4eb9 0004 c034 jsr 4c034 <__errno>
49248: 7a14 moveq #20,%d5
4924a: 2040 moveal %d0,%a0
4924c: 2085 movel %d5,%a0@
4924e: 6000 0126 braw 49376 <IMFS_eval_path+0x276>
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
49252: 2f04 movel %d4,%sp@-
49254: 2f0b movel %a3,%sp@-
49256: 4eb9 0004 97b0 jsr 497b0 <IMFS_find_match_in_dir>
if ( !node )
4925c: 508f addql #8,%sp
rtems_set_errno_and_return_minus_one( ENOTDIR );
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
4925e: 2640 moveal %d0,%a3
if ( !node )
49260: 4a80 tstl %d0
49262: 6610 bnes 49274 <IMFS_eval_path+0x174>
rtems_set_errno_and_return_minus_one( ENOENT );
49264: 4eb9 0004 c034 jsr 4c034 <__errno>
4926a: 7802 moveq #2,%d4
4926c: 2040 moveal %d0,%a0
4926e: 2084 movel %d4,%a0@
49270: 6000 0104 braw 49376 <IMFS_eval_path+0x276>
* file system and not the IMFS. For example the IMFS length is
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
49274: 7001 moveq #1,%d0
49276: b0ab 0048 cmpl %a3@(72),%d0
4927a: 6668 bnes 492e4 <IMFS_eval_path+0x1e4>
4927c: 4aab 0058 tstl %a3@(88)
49280: 6762 beqs 492e4 <IMFS_eval_path+0x1e4>
IMFS_skip_separator( pathname, &pathnamelen, &i);
49282: 486e fff8 pea %fp@(-8)
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
49286: 240c movel %a4,%d2
49288: 7c2e moveq #46,%d6
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
4928a: 2f05 movel %d5,%sp@-
4928c: 2f0c movel %a4,%sp@-
4928e: 4eba fd38 jsr %pc@(48fc8 <IMFS_skip_separator>)
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
49292: 202e fff8 movel %fp@(-8),%d0
49296: d480 addl %d0,%d2
49298: 2042 moveal %d2,%a0
4929a: 4fef 000c lea %sp@(12),%sp
4929e: 1210 moveb %a0@,%d1
492a0: 49c1 extbl %d1
492a2: bc81 cmpl %d1,%d6
492a4: 660a bnes 492b0 <IMFS_eval_path+0x1b0>
492a6: 1234 0801 moveb %a4@(00000001,%d0:l),%d1
492aa: 49c1 extbl %d1
492ac: bc81 cmpl %d1,%d6
492ae: 6726 beqs 492d6 <IMFS_eval_path+0x1d6>
*pathloc = node->info.directory.mt_fs->mt_fs_root;
492b0: 4878 0014 pea 14 <OPER2>
492b4: 266b 0058 moveal %a3@(88),%a3
492b8: 47eb 001c lea %a3@(28),%a3
492bc: 2f0b movel %a3,%sp@-
492be: 2f0a movel %a2,%sp@-
492c0: 4eb9 0004 c854 jsr 4c854 <memcpy>
return (*pathloc->ops->evalpath_h)( &pathname[i],
492c6: 206a 000c moveal %a2@(12),%a0
492ca: 2f0a movel %a2,%sp@-
492cc: 2f03 movel %d3,%sp@-
492ce: 2f2e 000c movel %fp@(12),%sp@-
492d2: 2f02 movel %d2,%sp@-
492d4: 606e bras 49344 <IMFS_eval_path+0x244>
pathnamelen,
flags, pathloc );
}
i += 2;
492d6: 5480 addql #2,%d0
pathnamelen -= 2;
492d8: 55ae 000c subql #2,%fp@(12)
node = node->Parent;
492dc: 266b 0008 moveal %a3@(8),%a3
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
492e0: 2d40 fff8 movel %d0,%fp@(-8)
}
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
492e4: 248b movel %a3,%a2@
break;
492e6: 6000 fe66 braw 4914e <IMFS_eval_path+0x4e>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
492ea: 4eb9 0004 c034 jsr 4c034 <__errno>
492f0: 765b moveq #91,%d3
492f2: 2040 moveal %d0,%a0
492f4: 2083 movel %d3,%a0@
492f6: 607e bras 49376 <IMFS_eval_path+0x276>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
492f8: 4a82 tstl %d2
492fa: 6708 beqs 49304 <IMFS_eval_path+0x204>
492fc: 7004 moveq #4,%d0
492fe: b082 cmpl %d2,%d0
49300: 6600 fe4c bnew 4914e <IMFS_eval_path+0x4e>
* new fs root node and let let the mounted filesystem set the handlers.
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
49304: 7201 moveq #1,%d1
49306: b2ab 0048 cmpl %a3@(72),%d1
4930a: 6644 bnes 49350 <IMFS_eval_path+0x250>
if ( node->info.directory.mt_fs != NULL ) {
4930c: 206b 0058 moveal %a3@(88),%a0
49310: 4a88 tstl %a0
49312: 673c beqs 49350 <IMFS_eval_path+0x250> <== ALWAYS TAKEN
*pathloc = node->info.directory.mt_fs->mt_fs_root;
49314: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
49318: 4868 001c pea %a0@(28) <== NOT EXECUTED
4931c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4931e: 4eb9 0004 c854 jsr 4c854 <memcpy> <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
49324: 206a 000c moveal %a2@(12),%a0 <== NOT EXECUTED
49328: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
4932c: 2c00 movel %d0,%d6 <== NOT EXECUTED
4932e: dcae 000c addl %fp@(12),%d6 <== NOT EXECUTED
49332: 2f0a movel %a2,%sp@- <== NOT EXECUTED
49334: 222e fff8 movel %fp@(-8),%d1 <== NOT EXECUTED
49338: 9280 subl %d0,%d1 <== NOT EXECUTED
4933a: 2001 movel %d1,%d0 <== NOT EXECUTED
4933c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4933e: 2f06 movel %d6,%sp@- <== NOT EXECUTED
49340: 4874 0800 pea %a4@(00000000,%d0:l)
49344: 2050 moveal %a0@,%a0
49346: 4e90 jsr %a0@
49348: 4fef 001c lea %sp@(28),%sp
4934c: 2400 movel %d0,%d2
4934e: 6028 bras 49378 <IMFS_eval_path+0x278>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
49350: 2f0a movel %a2,%sp@-
49352: 4eb9 0004 9014 jsr 49014 <IMFS_Set_handlers>
49358: 2400 movel %d0,%d2
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
4935a: 2e83 movel %d3,%sp@
4935c: 2f0a movel %a2,%sp@-
4935e: 4eb9 0004 9082 jsr 49082 <IMFS_evaluate_permission>
49364: 508f addql #8,%sp
49366: 4a80 tstl %d0
49368: 660e bnes 49378 <IMFS_eval_path+0x278>
rtems_set_errno_and_return_minus_one( EACCES );
4936a: 4eb9 0004 c034 jsr 4c034 <__errno>
49370: 740d moveq #13,%d2
49372: 2040 moveal %d0,%a0
49374: 2082 movel %d2,%a0@
49376: 74ff moveq #-1,%d2
return result;
}
49378: 2002 movel %d2,%d0
4937a: 4cee 3cfc ffac moveml %fp@(-84),%d2-%d7/%a2-%a5
49380: 4e5e unlk %fp <== NOT EXECUTED
00049498 <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 */
)
{
49498: 4e56 ffa8 linkw %fp,#-88
4949c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
494a0: 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 );
494a4: 260e movel %fp,%d3
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
494a6: 2a0e movel %fp,%d5
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
494a8: 0683 ffff ffd3 addil #-45,%d3
494ae: 2e3c 0004 981c movel #301084,%d7
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
494b4: 2c3c 0004 9082 movel #299138,%d6
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
494ba: 0685 ffff fff4 addil #-12,%d5
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
494c0: 286e 0008 moveal %fp@(8),%a4
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
494c4: 2652 moveal %a2@,%a3
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
494c6: 42ae fff4 clrl %fp@(-12)
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
494ca: 2a6e 0010 moveal %fp@(16),%a5
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
494ce: 2f0c movel %a4,%sp@-
494d0: 4eb9 0004 d3a0 jsr 4d3a0 <strlen>
494d6: 588f addql #4,%sp
494d8: 2d40 fffc movel %d0,%fp@(-4)
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
494dc: 486e fff8 pea %fp@(-8)
494e0: 200c movel %a4,%d0
494e2: d0ae fff4 addl %fp@(-12),%d0
494e6: 2047 moveal %d7,%a0
494e8: 2f03 movel %d3,%sp@-
494ea: 2f2e fffc movel %fp@(-4),%sp@-
494ee: 2f00 movel %d0,%sp@-
494f0: 4e90 jsr %a0@
pathlen -= len;
i += len;
if ( !pathloc->node_access )
494f2: 4fef 0010 lea %sp@(16),%sp
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
494f6: 2400 movel %d0,%d2
pathlen -= len;
494f8: 202e fff8 movel %fp@(-8),%d0
494fc: 91ae fffc subl %d0,%fp@(-4)
i += len;
49500: d1ae fff4 addl %d0,%fp@(-12)
if ( !pathloc->node_access )
49504: 4a92 tstl %a2@
49506: 6700 0198 beqw 496a0 <IMFS_evaluate_for_make+0x208>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
4950a: 4a82 tstl %d2
4950c: 671a beqs 49528 <IMFS_evaluate_for_make+0x90>
if ( node->type == IMFS_DIRECTORY )
4950e: 7001 moveq #1,%d0
49510: b0ab 0048 cmpl %a3@(72),%d0
49514: 6612 bnes 49528 <IMFS_evaluate_for_make+0x90>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
49516: 4878 0001 pea 1 <ADD>
4951a: 2046 moveal %d6,%a0
4951c: 2f0a movel %a2,%sp@-
4951e: 4e90 jsr %a0@
49520: 508f addql #8,%sp
49522: 4a80 tstl %d0
49524: 6700 01cc beqw 496f2 <IMFS_evaluate_for_make+0x25a>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
49528: 2652 moveal %a2@,%a3
switch( type ) {
4952a: 7002 moveq #2,%d0
4952c: b082 cmpl %d2,%d0
4952e: 671a beqs 4954a <IMFS_evaluate_for_make+0xb2>
49530: 6508 bcss 4953a <IMFS_evaluate_for_make+0xa2>
49532: 4a82 tstl %d2
49534: 6700 012c beqw 49662 <IMFS_evaluate_for_make+0x1ca>
49538: 60a2 bras 494dc <IMFS_evaluate_for_make+0x44>
4953a: 7203 moveq #3,%d1
4953c: b282 cmpl %d2,%d1
4953e: 6756 beqs 49596 <IMFS_evaluate_for_make+0xfe>
49540: 7804 moveq #4,%d4
49542: b882 cmpl %d2,%d4
49544: 6696 bnes 494dc <IMFS_evaluate_for_make+0x44> <== NEVER TAKEN
49546: 6000 012a braw 49672 <IMFS_evaluate_for_make+0x1da>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
4954a: 2079 0005 c130 moveal 5c130 <rtems_current_user_env>,%a0
49550: b7e8 0018 cmpal %a0@(24),%a3
49554: 6786 beqs 494dc <IMFS_evaluate_for_make+0x44>
49556: 206a 0010 moveal %a2@(16),%a0
/*
* Am I at the root of this mounted filesystem?
*/
if ( rtems_filesystem_is_root_location( pathloc ) ) {
4955a: b7e8 001c cmpal %a0@(28),%a3
4955e: 6628 bnes 49588 <IMFS_evaluate_for_make+0xf0>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
49560: 4878 0014 pea 14 <OPER2>
49564: 4868 0008 pea %a0@(8)
49568: 2f0a movel %a2,%sp@-
4956a: 4eb9 0004 c854 jsr 4c854 <memcpy>
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
49570: 206a 000c moveal %a2@(12),%a0
49574: 202e fff4 movel %fp@(-12),%d0
49578: 90ae fff8 subl %fp@(-8),%d0
4957c: 2f0d movel %a5,%sp@-
4957e: 2f0a movel %a2,%sp@-
49580: 4874 0800 pea %a4@(00000000,%d0:l)
49584: 6000 00b8 braw 4963e <IMFS_evaluate_for_make+0x1a6>
}
} else {
if ( !node->Parent )
49588: 266b 0008 moveal %a3@(8),%a3
4958c: 4a8b tstl %a3
4958e: 6600 00cc bnew 4965c <IMFS_evaluate_for_make+0x1c4>
49592: 6000 010c braw 496a0 <IMFS_evaluate_for_make+0x208>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
49596: 202b 0048 movel %a3@(72),%d0
4959a: 7203 moveq #3,%d1
4959c: b280 cmpl %d0,%d1
4959e: 6706 beqs 495a6 <IMFS_evaluate_for_make+0x10e>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
495a0: 7204 moveq #4,%d1
495a2: b280 cmpl %d0,%d1
495a4: 6616 bnes 495bc <IMFS_evaluate_for_make+0x124>
result = IMFS_evaluate_link( pathloc, 0 );
495a6: 42a7 clrl %sp@-
if ( result == -1 )
495a8: 78ff moveq #-1,%d4
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
495aa: 2f0a movel %a2,%sp@-
495ac: 4eb9 0004 9400 jsr 49400 <IMFS_evaluate_link>
if ( result == -1 )
495b2: 508f addql #8,%sp
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
495b4: 2400 movel %d0,%d2
if ( result == -1 )
495b6: b880 cmpl %d0,%d4
495b8: 6700 0146 beqw 49700 <IMFS_evaluate_for_make+0x268>
return -1;
}
node = pathloc->node_access;
495bc: 2052 moveal %a2@,%a0
if ( !node )
495be: 4a88 tstl %a0
495c0: 6700 0110 beqw 496d2 <IMFS_evaluate_for_make+0x23a>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
495c4: 7001 moveq #1,%d0
495c6: b0a8 0048 cmpl %a0@(72),%d0
495ca: 6600 0106 bnew 496d2 <IMFS_evaluate_for_make+0x23a>
/*
* Find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
495ce: 2f03 movel %d3,%sp@-
495d0: 2f08 movel %a0,%sp@-
495d2: 4eb9 0004 97b0 jsr 497b0 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
495d8: 508f addql #8,%sp
/*
* Find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
495da: 2640 moveal %d0,%a3
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
495dc: 4a80 tstl %d0
495de: 6700 00a0 beqw 49680 <IMFS_evaluate_for_make+0x1e8>
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
495e2: 7001 moveq #1,%d0
495e4: b0ab 0048 cmpl %a3@(72),%d0
495e8: 6672 bnes 4965c <IMFS_evaluate_for_make+0x1c4>
495ea: 4aab 0058 tstl %a3@(88)
495ee: 676c beqs 4965c <IMFS_evaluate_for_make+0x1c4>
IMFS_skip_separator( path, &pathlen, &i);
495f0: 2f05 movel %d5,%sp@-
495f2: 486e fffc pea %fp@(-4)
if ((path[i] != '.') || (path[i + 1] != '.')) {
495f6: 240c movel %a4,%d2
495f8: 782e moveq #46,%d4
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
495fa: 2f0c movel %a4,%sp@-
495fc: 4eba f9ca jsr %pc@(48fc8 <IMFS_skip_separator>)
if ((path[i] != '.') || (path[i + 1] != '.')) {
49600: 202e fff4 movel %fp@(-12),%d0
49604: d480 addl %d0,%d2
49606: 2042 moveal %d2,%a0
49608: 4fef 000c lea %sp@(12),%sp
4960c: 1210 moveb %a0@,%d1
4960e: 49c1 extbl %d1
49610: b881 cmpl %d1,%d4
49612: 660a bnes 4961e <IMFS_evaluate_for_make+0x186>
49614: 1234 0801 moveb %a4@(00000001,%d0:l),%d1
49618: 49c1 extbl %d1
4961a: b881 cmpl %d1,%d4
4961c: 6730 beqs 4964e <IMFS_evaluate_for_make+0x1b6> <== ALWAYS TAKEN
*pathloc = node->info.directory.mt_fs->mt_fs_root;
4961e: 4878 0014 pea 14 <OPER2>
49622: 266b 0058 moveal %a3@(88),%a3
49626: 47eb 001c lea %a3@(28),%a3
4962a: 2f0b movel %a3,%sp@-
4962c: 2f0a movel %a2,%sp@-
4962e: 4eb9 0004 c854 jsr 4c854 <memcpy>
return (*pathloc->ops->evalformake_h)( &path[i],
49634: 206a 000c moveal %a2@(12),%a0
49638: 2f0d movel %a5,%sp@-
4963a: 2f0a movel %a2,%sp@-
4963c: 2f02 movel %d2,%sp@-
4963e: 2068 0004 moveal %a0@(4),%a0
49642: 4e90 jsr %a0@
49644: 4fef 0018 lea %sp@(24),%sp
49648: 2400 movel %d0,%d2
4964a: 6000 00b4 braw 49700 <IMFS_evaluate_for_make+0x268>
pathloc,
name );
}
i += 2;
4964e: 5480 addql #2,%d0
pathlen -= 2;
49650: 55ae fffc subql #2,%fp@(-4)
node = node->Parent;
49654: 266b 0008 moveal %a3@(8),%a3
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalformake_h)( &path[i],
pathloc,
name );
}
i += 2;
49658: 2d40 fff4 movel %d0,%fp@(-12)
pathlen -= 2;
node = node->Parent;
}
pathloc->node_access = node;
4965c: 248b movel %a3,%a2@
4965e: 6000 fe7c braw 494dc <IMFS_evaluate_for_make+0x44>
}
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
49662: 4eb9 0004 c034 jsr 4c034 <__errno>
49668: 7c11 moveq #17,%d6
4966a: 2040 moveal %d0,%a0
4966c: 2086 movel %d6,%a0@
4966e: 6000 008e braw 496fe <IMFS_evaluate_for_make+0x266>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
49672: 4eb9 0004 c034 jsr 4c034 <__errno>
49678: 7a5b moveq #91,%d5
4967a: 2040 moveal %d0,%a0
4967c: 2085 movel %d5,%a0@
4967e: 607e bras 496fe <IMFS_evaluate_for_make+0x266>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
49680: 202e fff4 movel %fp@(-12),%d0
49684: 90ae fff8 subl %fp@(-8),%d0
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
if ( !IMFS_is_separator( path[ i ] ) )
49688: 47f9 0004 38a4 lea 438a4 <rtems_filesystem_is_separator>,%a3
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
4968e: d08c addl %a4,%d0
49690: 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++) {
49692: 601e bras 496b2 <IMFS_evaluate_for_make+0x21a>
if ( !IMFS_is_separator( path[ i ] ) )
49694: 49c0 extbl %d0
49696: 2f00 movel %d0,%sp@-
49698: 4e93 jsr %a3@
4969a: 588f addql #4,%sp
4969c: 4a80 tstl %d0
4969e: 660e bnes 496ae <IMFS_evaluate_for_make+0x216>
rtems_set_errno_and_return_minus_one( ENOENT );
496a0: 4eb9 0004 c034 jsr 4c034 <__errno>
496a6: 7802 moveq #2,%d4
496a8: 2040 moveal %d0,%a0
496aa: 2084 movel %d4,%a0@
496ac: 6050 bras 496fe <IMFS_evaluate_for_make+0x266>
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
496ae: 52ae fff4 addql #1,%fp@(-12)
496b2: 202e fff4 movel %fp@(-12),%d0
496b6: 1034 0800 moveb %a4@(00000000,%d0:l),%d0
496ba: 66d8 bnes 49694 <IMFS_evaluate_for_make+0x1fc>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
496bc: 2f0a movel %a2,%sp@-
496be: 4eb9 0004 9014 jsr 49014 <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
496c4: 2052 moveal %a2@,%a0
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
496c6: 2400 movel %d0,%d2
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
496c8: 588f addql #4,%sp
496ca: 7001 moveq #1,%d0
496cc: b0a8 0048 cmpl %a0@(72),%d0
496d0: 670e beqs 496e0 <IMFS_evaluate_for_make+0x248> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
496d2: 4eb9 0004 c034 jsr 4c034 <__errno>
496d8: 7614 moveq #20,%d3
496da: 2040 moveal %d0,%a0
496dc: 2083 movel %d3,%a0@
496de: 601e bras 496fe <IMFS_evaluate_for_make+0x266>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
496e0: 4878 0003 pea 3 <DIVIDE>
496e4: 2f0a movel %a2,%sp@-
496e6: 4eb9 0004 9082 jsr 49082 <IMFS_evaluate_permission>
496ec: 508f addql #8,%sp
496ee: 4a80 tstl %d0
496f0: 660e bnes 49700 <IMFS_evaluate_for_make+0x268>
rtems_set_errno_and_return_minus_one( EACCES );
496f2: 4eb9 0004 c034 jsr 4c034 <__errno>
496f8: 740d moveq #13,%d2
496fa: 2040 moveal %d0,%a0
496fc: 2082 movel %d2,%a0@
496fe: 74ff moveq #-1,%d2
return result;
}
49700: 2002 movel %d2,%d0
49702: 4cee 3cfc ffa8 moveml %fp@(-88),%d2-%d7/%a2-%a5
49708: 4e5e unlk %fp <== NOT EXECUTED
00049082 <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 ) )
49082: 72f8 moveq #-8,%d1
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
49084: 4e56 0000 linkw %fp,#0
49088: 202e 000c movel %fp@(12),%d0
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
4908c: c280 andl %d0,%d1
4908e: 6710 beqs 490a0 <IMFS_evaluate_permission+0x1e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
49090: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
49096: 2040 moveal %d0,%a0 <== NOT EXECUTED
49098: 7001 moveq #1,%d0 <== NOT EXECUTED
4909a: 2080 movel %d0,%a0@ <== NOT EXECUTED
4909c: 70ff moveq #-1,%d0 <== NOT EXECUTED
4909e: 6016 bras 490b6 <IMFS_evaluate_permission+0x34> <== NOT EXECUTED
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
490a0: 206e 0008 moveal %fp@(8),%a0
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
490a4: ed88 lsll #6,%d0
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
490a6: 2050 moveal %a0@,%a0
490a8: 2200 movel %d0,%d1
490aa: c2a8 002e andl %a0@(46),%d1
return 1;
490ae: b081 cmpl %d1,%d0
490b0: 57c0 seq %d0
490b2: 49c0 extbl %d0
490b4: 4480 negl %d0
return 0;
}
490b6: 4e5e unlk %fp <== NOT EXECUTED
0004305c <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
4305c: 4e56 fff4 linkw %fp,#-12
43060: 206e 0008 moveal %fp@(8),%a0
43064: 48d7 001c moveml %d2-%d4,%sp@
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
43068: 2f08 movel %a0,%sp@-
4306a: 2f2e 0014 movel %fp@(20),%sp@-
4306e: 2f2e 0010 movel %fp@(16),%sp@-
43072: 2f2e 000c movel %fp@(12),%sp@-
43076: 2068 0018 moveal %a0@(24),%a0
4307a: 2f28 004c movel %a0@(76),%sp@-
4307e: 4eb9 0004 bbd6 jsr 4bbd6 <pipe_lseek>
IMFS_FIFO_RETURN(err);
43084: 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);
43088: 2800 movel %d0,%d4
4308a: 2600 movel %d0,%d3
4308c: 5bc2 smi %d2
4308e: 49c2 extbl %d2
IMFS_FIFO_RETURN(err);
43090: 4a82 tstl %d2
43092: 6a10 bpls 430a4 <IMFS_fifo_lseek+0x48> <== NEVER TAKEN
43094: 4eb9 0004 d89c jsr 4d89c <__errno>
4309a: 4484 negl %d4
4309c: 2040 moveal %d0,%a0
4309e: 74ff moveq #-1,%d2
430a0: 76ff moveq #-1,%d3
430a2: 2084 movel %d4,%a0@
}
430a4: 2002 movel %d2,%d0
430a6: 2203 movel %d3,%d1
430a8: 4cee 001c fff4 moveml %fp@(-12),%d2-%d4
430ae: 4e5e unlk %fp <== NOT EXECUTED
000430b2 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
430b2: 4e56 fff8 linkw %fp,#-8
430b6: 206e 0008 moveal %fp@(8),%a0
430ba: 2f0a movel %a2,%sp@-
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
430bc: 2468 0018 moveal %a0@(24),%a2
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
430c0: 2f02 movel %d2,%sp@-
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
430c2: 2f08 movel %a0,%sp@-
430c4: 2f2e 0010 movel %fp@(16),%sp@-
430c8: 2f2e 000c movel %fp@(12),%sp@-
430cc: 2f2a 004c movel %a2@(76),%sp@-
430d0: 4eb9 0004 b9fe jsr 4b9fe <pipe_write>
if (err > 0) {
430d6: 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);
430da: 2400 movel %d0,%d2
if (err > 0) {
430dc: 6f1c bles 430fa <IMFS_fifo_write+0x48>
IMFS_mtime_ctime_update(jnode);
430de: 42a7 clrl %sp@-
430e0: 486e fff8 pea %fp@(-8)
430e4: 4eb9 0004 4270 jsr 44270 <gettimeofday>
430ea: 202e fff8 movel %fp@(-8),%d0
430ee: 508f addql #8,%sp
430f0: 2540 0040 movel %d0,%a2@(64)
430f4: 2540 0044 movel %d0,%a2@(68)
430f8: 6012 bras 4310c <IMFS_fifo_write+0x5a>
}
IMFS_FIFO_RETURN(err);
430fa: 4a80 tstl %d0
430fc: 670e beqs 4310c <IMFS_fifo_write+0x5a> <== NEVER TAKEN
430fe: 4eb9 0004 d89c jsr 4d89c <__errno>
43104: 4482 negl %d2
43106: 2040 moveal %d0,%a0
43108: 2082 movel %d2,%a0@
4310a: 74ff moveq #-1,%d2
}
4310c: 2002 movel %d2,%d0
4310e: 242e fff0 movel %fp@(-16),%d2
43112: 246e fff4 moveal %fp@(-12),%a2
43116: 4e5e unlk %fp <== NOT EXECUTED
000497b0 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
497b0: 4e56 fff0 linkw %fp,#-16
497b4: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
497b8: 4879 0005 b406 pea 5b406 <dotname>
497be: 49f9 0004 cdec lea 4cdec <strcmp>,%a4
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
497c4: 242e 000c movel %fp@(12),%d2
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
497c8: 2f02 movel %d2,%sp@-
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
497ca: 246e 0008 moveal %fp@(8),%a2
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
497ce: 4e94 jsr %a4@
497d0: 508f addql #8,%sp
497d2: 4a80 tstl %d0
497d4: 673a beqs 49810 <IMFS_find_match_in_dir+0x60> <== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
497d6: 4879 0005 b408 pea 5b408 <dotdotname>
497dc: 2f02 movel %d2,%sp@-
497de: 4e94 jsr %a4@
497e0: 508f addql #8,%sp
497e2: 4a80 tstl %d0
497e4: 6606 bnes 497ec <IMFS_find_match_in_dir+0x3c> <== ALWAYS TAKEN
return directory->Parent;
497e6: 246a 0008 moveal %a2@(8),%a2 <== NOT EXECUTED
497ea: 6024 bras 49810 <IMFS_find_match_in_dir+0x60> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
497ec: 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));
497f0: 45ea 0050 lea %a2@(80),%a2
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
497f4: 6010 bras 49806 <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 ) )
497f6: 486b 000c pea %a3@(12)
497fa: 2f02 movel %d2,%sp@-
497fc: 4e94 jsr %a4@
497fe: 508f addql #8,%sp
49800: 4a80 tstl %d0
49802: 670a beqs 4980e <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 ) {
49804: 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 );
49806: b5cb cmpal %a3,%a2
49808: 66ec bnes 497f6 <IMFS_find_match_in_dir+0x46>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
4980a: 95ca subal %a2,%a2
4980c: 6002 bras 49810 <IMFS_find_match_in_dir+0x60>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
4980e: 244b moveal %a3,%a2
return the_jnode;
}
return 0;
}
49810: 200a movel %a2,%d0
49812: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
49818: 4e5e unlk %fp <== NOT EXECUTED
0004970c <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
)
{
4970c: 4e56 ffd8 linkw %fp,#-40
49710: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@
49714: 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;
49718: 240e movel %fp,%d2
4971a: 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 );
49720: 49f9 0004 9014 lea 49014 <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;
49726: 246b 001c moveal %a3@(28),%a2
loc = temp_mt_entry->mt_fs_root;
4972a: 4878 0014 pea 14 <OPER2>
4972e: 486b 001c pea %a3@(28)
49732: 2f02 movel %d2,%sp@-
49734: 4eb9 0004 c854 jsr 4c854 <memcpy>
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
4973a: 4fef 000c lea %sp@(12),%sp
4973e: 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 );
49742: 47f9 0004 24e8 lea 424e8 <IMFS_unlink>,%a3
49748: 6002 bras 4974c <IMFS_fsunmount+0x40>
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
4974a: 2440 moveal %d0,%a2
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
4974c: 262a 0008 movel %a2@(8),%d3
loc.node_access = (void *)jnode;
49750: 2d4a ffec movel %a2,%fp@(-20)
IMFS_Set_handlers( &loc );
49754: 2f02 movel %d2,%sp@-
49756: 4e94 jsr %a4@
if ( jnode->type != IMFS_DIRECTORY ) {
49758: 588f addql #4,%sp
4975a: 7001 moveq #1,%d0
4975c: b0aa 0048 cmpl %a2@(72),%d0
49760: 660e bnes 49770 <IMFS_fsunmount+0x64>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
49762: 200a movel %a2,%d0
49764: 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 ) ) {
4976a: b0aa 004c cmpl %a2@(76),%d0
4976e: 660e bnes 4977e <IMFS_fsunmount+0x72>
result = IMFS_unlink( NULL, &loc );
49770: 2f02 movel %d2,%sp@-
49772: 42a7 clrl %sp@-
49774: 4e93 jsr %a3@
if (result != 0)
49776: 508f addql #8,%sp
49778: 4a80 tstl %d0
4977a: 6624 bnes 497a0 <IMFS_fsunmount+0x94> <== NEVER TAKEN
return -1;
jnode = next;
4977c: 2443 moveal %d3,%a2
}
if ( jnode != NULL ) {
4977e: 4a8a tstl %a2
49780: 6722 beqs 497a4 <IMFS_fsunmount+0x98>
if ( jnode->type == IMFS_DIRECTORY ) {
49782: 7001 moveq #1,%d0
49784: b0aa 0048 cmpl %a2@(72),%d0
49788: 66c2 bnes 4974c <IMFS_fsunmount+0x40> <== NEVER TAKEN
4978a: 220a movel %a2,%d1
4978c: 0681 0000 0050 addil #80,%d1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
49792: 202a 004c movel %a2@(76),%d0
if ( jnode_has_children( jnode ) )
49796: b280 cmpl %d0,%d1
49798: 67b2 beqs 4974c <IMFS_fsunmount+0x40>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
4979a: 4a80 tstl %d0
4979c: 66ac bnes 4974a <IMFS_fsunmount+0x3e> <== ALWAYS TAKEN
4979e: 6006 bras 497a6 <IMFS_fsunmount+0x9a> <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
497a0: 70ff moveq #-1,%d0 <== NOT EXECUTED
497a2: 6002 bras 497a6 <IMFS_fsunmount+0x9a> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
497a4: 4280 clrl %d0
}
497a6: 4cee 1c0c ffd8 moveml %fp@(-40),%d2-%d3/%a2-%a4
497ac: 4e5e unlk %fp <== NOT EXECUTED
0004981c <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
4981c: 4e56 ffe4 linkw %fp,#-28
49820: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
49824: 2a6e 0008 moveal %fp@(8),%a5
register int i = 0;
49828: 4282 clrl %d2
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
4982a: 283c 0004 38a4 movel #276644,%d4
const char *path,
int pathlen,
char *token,
int *token_len
)
{
49830: 246e 0010 moveal %fp@(16),%a2
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
49834: 284a moveal %a2,%a4
const char *path,
int pathlen,
char *token,
int *token_len
)
{
49836: 266e 000c moveal %fp@(12),%a3
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
4983a: 1615 moveb %a5@,%d3
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
4983c: 600e bras 4984c <IMFS_get_token+0x30>
token[i] = c;
if ( i == IMFS_NAME_MAX )
4983e: 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;
49840: 18c3 moveb %d3,%a4@+
if ( i == IMFS_NAME_MAX )
49842: b082 cmpl %d2,%d0
49844: 6776 beqs 498bc <IMFS_get_token+0xa0>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
49846: 5282 addql #1,%d2
49848: 1635 2800 moveb %a5@(00000000,%d2:l),%d3
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
4984c: 2044 moveal %d4,%a0
4984e: 1003 moveb %d3,%d0
49850: 49c0 extbl %d0
49852: 2f00 movel %d0,%sp@-
49854: 4e90 jsr %a0@
49856: 588f addql #4,%sp
49858: 4a80 tstl %d0
4985a: 6604 bnes 49860 <IMFS_get_token+0x44>
4985c: b7c2 cmpal %d2,%a3
4985e: 6ede bgts 4983e <IMFS_get_token+0x22>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
49860: 4a82 tstl %d2
49862: 660a bnes 4986e <IMFS_get_token+0x52>
token[i] = c;
49864: 1483 moveb %d3,%a2@
if ( (token[i] != '\0') && pathlen ) {
49866: 6714 beqs 4987c <IMFS_get_token+0x60>
49868: 4a8b tstl %a3
4986a: 6614 bnes 49880 <IMFS_get_token+0x64>
4986c: 600e bras 4987c <IMFS_get_token+0x60>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
4986e: 4a32 28ff tstb %a2@(ffffffff,%d2:l)
49872: 6712 beqs 49886 <IMFS_get_token+0x6a> <== NEVER TAKEN
token[i] = '\0';
49874: 4200 clrb %d0
49876: 1580 2800 moveb %d0,%a2@(00000000,%d2:l)
4987a: 600a bras 49886 <IMFS_get_token+0x6a>
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
4987c: 4283 clrl %d3
4987e: 6008 bras 49888 <IMFS_get_token+0x6c>
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
49880: 7601 moveq #1,%d3
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
49882: 7401 moveq #1,%d2
49884: 6002 bras 49888 <IMFS_get_token+0x6c>
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
49886: 7603 moveq #3,%d3
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
49888: 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 ) {
4988c: 7003 moveq #3,%d0
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
4988e: 2082 movel %d2,%a0@
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
49890: b083 cmpl %d3,%d0
49892: 6632 bnes 498c6 <IMFS_get_token+0xaa>
if ( strcmp( token, "..") == 0 )
49894: 4879 0005 b40b pea 5b40b <dotdotname+0x3>
4989a: 47f9 0004 cdec lea 4cdec <strcmp>,%a3
498a0: 2f0a movel %a2,%sp@-
498a2: 4e93 jsr %a3@
498a4: 508f addql #8,%sp
498a6: 4a80 tstl %d0
498a8: 6716 beqs 498c0 <IMFS_get_token+0xa4>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
498aa: 4879 0005 b40c pea 5b40c <dotdotname+0x4>
498b0: 2f0a movel %a2,%sp@-
498b2: 4e93 jsr %a3@
498b4: 508f addql #8,%sp
498b6: 4a80 tstl %d0
498b8: 670a beqs 498c4 <IMFS_get_token+0xa8>
498ba: 600a bras 498c6 <IMFS_get_token+0xaa>
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
return IMFS_INVALID_TOKEN;
498bc: 7604 moveq #4,%d3
498be: 6006 bras 498c6 <IMFS_get_token+0xaa>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
498c0: 7602 moveq #2,%d3
498c2: 6002 bras 498c6 <IMFS_get_token+0xaa>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
498c4: 7601 moveq #1,%d3
}
return type;
}
498c6: 2003 movel %d3,%d0
498c8: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
498ce: 4e5e unlk %fp
...
000420fc <IMFS_initialize_support>:
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
420fc: 307c 0006 moveaw #6,%a0
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
42100: 7210 moveq #16,%d1
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
42102: 4e56 fff4 linkw %fp,#-12
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
42106: 2039 0005 bfee movel 5bfee <imfs_rq_memfile_bytes_per_block>,%d0
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
4210c: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
42110: 246e 0008 moveal %fp@(8),%a2
42114: 242e 0014 movel %fp@(20),%d2
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
42118: b081 cmpl %d1,%d0
4211a: 6710 beqs 4212c <IMFS_initialize_support+0x30>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
4211c: 6d08 blts 42126 <IMFS_initialize_support+0x2a>
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
4211e: 5388 subql #1,%a0
42120: d281 addl %d1,%d1
42122: 4a88 tstl %a0
42124: 66f2 bnes 42118 <IMFS_initialize_support+0x1c> <== ALWAYS TAKEN
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
42126: 203c 0000 0080 movel #128,%d0
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
4212c: 23c0 0005 ced8 movel %d0,5ced8 <imfs_memfile_bytes_per_block>
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
42132: 4eb9 0004 8f8c jsr 48f8c <IMFS_create_root_node>
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
42138: 256e 000c 0028 movel %fp@(12),%a2@(40)
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
4213e: 2640 moveal %d0,%a3
42140: 2540 001c movel %d0,%a2@(28)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
42144: 2542 0024 movel %d2,%a2@(36)
temp_mt_entry->mt_fs_root.ops = op_table;
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
42148: 4878 0030 pea 30 <OPER2+0x1c>
4214c: 4879 0005 b3d6 pea 5b3d6 <IMFS_LIMITS_AND_OPTIONS>
42152: 486a 0038 pea %a2@(56)
42156: 4eb9 0004 c854 jsr 4c854 <memcpy>
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
4215c: 4878 0014 pea 14 <OPER2>
42160: 4878 0001 pea 1 <ADD>
42164: 4eb9 0004 27cc jsr 427cc <calloc>
if ( !fs_info ) {
4216a: 4fef 0014 lea %sp@(20),%sp
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
4216e: 2040 moveal %d0,%a0
if ( !fs_info ) {
42170: 4a80 tstl %d0
42172: 661a bnes 4218e <IMFS_initialize_support+0x92>
free(temp_mt_entry->mt_fs_root.node_access);
42174: 2f0b movel %a3,%sp@-
42176: 4eb9 0004 2b68 jsr 42b68 <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
4217c: 4eb9 0004 c034 jsr 4c034 <__errno>
42182: 588f addql #4,%sp
42184: 2040 moveal %d0,%a0
42186: 700c moveq #12,%d0
42188: 2080 movel %d0,%a0@
4218a: 70ff moveq #-1,%d0
4218c: 6030 bras 421be <IMFS_initialize_support+0xc2>
}
temp_mt_entry->fs_info = fs_info;
4218e: 2540 0034 movel %d0,%a2@(52)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
42192: 2039 0005 cedc movel 5cedc <imfs_instance.5953>,%d0
42198: 2080 movel %d0,%a0@
4219a: 5280 addql #1,%d0
4219c: 23c0 0005 cedc movel %d0,5cedc <imfs_instance.5953>
fs_info->ino_count = 1;
421a2: 7001 moveq #1,%d0
fs_info->memfile_handlers = memfile_handlers;
421a4: 216e 0010 0008 movel %fp@(16),%a0@(8)
fs_info->directory_handlers = directory_handlers;
fs_info->fifo_handlers = fifo_handlers;
421aa: 216e 0018 0010 movel %fp@(24),%a0@(16)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
421b0: 2140 0004 movel %d0,%a0@(4)
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
421b4: 2142 000c movel %d2,%a0@(12)
fs_info->fifo_handlers = fifo_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
421b8: 2740 0034 movel %d0,%a3@(52)
return 0;
421bc: 4200 clrb %d0
}
421be: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
421c4: 4e5e unlk %fp <== NOT EXECUTED
0004ad94 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4ad94: 4e56 fff0 linkw %fp,#-16
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
4ad98: 2039 0005 ced8 movel 5ced8 <imfs_memfile_bytes_per_block>,%d0
4ad9e: e488 lsrl #2,%d0
4ada0: 2200 movel %d0,%d1
4ada2: 5381 subql #1,%d1
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4ada4: 48d7 041c moveml %d2-%d4/%a2,%sp@
4ada8: 246e 0008 moveal %fp@(8),%a2
4adac: 242e 000c movel %fp@(12),%d2
4adb0: 206e 0010 moveal %fp@(16),%a0
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
4adb4: b282 cmpl %d2,%d1
4adb6: 6536 bcss 4adee <IMFS_memfile_get_block_pointer+0x5a>
p = info->indirect;
4adb8: 226a 0054 moveal %a2@(84),%a1
if ( malloc_it ) {
4adbc: 4a88 tstl %a0
4adbe: 6720 beqs 4ade0 <IMFS_memfile_get_block_pointer+0x4c>
if ( !p ) {
4adc0: 4a89 tstl %a1
4adc2: 6610 bnes 4add4 <IMFS_memfile_get_block_pointer+0x40>
p = memfile_alloc_block();
4adc4: 4eb9 0004 ad70 jsr 4ad70 <memfile_alloc_block>
if ( !p )
4adca: 4a80 tstl %d0
4adcc: 6700 00f8 beqw 4aec6 <IMFS_memfile_get_block_pointer+0x132>
return 0;
info->indirect = p;
4add0: 2540 0054 movel %d0,%a2@(84)
}
return &info->indirect[ my_block ];
4add4: 206a 0054 moveal %a2@(84),%a0
4add8: e58a lsll #2,%d2
4adda: d1c2 addal %d2,%a0
4addc: 6000 00ea braw 4aec8 <IMFS_memfile_get_block_pointer+0x134>
}
if ( !p )
4ade0: 4a89 tstl %a1
4ade2: 6700 00e2 beqw 4aec6 <IMFS_memfile_get_block_pointer+0x132>
return 0;
return &info->indirect[ my_block ];
4ade6: 41f1 2c00 lea %a1@(00000000,%d2:l:4),%a0
4adea: 6000 00dc braw 4aec8 <IMFS_memfile_get_block_pointer+0x134>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
4adee: 2200 movel %d0,%d1
4adf0: 5281 addql #1,%d1
4adf2: 4c00 1800 mulsl %d0,%d1
4adf6: 2241 moveal %d1,%a1
4adf8: 5389 subql #1,%a1
4adfa: b3c2 cmpal %d2,%a1
4adfc: 653e bcss 4ae3c <IMFS_memfile_get_block_pointer+0xa8>
my_block -= FIRST_DOUBLY_INDIRECT;
4adfe: 9480 subl %d0,%d2
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4ae00: 4c40 2003 remul %d0,%d3,%d2
4ae04: 4c40 2002 remul %d0,%d2,%d2
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
4ae08: 202a 0058 movel %a2@(88),%d0
if ( malloc_it ) {
4ae0c: 4a88 tstl %a0
4ae0e: 671c beqs 4ae2c <IMFS_memfile_get_block_pointer+0x98>
if ( !p ) {
4ae10: 4a80 tstl %d0
4ae12: 6610 bnes 4ae24 <IMFS_memfile_get_block_pointer+0x90>
p = memfile_alloc_block();
4ae14: 4eb9 0004 ad70 jsr 4ad70 <memfile_alloc_block>
if ( !p )
4ae1a: 4a80 tstl %d0
4ae1c: 6700 00a8 beqw 4aec6 <IMFS_memfile_get_block_pointer+0x132>
return 0;
info->doubly_indirect = p;
4ae20: 2540 0058 movel %d0,%a2@(88)
}
p1 = (block_p *)p[ doubly ];
4ae24: 2040 moveal %d0,%a0
4ae26: 45f0 2c00 lea %a0@(00000000,%d2:l:4),%a2
4ae2a: 6066 bras 4ae92 <IMFS_memfile_get_block_pointer+0xfe>
}
return (block_p *)&p1[ singly ];
}
if ( !p )
4ae2c: 4a80 tstl %d0
4ae2e: 6700 0096 beqw 4aec6 <IMFS_memfile_get_block_pointer+0x132>
return 0;
p = (block_p *)p[ doubly ];
4ae32: 2240 moveal %d0,%a1
4ae34: 2071 2c00 moveal %a1@(00000000,%d2:l:4),%a0
4ae38: 6000 0082 braw 4aebc <IMFS_memfile_get_block_pointer+0x128>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
4ae3c: 2601 movel %d1,%d3
4ae3e: 5283 addql #1,%d3
4ae40: 4c00 3800 mulsl %d0,%d3
4ae44: 5383 subql #1,%d3
4ae46: b682 cmpl %d2,%d3
4ae48: 657c bcss 4aec6 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
4ae4a: 9481 subl %d1,%d2
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4ae4c: 4c40 2003 remul %d0,%d3,%d2
4ae50: 4c40 2002 remul %d0,%d2,%d2
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
4ae54: 4c40 2004 remul %d0,%d4,%d2
4ae58: 4c40 2002 remul %d0,%d2,%d2
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
4ae5c: 202a 005c movel %a2@(92),%d0
if ( malloc_it ) {
4ae60: 4a88 tstl %a0
4ae62: 6746 beqs 4aeaa <IMFS_memfile_get_block_pointer+0x116>
if ( !p ) {
4ae64: 4a80 tstl %d0
4ae66: 660e bnes 4ae76 <IMFS_memfile_get_block_pointer+0xe2>
p = memfile_alloc_block();
4ae68: 4eb9 0004 ad70 jsr 4ad70 <memfile_alloc_block>
if ( !p )
4ae6e: 4a80 tstl %d0
4ae70: 6754 beqs 4aec6 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->triply_indirect = p;
4ae72: 2540 005c movel %d0,%a2@(92)
}
p1 = (block_p *) p[ triply ];
4ae76: 2040 moveal %d0,%a0
4ae78: 45f0 2c00 lea %a0@(00000000,%d2:l:4),%a2
4ae7c: 2012 movel %a2@,%d0
if ( !p1 ) {
4ae7e: 660c bnes 4ae8c <IMFS_memfile_get_block_pointer+0xf8>
p1 = memfile_alloc_block();
4ae80: 4eb9 0004 ad70 jsr 4ad70 <memfile_alloc_block>
if ( !p1 )
4ae86: 4a80 tstl %d0
4ae88: 673c beqs 4aec6 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
4ae8a: 2480 movel %d0,%a2@
}
p2 = (block_p *)p1[ doubly ];
4ae8c: 2240 moveal %d0,%a1
4ae8e: 45f1 4c00 lea %a1@(00000000,%d4:l:4),%a2
4ae92: 2012 movel %a2@,%d0
if ( !p2 ) {
4ae94: 660c bnes 4aea2 <IMFS_memfile_get_block_pointer+0x10e>
p2 = memfile_alloc_block();
4ae96: 4eb9 0004 ad70 jsr 4ad70 <memfile_alloc_block>
if ( !p2 )
4ae9c: 4a80 tstl %d0
4ae9e: 6726 beqs 4aec6 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
4aea0: 2480 movel %d0,%a2@
}
return (block_p *)&p2[ singly ];
4aea2: 2240 moveal %d0,%a1
4aea4: 41f1 3c00 lea %a1@(00000000,%d3:l:4),%a0
4aea8: 601e bras 4aec8 <IMFS_memfile_get_block_pointer+0x134>
}
if ( !p )
4aeaa: 4a80 tstl %d0
4aeac: 6718 beqs 4aec6 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
4aeae: 2240 moveal %d0,%a1
4aeb0: 2071 2c00 moveal %a1@(00000000,%d2:l:4),%a0
if ( !p1 )
4aeb4: 4a88 tstl %a0
4aeb6: 670e beqs 4aec6 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
4aeb8: 2070 4c00 moveal %a0@(00000000,%d4:l:4),%a0
if ( !p2 )
4aebc: 4a88 tstl %a0
4aebe: 6706 beqs 4aec6 <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
4aec0: 41f0 3c00 lea %a0@(00000000,%d3:l:4),%a0
4aec4: 6002 bras 4aec8 <IMFS_memfile_get_block_pointer+0x134>
}
return &info->indirect[ my_block ];
}
if ( !p )
return 0;
4aec6: 91c8 subal %a0,%a0 <== NOT EXECUTED
/*
* This means the requested block number is out of range.
*/
return 0;
}
4aec8: 2008 movel %a0,%d0
4aeca: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4aed0: 4e5e unlk %fp <== NOT EXECUTED
0004aed4 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4aed4: 4e56 ffc8 linkw %fp,#-56
4aed8: 206e 0018 moveal %fp@(24),%a0
4aedc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4aee0: 246e 0008 moveal %fp@(8),%a2
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
4aee4: 7406 moveq #6,%d2
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4aee6: 2a2e 0014 movel %fp@(20),%d5
4aeea: 286e 000c moveal %fp@(12),%a4
4aeee: 2a6e 0010 moveal %fp@(16),%a5
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
4aef2: b4aa 0048 cmpl %a2@(72),%d2
4aef6: 665c bnes 4af54 <IMFS_memfile_read+0x80>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
4aef8: 97cb subal %a3,%a3
4aefa: 242a 004c movel %a2@(76),%d2
4aefe: 262a 0050 movel %a2@(80),%d3
4af02: 2d48 fff4 movel %a0,%fp@(-12)
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
4af06: 226a 0054 moveal %a2@(84),%a1
if (my_length > (the_jnode->info.linearfile.size - start))
4af0a: 2002 movel %d2,%d0
4af0c: 2203 movel %d3,%d1
4af0e: 2d4b fff0 movel %a3,%fp@(-16)
4af12: 280c movel %a4,%d4
4af14: 928d subl %a5,%d1
4af16: 9184 subxl %d4,%d0
4af18: 2c2e fff0 movel %fp@(-16),%d6
4af1c: 2e2e fff4 movel %fp@(-12),%d7
4af20: 9e81 subl %d1,%d7
4af22: 9d80 subxl %d0,%d6
4af24: 6f04 bles 4af2a <IMFS_memfile_read+0x56> <== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
4af26: 968d subl %a5,%d3
4af28: 6002 bras 4af2c <IMFS_memfile_read+0x58>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
4af2a: 2608 movel %a0,%d3 <== NOT EXECUTED
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
4af2c: 2f03 movel %d3,%sp@-
4af2e: 4871 d800 pea %a1@(00000000,%a5:l)
4af32: 2f05 movel %d5,%sp@-
4af34: 4eb9 0004 c854 jsr 4c854 <memcpy>
IMFS_update_atime( the_jnode );
4af3a: 42a7 clrl %sp@-
4af3c: 486e fff8 pea %fp@(-8)
4af40: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4af46: 256e fff8 003c movel %fp@(-8),%a2@(60)
return my_length;
4af4c: 4fef 0014 lea %sp@(20),%sp
4af50: 6000 0122 braw 4b074 <IMFS_memfile_read+0x1a0>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
4af54: 2808 movel %a0,%d4
4af56: d88d addl %a5,%d4
if ( last_byte > the_jnode->info.file.size )
4af58: 2204 movel %d4,%d1
4af5a: 4280 clrl %d0
4af5c: 242a 004c movel %a2@(76),%d2
4af60: 262a 0050 movel %a2@(80),%d3
4af64: 2c00 movel %d0,%d6
4af66: 2e01 movel %d1,%d7
4af68: 9e83 subl %d3,%d7
4af6a: 9d82 subxl %d2,%d6
4af6c: 6f06 bles 4af74 <IMFS_memfile_read+0xa0>
my_length = the_jnode->info.file.size - start;
4af6e: 2403 movel %d3,%d2
4af70: 948d subl %a5,%d2
4af72: 6002 bras 4af76 <IMFS_memfile_read+0xa2>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
4af74: 2408 movel %a0,%d2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4af76: 2639 0005 ced8 movel 5ced8 <imfs_memfile_bytes_per_block>,%d3
4af7c: 2e03 movel %d3,%d7
4af7e: 5bc6 smi %d6
4af80: 49c6 extbl %d6
4af82: 2f07 movel %d7,%sp@-
4af84: 2f06 movel %d6,%sp@-
4af86: 2f0d movel %a5,%sp@-
4af88: 2f0c movel %a4,%sp@-
4af8a: 4eb9 0005 8a10 jsr 58a10 <__moddi3>
4af90: 4fef 0010 lea %sp@(16),%sp
4af94: 2801 movel %d1,%d4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4af96: 2f07 movel %d7,%sp@-
4af98: 2f06 movel %d6,%sp@-
4af9a: 2f0d movel %a5,%sp@-
4af9c: 2f0c movel %a4,%sp@-
4af9e: 4eb9 0005 85c8 jsr 585c8 <__divdi3>
4afa4: 4fef 0010 lea %sp@(16),%sp
4afa8: 2c01 movel %d1,%d6
if ( start_offset ) {
4afaa: 4a84 tstl %d4
4afac: 673e beqs 4afec <IMFS_memfile_read+0x118>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4afae: 42a7 clrl %sp@-
4afb0: 2f01 movel %d1,%sp@-
4afb2: 2f0a movel %a2,%sp@-
4afb4: 4eb9 0004 ad94 jsr 4ad94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4afba: 4fef 000c lea %sp@(12),%sp
4afbe: 4a80 tstl %d0
4afc0: 6700 00b0 beqw 4b072 <IMFS_memfile_read+0x19e>
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4afc4: 2203 movel %d3,%d1
4afc6: 9284 subl %d4,%d1
4afc8: 2602 movel %d2,%d3
4afca: b282 cmpl %d2,%d1
4afcc: 6402 bccs 4afd0 <IMFS_memfile_read+0xfc>
4afce: 2601 movel %d1,%d3
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4afd0: 2f03 movel %d3,%sp@-
4afd2: 2040 moveal %d0,%a0
4afd4: d890 addl %a0@,%d4
dest += to_copy;
block++;
4afd6: 5286 addql #1,%d6
my_length -= to_copy;
4afd8: 9483 subl %d3,%d2
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4afda: 2f04 movel %d4,%sp@-
4afdc: 2f05 movel %d5,%sp@-
dest += to_copy;
4afde: da83 addl %d3,%d5
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4afe0: 4eb9 0004 c854 jsr 4c854 <memcpy>
dest += to_copy;
block++;
my_length -= to_copy;
4afe6: 4fef 000c lea %sp@(12),%sp
4afea: 6002 bras 4afee <IMFS_memfile_read+0x11a>
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
4afec: 4283 clrl %d3
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4afee: 2839 0005 ced8 movel 5ced8 <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 );
4aff4: 47f9 0004 ad94 lea 4ad94 <IMFS_memfile_get_block_pointer>,%a3
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4affa: 49f9 0004 c854 lea 4c854 <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 ) {
4b000: 6026 bras 4b028 <IMFS_memfile_read+0x154>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b002: 42a7 clrl %sp@-
4b004: 2f06 movel %d6,%sp@-
4b006: 2f0a movel %a2,%sp@-
4b008: 4e93 jsr %a3@
if ( !block_ptr )
4b00a: 4fef 000c lea %sp@(12),%sp
4b00e: 4a80 tstl %d0
4b010: 6762 beqs 4b074 <IMFS_memfile_read+0x1a0> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b012: 2040 moveal %d0,%a0
dest += to_copy;
block++;
4b014: 5286 addql #1,%d6
my_length -= to_copy;
4b016: 9484 subl %d4,%d2
copied += to_copy;
4b018: d684 addl %d4,%d3
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b01a: 2f04 movel %d4,%sp@-
4b01c: 2f10 movel %a0@,%sp@-
4b01e: 2f05 movel %d5,%sp@-
dest += to_copy;
4b020: da84 addl %d4,%d5
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4b022: 4e94 jsr %a4@
dest += to_copy;
block++;
my_length -= to_copy;
copied += to_copy;
4b024: 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 ) {
4b028: b4b9 0005 ced8 cmpl 5ced8 <imfs_memfile_bytes_per_block>,%d2
4b02e: 64d2 bccs 4b002 <IMFS_memfile_read+0x12e>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
4b030: 4a82 tstl %d2
4b032: 6728 beqs 4b05c <IMFS_memfile_read+0x188>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b034: 42a7 clrl %sp@-
4b036: 2f06 movel %d6,%sp@-
4b038: 2f0a movel %a2,%sp@-
4b03a: 4eb9 0004 ad94 jsr 4ad94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4b040: 4fef 000c lea %sp@(12),%sp
4b044: 4a80 tstl %d0
4b046: 672c beqs 4b074 <IMFS_memfile_read+0x1a0> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4b048: 2640 moveal %d0,%a3
copied += my_length;
4b04a: d682 addl %d2,%d3
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4b04c: 2f02 movel %d2,%sp@-
4b04e: 2f13 movel %a3@,%sp@-
4b050: 2f05 movel %d5,%sp@-
4b052: 4eb9 0004 c854 jsr 4c854 <memcpy>
copied += my_length;
4b058: 4fef 000c lea %sp@(12),%sp
}
IMFS_update_atime( the_jnode );
4b05c: 42a7 clrl %sp@-
4b05e: 486e fff8 pea %fp@(-8)
4b062: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4b068: 256e fff8 003c movel %fp@(-8),%a2@(60)
return copied;
4b06e: 508f addql #8,%sp
4b070: 6002 bras 4b074 <IMFS_memfile_read+0x1a0>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
4b072: 4283 clrl %d3 <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
4b074: 2003 movel %d3,%d0
4b076: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4b07c: 4e5e unlk %fp <== NOT EXECUTED
0004b142 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4b142: 4e56 ffe4 linkw %fp,#-28
4b146: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
4b14a: 2439 0005 ced8 movel 5ced8 <imfs_memfile_bytes_per_block>,%d2
4b150: e48a lsrl #2,%d2
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4b152: 246e 0008 moveal %fp@(8),%a2
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4b156: 4aaa 0054 tstl %a2@(84)
4b15a: 670e beqs 4b16a <IMFS_memfile_remove+0x28>
memfile_free_blocks_in_table( &info->indirect, to_free );
4b15c: 2f02 movel %d2,%sp@-
4b15e: 486a 0054 pea %a2@(84)
4b162: 4eb9 0004 b0fc jsr 4b0fc <memfile_free_blocks_in_table>
4b168: 508f addql #8,%sp
}
if ( info->doubly_indirect ) {
4b16a: 4aaa 0058 tstl %a2@(88)
4b16e: 661c bnes 4b18c <IMFS_memfile_remove+0x4a>
4b170: 603c bras 4b1ae <IMFS_memfile_remove+0x6c>
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
4b172: 2003 movel %d3,%d0
4b174: e588 lsll #2,%d0
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
4b176: 206a 0058 moveal %a2@(88),%a0
4b17a: d1c0 addal %d0,%a0
4b17c: 4a90 tstl %a0@
4b17e: 6708 beqs 4b188 <IMFS_memfile_remove+0x46> <== NEVER TAKEN
memfile_free_blocks_in_table(
4b180: 2f02 movel %d2,%sp@-
4b182: 2f08 movel %a0,%sp@-
4b184: 4e93 jsr %a3@
4b186: 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++ ) {
4b188: 5283 addql #1,%d3
4b18a: 6008 bras 4b194 <IMFS_memfile_remove+0x52>
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
4b18c: 4283 clrl %d3
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
4b18e: 47f9 0004 b0fc lea 4b0fc <memfile_free_blocks_in_table>,%a3
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4b194: 2039 0005 ced8 movel 5ced8 <imfs_memfile_bytes_per_block>,%d0
4b19a: e488 lsrl #2,%d0
4b19c: b083 cmpl %d3,%d0
4b19e: 62d2 bhis 4b172 <IMFS_memfile_remove+0x30>
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
4b1a0: 2f02 movel %d2,%sp@-
4b1a2: 486a 0058 pea %a2@(88)
4b1a6: 4eb9 0004 b0fc jsr 4b0fc <memfile_free_blocks_in_table>
4b1ac: 508f addql #8,%sp
}
if ( info->triply_indirect ) {
4b1ae: 4aaa 005c tstl %a2@(92)
4b1b2: 6642 bnes 4b1f6 <IMFS_memfile_remove+0xb4>
4b1b4: 6062 bras 4b218 <IMFS_memfile_remove+0xd6>
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
4b1b6: 2c03 movel %d3,%d6
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4b1b8: 206a 005c moveal %a2@(92),%a0
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
4b1bc: e58e lsll #2,%d6
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4b1be: 2a30 6800 movel %a0@(00000000,%d6:l),%d5
if ( !p ) /* ensure we have a valid pointer */
4b1c2: 6746 beqs 4b20a <IMFS_memfile_remove+0xc8> <== NEVER TAKEN
4b1c4: 4284 clrl %d4
4b1c6: 6012 bras 4b1da <IMFS_memfile_remove+0x98>
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
4b1c8: 2045 moveal %d5,%a0
4b1ca: 5885 addql #4,%d5
4b1cc: 4a90 tstl %a0@
4b1ce: 6708 beqs 4b1d8 <IMFS_memfile_remove+0x96> <== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
4b1d0: 2f02 movel %d2,%sp@-
4b1d2: 2f08 movel %a0,%sp@-
4b1d4: 4e93 jsr %a3@
4b1d6: 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++ ) {
4b1d8: 5284 addql #1,%d4
4b1da: 2039 0005 ced8 movel 5ced8 <imfs_memfile_bytes_per_block>,%d0
4b1e0: e488 lsrl #2,%d0
4b1e2: b084 cmpl %d4,%d0
4b1e4: 62e2 bhis 4b1c8 <IMFS_memfile_remove+0x86>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
4b1e6: 2f02 movel %d2,%sp@-
4b1e8: dcaa 005c addl %a2@(92),%d6
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4b1ec: 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(
4b1ee: 2f06 movel %d6,%sp@-
4b1f0: 4e93 jsr %a3@
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4b1f2: 508f addql #8,%sp
4b1f4: 6008 bras 4b1fe <IMFS_memfile_remove+0xbc>
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
4b1f6: 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);
4b1f8: 47f9 0004 b0fc lea 4b0fc <memfile_free_blocks_in_table>,%a3
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4b1fe: 2039 0005 ced8 movel 5ced8 <imfs_memfile_bytes_per_block>,%d0
4b204: e488 lsrl #2,%d0
4b206: b083 cmpl %d3,%d0
4b208: 62ac bhis 4b1b6 <IMFS_memfile_remove+0x74>
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
4b20a: 2f02 movel %d2,%sp@-
4b20c: 486a 005c pea %a2@(92)
4b210: 4eb9 0004 b0fc jsr 4b0fc <memfile_free_blocks_in_table>
4b216: 508f addql #8,%sp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
4b218: 4280 clrl %d0
4b21a: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
4b220: 4e5e unlk %fp <== NOT EXECUTED
0004b35c <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 ) {
4b35c: 4280 clrl %d0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4b35e: 4e56 ffd0 linkw %fp,#-48
4b362: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4b366: 286e 000c moveal %fp@(12),%a4
4b36a: 2a6e 0010 moveal %fp@(16),%a5
4b36e: 246e 0008 moveal %fp@(8),%a2
4b372: 242e 0018 movel %fp@(24),%d2
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
4b376: 41f5 2800 lea %a5@(00000000,%d2:l),%a0
if ( last_byte > the_jnode->info.file.size ) {
4b37a: 2208 movel %a0,%d1
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4b37c: 262e 0014 movel %fp@(20),%d3
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
4b380: 282a 004c movel %a2@(76),%d4
4b384: 2a2a 0050 movel %a2@(80),%d5
4b388: 9a81 subl %d1,%d5
4b38a: 9980 subxl %d0,%d4
4b38c: 6c26 bges 4b3b4 <IMFS_memfile_write+0x58>
status = IMFS_memfile_extend( the_jnode, last_byte );
4b38e: 2f08 movel %a0,%sp@-
4b390: 2f00 movel %d0,%sp@-
4b392: 2f0a movel %a2,%sp@-
4b394: 4eb9 0004 b24c jsr 4b24c <IMFS_memfile_extend>
if ( status )
4b39a: 4fef 000c lea %sp@(12),%sp
4b39e: 4a80 tstl %d0
4b3a0: 6712 beqs 4b3b4 <IMFS_memfile_write+0x58>
rtems_set_errno_and_return_minus_one( ENOSPC );
4b3a2: 4eb9 0004 c034 jsr 4c034 <__errno>
4b3a8: 741c moveq #28,%d2
4b3aa: 7aff moveq #-1,%d5
4b3ac: 2040 moveal %d0,%a0
4b3ae: 2082 movel %d2,%a0@
4b3b0: 6000 0102 braw 4b4b4 <IMFS_memfile_write+0x158>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4b3b4: 2a39 0005 ced8 movel 5ced8 <imfs_memfile_bytes_per_block>,%d5
4b3ba: 2e05 movel %d5,%d7
4b3bc: 5bc6 smi %d6
4b3be: 49c6 extbl %d6
4b3c0: 2f07 movel %d7,%sp@-
4b3c2: 2f06 movel %d6,%sp@-
4b3c4: 2f0d movel %a5,%sp@-
4b3c6: 2f0c movel %a4,%sp@-
4b3c8: 4eb9 0005 8a10 jsr 58a10 <__moddi3>
4b3ce: 4fef 0010 lea %sp@(16),%sp
4b3d2: 2801 movel %d1,%d4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4b3d4: 2f07 movel %d7,%sp@-
4b3d6: 2f06 movel %d6,%sp@-
4b3d8: 2f0d movel %a5,%sp@-
4b3da: 2f0c movel %a4,%sp@-
4b3dc: 4eb9 0005 85c8 jsr 585c8 <__divdi3>
4b3e2: 4fef 0010 lea %sp@(16),%sp
4b3e6: 2c01 movel %d1,%d6
if ( start_offset ) {
4b3e8: 4a84 tstl %d4
4b3ea: 673a beqs 4b426 <IMFS_memfile_write+0xca>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b3ec: 42a7 clrl %sp@-
4b3ee: 2f01 movel %d1,%sp@-
4b3f0: 2f0a movel %a2,%sp@-
4b3f2: 4eb9 0004 ad94 jsr 4ad94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4b3f8: 4fef 000c lea %sp@(12),%sp
4b3fc: 4a80 tstl %d0
4b3fe: 6700 00b2 beqw 4b4b2 <IMFS_memfile_write+0x156>
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4b402: 9a84 subl %d4,%d5
4b404: b485 cmpl %d5,%d2
4b406: 6402 bccs 4b40a <IMFS_memfile_write+0xae>
4b408: 2a02 movel %d2,%d5
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4b40a: 2f05 movel %d5,%sp@-
4b40c: 2040 moveal %d0,%a0
src += to_copy;
block++;
4b40e: 5286 addql #1,%d6
my_length -= to_copy;
4b410: 9485 subl %d5,%d2
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4b412: 2f03 movel %d3,%sp@-
4b414: d890 addl %a0@,%d4
src += to_copy;
4b416: d685 addl %d5,%d3
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4b418: 2f04 movel %d4,%sp@-
4b41a: 4eb9 0004 c854 jsr 4c854 <memcpy>
src += to_copy;
block++;
my_length -= to_copy;
copied += to_copy;
4b420: 4fef 000c lea %sp@(12),%sp
4b424: 6002 bras 4b428 <IMFS_memfile_write+0xcc>
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
4b426: 4285 clrl %d5
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
4b428: 2839 0005 ced8 movel 5ced8 <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 );
4b42e: 47f9 0004 ad94 lea 4ad94 <IMFS_memfile_get_block_pointer>,%a3
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4b434: 49f9 0004 c854 lea 4c854 <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 ) {
4b43a: 6026 bras 4b462 <IMFS_memfile_write+0x106>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b43c: 42a7 clrl %sp@-
4b43e: 2f06 movel %d6,%sp@-
4b440: 2f0a movel %a2,%sp@-
4b442: 4e93 jsr %a3@
if ( !block_ptr )
4b444: 4fef 000c lea %sp@(12),%sp
4b448: 4a80 tstl %d0
4b44a: 6768 beqs 4b4b4 <IMFS_memfile_write+0x158> <== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4b44c: 2f04 movel %d4,%sp@-
4b44e: 2040 moveal %d0,%a0
src += to_copy;
block++;
4b450: 5286 addql #1,%d6
my_length -= to_copy;
4b452: 9484 subl %d4,%d2
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
4b454: da84 addl %d4,%d5
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4b456: 2f03 movel %d3,%sp@-
4b458: 2f10 movel %a0@,%sp@-
src += to_copy;
4b45a: d684 addl %d4,%d3
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4b45c: 4e94 jsr %a4@
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
4b45e: 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 ) {
4b462: b4b9 0005 ced8 cmpl 5ced8 <imfs_memfile_bytes_per_block>,%d2
4b468: 64d2 bccs 4b43c <IMFS_memfile_write+0xe0>
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
4b46a: 4a82 tstl %d2
4b46c: 6728 beqs 4b496 <IMFS_memfile_write+0x13a>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4b46e: 42a7 clrl %sp@-
4b470: 2f06 movel %d6,%sp@-
4b472: 2f0a movel %a2,%sp@-
4b474: 4eb9 0004 ad94 jsr 4ad94 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
4b47a: 4fef 000c lea %sp@(12),%sp
4b47e: 4a80 tstl %d0
4b480: 6732 beqs 4b4b4 <IMFS_memfile_write+0x158> <== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
4b482: 2f02 movel %d2,%sp@-
4b484: 2040 moveal %d0,%a0
my_length = 0;
copied += to_copy;
4b486: da82 addl %d2,%d5
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
4b488: 2f03 movel %d3,%sp@-
4b48a: 2f10 movel %a0@,%sp@-
4b48c: 4eb9 0004 c854 jsr 4c854 <memcpy>
my_length = 0;
copied += to_copy;
4b492: 4fef 000c lea %sp@(12),%sp
}
IMFS_mtime_ctime_update( the_jnode );
4b496: 42a7 clrl %sp@-
4b498: 486e fff8 pea %fp@(-8)
4b49c: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4b4a2: 202e fff8 movel %fp@(-8),%d0
return copied;
4b4a6: 508f addql #8,%sp
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
4b4a8: 2540 0040 movel %d0,%a2@(64)
4b4ac: 2540 0044 movel %d0,%a2@(68)
return copied;
4b4b0: 6002 bras 4b4b4 <IMFS_memfile_write+0x158>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
4b4b2: 4285 clrl %d5 <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4b4b4: 2005 movel %d5,%d0
4b4b6: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
4b4bc: 4e5e unlk %fp <== NOT EXECUTED
00042280 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
42280: 4e56 ffac linkw %fp,#-84
42284: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
42288: 246e 0008 moveal %fp@(8),%a2
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
4228c: 2f0a movel %a2,%sp@-
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
4228e: 242e 000c movel %fp@(12),%d2
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
42292: 4eb9 0004 d3a0 jsr 4d3a0 <strlen>
42298: 588f addql #4,%sp
4229a: 486e fffc pea %fp@(-4)
4229e: 486e ffbf pea %fp@(-65)
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
422a2: 262e 0010 movel %fp@(16),%d3
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
422a6: 2f00 movel %d0,%sp@-
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
422a8: 266e 0014 moveal %fp@(20),%a3
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
422ac: 2f0a movel %a2,%sp@-
422ae: 4eb9 0004 981c jsr 4981c <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
422b4: 4fef 0010 lea %sp@(16),%sp
422b8: 2002 movel %d2,%d0
422ba: 0280 0000 f000 andil #61440,%d0
422c0: 0c80 0000 4000 cmpil #16384,%d0
422c6: 6730 beqs 422f8 <IMFS_mknod+0x78>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
422c8: 0c80 0000 8000 cmpil #32768,%d0
422ce: 672c beqs 422fc <IMFS_mknod+0x7c>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
422d0: 0c80 0000 6000 cmpil #24576,%d0
422d6: 6708 beqs 422e0 <IMFS_mknod+0x60>
422d8: 0c80 0000 2000 cmpil #8192,%d0
422de: 660c bnes 422ec <IMFS_mknod+0x6c>
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
422e0: 2d43 ffe0 movel %d3,%fp@(-32)
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
422e4: 7002 moveq #2,%d0
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
422e6: 2d4b ffe4 movel %a3,%fp@(-28)
422ea: 6016 bras 42302 <IMFS_mknod+0x82>
} else if (S_ISFIFO(mode))
422ec: 0c80 0000 1000 cmpil #4096,%d0
422f2: 670c beqs 42300 <IMFS_mknod+0x80> <== ALWAYS TAKEN
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
IMFS_token_types type = 0;
422f4: 4280 clrl %d0 <== NOT EXECUTED
422f6: 600a bras 42302 <IMFS_mknod+0x82> <== NOT EXECUTED
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
422f8: 7001 moveq #1,%d0
422fa: 6006 bras 42302 <IMFS_mknod+0x82>
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
422fc: 7005 moveq #5,%d0
422fe: 6002 bras 42302 <IMFS_mknod+0x82>
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
} else if (S_ISFIFO(mode))
type = IMFS_FIFO;
42300: 7007 moveq #7,%d0
* was ONLY passed a NULL when we created the root node. We
* added a new IMFS_create_root_node() so this path no longer
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
42302: 486e ffe0 pea %fp@(-32)
42306: 2f02 movel %d2,%sp@-
42308: 486e ffbf pea %fp@(-65)
4230c: 2f00 movel %d0,%sp@-
4230e: 2f2e 0018 movel %fp@(24),%sp@-
42312: 4eb9 0004 8e78 jsr 48e78 <IMFS_create_node>
if ( !new_node )
42318: 4fef 0014 lea %sp@(20),%sp
* was ONLY passed a NULL when we created the root node. We
* added a new IMFS_create_root_node() so this path no longer
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
4231c: 2440 moveal %d0,%a2
if ( !new_node )
4231e: 4a80 tstl %d0
42320: 6610 bnes 42332 <IMFS_mknod+0xb2>
rtems_set_errno_and_return_minus_one( ENOMEM );
42322: 4eb9 0004 c034 jsr 4c034 <__errno>
42328: 2040 moveal %d0,%a0
4232a: 700c moveq #12,%d0
4232c: 2080 movel %d0,%a0@
4232e: 70ff moveq #-1,%d0
42330: 6034 bras 42366 <IMFS_mknod+0xe6>
IMFS_update_ctime(new_node->Parent);
42332: 42a7 clrl %sp@-
42334: 240e movel %fp,%d2
42336: 0682 ffff fff4 addil #-12,%d2
4233c: 47f9 0004 2bf0 lea 42bf0 <gettimeofday>,%a3
42342: 2f02 movel %d2,%sp@-
42344: 4e93 jsr %a3@
42346: 206a 0008 moveal %a2@(8),%a0
4234a: 216e fff4 0044 movel %fp@(-12),%a0@(68)
IMFS_update_mtime(new_node->Parent);
42350: 42a7 clrl %sp@-
42352: 2f02 movel %d2,%sp@-
42354: 4e93 jsr %a3@
42356: 206a 0008 moveal %a2@(8),%a0
return 0;
4235a: 4fef 0010 lea %sp@(16),%sp
4235e: 4280 clrl %d0
new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
IMFS_update_ctime(new_node->Parent);
IMFS_update_mtime(new_node->Parent);
42360: 216e fff4 0040 movel %fp@(-12),%a0@(64)
return 0;
}
42366: 4cee 0c0c ffac moveml %fp@(-84),%d2-%d3/%a2-%a3
4236c: 4e5e unlk %fp <== NOT EXECUTED
00042370 <IMFS_mount>:
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
42370: 7001 moveq #1,%d0
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
42372: 4e56 0000 linkw %fp,#0
42376: 226e 0008 moveal %fp@(8),%a1
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
4237a: 2069 0008 moveal %a1@(8),%a0
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
4237e: b0a8 0048 cmpl %a0@(72),%d0
42382: 6710 beqs 42394 <IMFS_mount+0x24> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
42384: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
4238a: 2040 moveal %d0,%a0 <== NOT EXECUTED
4238c: 7014 moveq #20,%d0 <== NOT EXECUTED
4238e: 2080 movel %d0,%a0@ <== NOT EXECUTED
42390: 70ff moveq #-1,%d0 <== NOT EXECUTED
42392: 6006 bras 4239a <IMFS_mount+0x2a> <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
42394: 2149 0058 movel %a1,%a0@(88)
return 0;
42398: 4280 clrl %d0
}
4239a: 4e5e unlk %fp
...
00044998 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
44998: 4e56 0000 linkw %fp,#0
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4499c: 2079 0006 1c64 moveal 61c64 <_impure_ptr>,%a0
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
449a2: 2f0a movel %a2,%sp@-
449a4: 246e 0008 moveal %fp@(8),%a2
449a8: 2f02 movel %d2,%sp@-
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
449aa: 2f28 0008 movel %a0@(8),%sp@-
switch( the_jnode->type ) {
449ae: 7406 moveq #6,%d2
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
449b0: 486a 000c pea %a2@(12)
449b4: 4eb9 0005 029c jsr 5029c <fputs>
switch( the_jnode->type ) {
449ba: 202a 0048 movel %a2@(72),%d0
449be: 2200 movel %d0,%d1
449c0: 508f addql #8,%sp
449c2: 5381 subql #1,%d1
449c4: 2079 0006 1c64 moveal 61c64 <_impure_ptr>,%a0
449ca: b481 cmpl %d1,%d2
449cc: 6500 0096 bcsw 44a64 <IMFS_print_jnode+0xcc>
449d0: 303b 1a08 movew %pc@(449da <IMFS_print_jnode+0x42>,%d1:l:2),%d0
449d4: 48c0 extl %d0
449d6: 4efb 0802 jmp %pc@(449da <IMFS_print_jnode+0x42>,%d0:l)
449da: 000e .short 0x000e <== NOT EXECUTED
449dc: 0022 .short 0x0022 <== NOT EXECUTED
449de: 006a .short 0x006a <== NOT EXECUTED
449e0: 006a .short 0x006a <== NOT EXECUTED
449e2: 0050 .short 0x0050 <== NOT EXECUTED
449e4: 0032 .short 0x0032 <== NOT EXECUTED
449e6: 0076 .short 0x0076 <== NOT EXECUTED
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
449e8: 2f28 0008 movel %a0@(8),%sp@-
449ec: 4878 002f pea 2f <OPER2+0x1b>
449f0: 4eb9 0005 01cc jsr 501cc <fputc>
break;
449f6: 508f addql #8,%sp
449f8: 6000 0082 braw 44a7c <IMFS_print_jnode+0xe4>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
449fc: 2f2a 0050 movel %a2@(80),%sp@-
44a00: 2f2a 004c movel %a2@(76),%sp@-
44a04: 4879 0006 04c5 pea 604c5 <map.6391+0x11>
44a0a: 600e bras 44a1a <IMFS_print_jnode+0x82>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
44a0c: 2f2a 0054 movel %a2@(84),%sp@-
44a10: 2f2a 0050 movel %a2@(80),%sp@-
44a14: 4879 0006 04d8 pea 604d8 <map.6391+0x24>
44a1a: 2f28 0008 movel %a0@(8),%sp@-
44a1e: 4eb9 0005 014e jsr 5014e <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
44a24: 4fef 0010 lea %sp@(16),%sp
44a28: 6052 bras 44a7c <IMFS_print_jnode+0xe4>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
44a2a: 2f2a 0050 movel %a2@(80),%sp@-
44a2e: 4879 0006 04e7 pea 604e7 <map.6391+0x33>
44a34: 2f28 0008 movel %a0@(8),%sp@-
44a38: 4eb9 0005 014e jsr 5014e <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
44a3e: 4fef 000c lea %sp@(12),%sp
44a42: 6038 bras 44a7c <IMFS_print_jnode+0xe4>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
44a44: 2f28 0008 movel %a0@(8),%sp@-
44a48: 4879 0006 04f3 pea 604f3 <map.6391+0x3f>
44a4e: 600a bras 44a5a <IMFS_print_jnode+0xc2>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
44a50: 2f28 0008 movel %a0@(8),%sp@-
44a54: 4879 0006 0507 pea 60507 <map.6391+0x53>
44a5a: 4eb9 0005 029c jsr 5029c <fputs>
return;
44a60: 508f addql #8,%sp
44a62: 6032 bras 44a96 <IMFS_print_jnode+0xfe>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
44a64: 2f00 movel %d0,%sp@- <== NOT EXECUTED
44a66: 4879 0006 051a pea 6051a <map.6391+0x66> <== NOT EXECUTED
44a6c: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
44a70: 4eb9 0005 014e jsr 5014e <fprintf> <== NOT EXECUTED
return;
44a76: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44a7a: 601a bras 44a96 <IMFS_print_jnode+0xfe> <== NOT EXECUTED
}
puts("");
}
44a7c: 242e fff8 movel %fp@(-8),%d2
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44a80: 203c 0006 0bce movel #396238,%d0
}
44a86: 246e fffc moveal %fp@(-4),%a2
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44a8a: 2d40 0008 movel %d0,%fp@(8)
}
44a8e: 4e5e unlk %fp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
44a90: 4ef9 0005 1a1e jmp 51a1e <puts>
}
44a96: 242e fff8 movel %fp@(-8),%d2
44a9a: 246e fffc moveal %fp@(-4),%a2
44a9e: 4e5e unlk %fp <== NOT EXECUTED
000423e8 <IMFS_rename>:
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
423e8: 4e56 fff8 linkw %fp,#-8
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
423ec: 206e 000c moveal %fp@(12),%a0
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
423f0: 2f0a movel %a2,%sp@-
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
423f2: 2450 moveal %a0@,%a2
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
423f4: 4878 0020 pea 20 <OPER2+0xc>
423f8: 2f2e 0014 movel %fp@(20),%sp@-
423fc: 486a 000c pea %a2@(12)
42400: 4eb9 0004 d3bc jsr 4d3bc <strncpy>
if ( the_jnode->Parent != NULL )
42406: 4fef 000c lea %sp@(12),%sp
4240a: 4aaa 0008 tstl %a2@(8)
4240e: 670a beqs 4241a <IMFS_rename+0x32> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
42410: 2f0a movel %a2,%sp@-
42412: 4eb9 0004 6394 jsr 46394 <_Chain_Extract>
42418: 588f addql #4,%sp
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
4241a: 206e 0010 moveal %fp@(16),%a0
4241e: 2050 moveal %a0@,%a0
the_jnode->Parent = new_parent;
42420: 2548 0008 movel %a0,%a2@(8)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
42424: 2f0a movel %a2,%sp@-
42426: 4868 004c pea %a0@(76)
4242a: 4eb9 0004 635c jsr 4635c <_Chain_Append>
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
42430: 42a7 clrl %sp@-
42432: 486e fff8 pea %fp@(-8)
42436: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
4243c: 256e fff8 0044 movel %fp@(-8),%a2@(68)
return 0;
}
42442: 4280 clrl %d0
42444: 246e fff4 moveal %fp@(-12),%a2
42448: 4e5e unlk %fp <== NOT EXECUTED
00048fc8 <IMFS_skip_separator>:
static void IMFS_skip_separator (
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
48fc8: 4e56 fff0 linkw %fp,#-16
48fcc: 48d7 3c00 moveml %a2-%a5,%sp@
48fd0: 286e 0008 moveal %fp@(8),%a4
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
48fd4: 4bf9 0004 38a4 lea 438a4 <rtems_filesystem_is_separator>,%a5
static void IMFS_skip_separator (
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
48fda: 266e 000c moveal %fp@(12),%a3
48fde: 246e 0010 moveal %fp@(16),%a2
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
48fe2: 6008 bras 48fec <IMFS_skip_separator+0x24>
++(*index);
48fe4: 5281 addql #1,%d1
--(*len);
48fe6: 5380 subql #1,%d0
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
++(*index);
48fe8: 2481 movel %d1,%a2@
--(*len);
48fea: 2680 movel %d0,%a3@
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
48fec: 2012 movel %a2@,%d0
48fee: 1034 0800 moveb %a4@(00000000,%d0:l),%d0
48ff2: 49c0 extbl %d0
48ff4: 2f00 movel %d0,%sp@-
48ff6: 4e95 jsr %a5@
48ff8: 588f addql #4,%sp
48ffa: 4a80 tstl %d0
48ffc: 670c beqs 4900a <IMFS_skip_separator+0x42>
48ffe: 2212 movel %a2@,%d1
49000: 4a34 1800 tstb %a4@(00000000,%d1:l)
49004: 6704 beqs 4900a <IMFS_skip_separator+0x42>
49006: 2013 movel %a3@,%d0
49008: 66da bnes 48fe4 <IMFS_skip_separator+0x1c> <== ALWAYS TAKEN
++(*index);
--(*len);
}
}
4900a: 4cee 3c00 fff0 moveml %fp@(-16),%a2-%a5
49010: 4e5e unlk %fp <== NOT EXECUTED
000499ac <IMFS_stat>:
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
499ac: 7205 moveq #5,%d1
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
499ae: 4e56 0000 linkw %fp,#0
499b2: 206e 000c moveal %fp@(12),%a0
499b6: 2f0a movel %a2,%sp@-
499b8: 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;
499bc: 2252 moveal %a2@,%a1
switch ( the_jnode->type ) {
499be: 2029 0048 movel %a1@(72),%d0
499c2: 5580 subql #2,%d0
499c4: b280 cmpl %d0,%d1
499c6: 653e bcss 49a06 <IMFS_stat+0x5a> <== NEVER TAKEN
499c8: 303b 0a08 movew %pc@(499d2 <IMFS_stat+0x26>,%d0:l:2),%d0
499cc: 48c0 extl %d0
499ce: 4efb 0802 jmp %pc@(499d2 <IMFS_stat+0x26>,%d0:l)
499d2: 000c .short 0x000c <== NOT EXECUTED
499d4: 0034 .short 0x0034 <== NOT EXECUTED
499d6: 0026 .short 0x0026 <== NOT EXECUTED
499d8: 001c .short 0x001c <== NOT EXECUTED
499da: 001c .short 0x001c <== NOT EXECUTED
499dc: 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 );
499de: 2029 0050 movel %a1@(80),%d0
499e2: 2169 004c 0016 movel %a1@(76),%a0@(22)
499e8: 2140 001a movel %d0,%a0@(26)
break;
499ec: 602a bras 49a18 <IMFS_stat+0x6c>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
499ee: 2029 004c movel %a1@(76),%d0
499f2: 2229 0050 movel %a1@(80),%d1
499f6: 6004 bras 499fc <IMFS_stat+0x50>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
499f8: 4280 clrl %d0
499fa: 4281 clrl %d1
499fc: 2140 001e movel %d0,%a0@(30)
49a00: 2141 0022 movel %d1,%a0@(34)
break;
49a04: 6012 bras 49a18 <IMFS_stat+0x6c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
49a06: 4eb9 0004 c034 jsr 4c034 <__errno>
49a0c: 2040 moveal %d0,%a0
49a0e: 70ff moveq #-1,%d0
49a10: 20bc 0000 0086 movel #134,%a0@
49a16: 6050 bras 49a68 <IMFS_stat+0xbc>
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
49a18: 246a 0010 moveal %a2@(16),%a2
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
49a1c: 246a 0034 moveal %a2@(52),%a2
49a20: 2012 movel %a2@,%d0
buf->st_mode = the_jnode->st_mode;
49a22: 2169 002e 000c movel %a1@(46),%a0@(12)
buf->st_nlink = the_jnode->st_nlink;
49a28: 3169 0032 0010 movew %a1@(50),%a0@(16)
buf->st_ino = the_jnode->st_ino;
49a2e: 2169 0034 0008 movel %a1@(52),%a0@(8)
buf->st_uid = the_jnode->st_uid;
49a34: 3169 0038 0012 movew %a1@(56),%a0@(18)
buf->st_gid = the_jnode->st_gid;
49a3a: 3169 003a 0014 movew %a1@(58),%a0@(20)
buf->st_atime = the_jnode->stat_atime;
49a40: 2169 003c 0026 movel %a1@(60),%a0@(38)
buf->st_mtime = the_jnode->stat_mtime;
49a46: 2169 0040 002e movel %a1@(64),%a0@(46)
buf->st_ctime = the_jnode->stat_ctime;
49a4c: 2169 0044 0036 movel %a1@(68),%a0@(54)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
49a52: 43f9 0005 bfee lea 5bfee <imfs_rq_memfile_bytes_per_block>,%a1
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
49a58: 2140 0004 movel %d0,%a0@(4)
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
49a5c: 2151 003e movel %a1@,%a0@(62)
return 0;
49a60: 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 =
49a62: 20bc 0000 fffe movel #65534,%a0@
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
return 0;
}
49a68: 246e fffc moveal %fp@(-4),%a2
49a6c: 4e5e unlk %fp <== NOT EXECUTED
000424e8 <IMFS_unlink>:
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
424e8: 7003 moveq #3,%d0
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
424ea: 4e56 ffd0 linkw %fp,#-48
424ee: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
424f2: 246e 000c moveal %fp@(12),%a2
424f6: 262e 0008 movel %fp@(8),%d3
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
424fa: 2652 moveal %a2@,%a3
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
424fc: b0ab 0048 cmpl %a3@(72),%d0
42500: 6600 0082 bnew 42584 <IMFS_unlink+0x9c>
if ( !node->info.hard_link.link_node )
42504: 282b 004c movel %a3@(76),%d4
42508: 660e bnes 42518 <IMFS_unlink+0x30> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
4250a: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
42510: 2040 moveal %d0,%a0 <== NOT EXECUTED
42512: 7016 moveq #22,%d0 <== NOT EXECUTED
42514: 2080 movel %d0,%a0@ <== NOT EXECUTED
42516: 607e bras 42596 <IMFS_unlink+0xae> <== NOT EXECUTED
the_link = *loc;
42518: 4878 0014 pea 14 <OPER2>
4251c: 240e movel %fp,%d2
4251e: 0682 ffff ffe4 addil #-28,%d2
42524: 2f0a movel %a2,%sp@-
42526: 2f02 movel %d2,%sp@-
42528: 4eb9 0004 c854 jsr 4c854 <memcpy>
the_link.node_access = node->info.hard_link.link_node;
4252e: 2d44 ffe4 movel %d4,%fp@(-28)
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
42532: 7801 moveq #1,%d4
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
42534: 2f02 movel %d2,%sp@-
42536: 4eb9 0004 9014 jsr 49014 <IMFS_Set_handlers>
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
4253c: 206b 004c moveal %a3@(76),%a0
42540: 4281 clrl %d1
42542: 4fef 0010 lea %sp@(16),%sp
42546: 3028 0032 movew %a0@(50),%d0
4254a: 3200 movew %d0,%d1
4254c: b881 cmpl %d1,%d4
4254e: 6616 bnes 42566 <IMFS_unlink+0x7e>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
42550: 2f02 movel %d2,%sp@-
42552: 206e ffec moveal %fp@(-20),%a0
42556: 2f03 movel %d3,%sp@-
42558: 2068 0034 moveal %a0@(52),%a0
4255c: 4e90 jsr %a0@
if ( result != 0 )
4255e: 508f addql #8,%sp
42560: 4a80 tstl %d0
42562: 6720 beqs 42584 <IMFS_unlink+0x9c>
42564: 6030 bras 42596 <IMFS_unlink+0xae>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
42566: 5380 subql #1,%d0
42568: 3140 0032 movew %d0,%a0@(50)
IMFS_update_ctime( node->info.hard_link.link_node );
4256c: 42a7 clrl %sp@-
4256e: 486e fff8 pea %fp@(-8)
42572: 4eb9 0004 2bf0 jsr 42bf0 <gettimeofday>
42578: 206b 004c moveal %a3@(76),%a0
4257c: 508f addql #8,%sp
4257e: 216e fff8 0044 movel %fp@(-8),%a0@(68)
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
42584: 206a 0008 moveal %a2@(8),%a0
42588: 2f0a movel %a2,%sp@-
4258a: 2f03 movel %d3,%sp@-
4258c: 2068 0034 moveal %a0@(52),%a0
42590: 4e90 jsr %a0@
return result;
42592: 508f addql #8,%sp
42594: 6002 bras 42598 <IMFS_unlink+0xb0>
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
if ( result != 0 )
return -1;
42596: 70ff moveq #-1,%d0
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
return result;
}
42598: 4cee 0c1c ffd0 moveml %fp@(-48),%d2-%d4/%a2-%a3
4259e: 4e5e unlk %fp
...
000425a4 <IMFS_unmount>:
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
425a4: 7001 moveq #1,%d0
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
425a6: 4e56 0000 linkw %fp,#0
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
425aa: 206e 0008 moveal %fp@(8),%a0
425ae: 2068 0008 moveal %a0@(8),%a0
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
425b2: b0a8 0048 cmpl %a0@(72),%d0
425b6: 670e beqs 425c6 <IMFS_unmount+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
425b8: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
425be: 7214 moveq #20,%d1 <== NOT EXECUTED
425c0: 2040 moveal %d0,%a0 <== NOT EXECUTED
425c2: 2081 movel %d1,%a0@ <== NOT EXECUTED
425c4: 6012 bras 425d8 <IMFS_unmount+0x34> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
425c6: 4aa8 0058 tstl %a0@(88)
425ca: 6610 bnes 425dc <IMFS_unmount+0x38> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
425cc: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
425d2: 2040 moveal %d0,%a0 <== NOT EXECUTED
425d4: 7016 moveq #22,%d0 <== NOT EXECUTED
425d6: 2080 movel %d0,%a0@ <== NOT EXECUTED
425d8: 70ff moveq #-1,%d0 <== NOT EXECUTED
425da: 6006 bras 425e2 <IMFS_unmount+0x3e> <== NOT EXECUTED
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
425dc: 42a8 0058 clrl %a0@(88)
return 0;
425e0: 4280 clrl %d0
}
425e2: 4e5e unlk %fp
...
00041ed8 <Stack_check_Dump_threads_usage>:
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
41ed8: 70ff moveq #-1,%d0 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
41eda: 4e56 ffe0 linkw %fp,#-32 <== NOT EXECUTED
41ede: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@ <== NOT EXECUTED
41ee2: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
41ee6: b08a cmpl %a2,%d0 <== NOT EXECUTED
41ee8: 6616 bnes 41f00 <Stack_check_Dump_threads_usage+0x28><== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
41eea: 4ab9 0005 da64 tstl 5da64 <Stack_check_Interrupt_stack+0x4><== NOT EXECUTED
41ef0: 6700 00f8 beqw 41fea <Stack_check_Dump_threads_usage+0x112><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
41ef4: 49f9 0005 da60 lea 5da60 <Stack_check_Interrupt_stack>,%a4 <== NOT EXECUTED
the_thread = 0;
current = 0;
41efa: 4283 clrl %d3 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
41efc: 95ca subal %a2,%a2 <== NOT EXECUTED
41efe: 6008 bras 41f08 <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 );
41f00: 262a 00f0 movel %a2@(240),%d3 <== NOT EXECUTED
the_thread = 0;
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
41f04: 49ea 00b0 lea %a2@(176),%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);
41f08: 2414 movel %a4@,%d2 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
41f0a: 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);
41f0c: 0682 ffff fff0 addil #-16,%d2 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
41f12: 226c 0004 moveal %a4@(4),%a1 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
41f16: 41e9 0020 lea %a1@(32),%a0 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
41f1a: c082 andl %d2,%d0 <== NOT EXECUTED
41f1c: d088 addl %a0,%d0 <== NOT EXECUTED
41f1e: 600c bras 41f2c <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
if (*base != U32_PATTERN)
41f20: 223c a5a5 a5a5 movel #-1515870811,%d1 <== NOT EXECUTED
41f26: b290 cmpl %a0@,%d1 <== NOT EXECUTED
41f28: 6608 bnes 41f32 <Stack_check_Dump_threads_usage+0x5a><== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
41f2a: 5888 addql #4,%a0 <== NOT EXECUTED
41f2c: b088 cmpl %a0,%d0 <== NOT EXECUTED
41f2e: 62f0 bhis 41f20 <Stack_check_Dump_threads_usage+0x48><== NOT EXECUTED
41f30: 600c bras 41f3e <Stack_check_Dump_threads_usage+0x66><== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
41f32: 4a88 tstl %a0 <== NOT EXECUTED
41f34: 6708 beqs 41f3e <Stack_check_Dump_threads_usage+0x66><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
41f36: 47f1 2810 lea %a1@(00000010,%d2:l),%a3 <== NOT EXECUTED
41f3a: 97c8 subal %a0,%a3 <== NOT EXECUTED
41f3c: 6002 bras 41f40 <Stack_check_Dump_threads_usage+0x68><== NOT EXECUTED
else
used = 0;
41f3e: 97cb subal %a3,%a3 <== NOT EXECUTED
41f40: 2a79 0005 d24c moveal 5d24c <print_handler>,%a5 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
41f46: 4a8a tstl %a2 <== NOT EXECUTED
41f48: 672c beqs 41f76 <Stack_check_Dump_threads_usage+0x9e><== NOT EXECUTED
#endif
{
(*print_handler)(
41f4a: 486e fffb pea %fp@(-5) <== NOT EXECUTED
41f4e: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
41f52: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
41f56: 4eb9 0004 59bc jsr 459bc <rtems_object_get_name> <== NOT EXECUTED
41f5c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
41f5e: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
41f62: 4879 0005 ae3b pea 5ae3b <map.6391+0x11> <== NOT EXECUTED
41f68: 2f39 0005 d250 movel 5d250 <print_context>,%sp@- <== NOT EXECUTED
41f6e: 4e95 jsr %a5@ <== NOT EXECUTED
41f70: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
41f74: 6016 bras 41f8c <Stack_check_Dump_threads_usage+0xb4><== NOT EXECUTED
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
}
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
41f76: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
41f7a: 4879 0005 ae48 pea 5ae48 <map.6391+0x1e> <== NOT EXECUTED
41f80: 2f39 0005 d250 movel 5d250 <print_context>,%sp@- <== NOT EXECUTED
41f86: 4e95 jsr %a5@ <== NOT EXECUTED
41f88: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
41f8c: 206c 0004 moveal %a4@(4),%a0 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
41f90: 2f02 movel %d2,%sp@- <== NOT EXECUTED
41f92: 2f03 movel %d3,%sp@- <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
41f94: 2014 movel %a4@,%d0 <== NOT EXECUTED
41f96: 5380 subql #1,%d0 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
41f98: 4870 0800 pea %a0@(00000000,%d0:l) <== NOT EXECUTED
41f9c: 2f08 movel %a0,%sp@- <== NOT EXECUTED
41f9e: 4879 0005 ae56 pea 5ae56 <map.6391+0x2c> <== NOT EXECUTED
41fa4: 2f39 0005 d250 movel 5d250 <print_context>,%sp@- <== NOT EXECUTED
41faa: 2079 0005 d24c moveal 5d24c <print_handler>,%a0 <== NOT EXECUTED
41fb0: 4e90 jsr %a0@ <== NOT EXECUTED
41fb2: 2079 0005 d24c moveal 5d24c <print_handler>,%a0 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
41fb8: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
41fbc: 4ab9 0005 d248 tstl 5d248 <Stack_check_Initialized> <== NOT EXECUTED
41fc2: 6612 bnes 41fd6 <Stack_check_Dump_threads_usage+0xfe><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
41fc4: 4879 0005 ae74 pea 5ae74 <map.6391+0x4a> <== NOT EXECUTED
41fca: 2f39 0005 d250 movel 5d250 <print_context>,%sp@- <== NOT EXECUTED
41fd0: 4e90 jsr %a0@ <== NOT EXECUTED
41fd2: 508f addql #8,%sp <== NOT EXECUTED
41fd4: 6014 bras 41fea <Stack_check_Dump_threads_usage+0x112><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
41fd6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
41fd8: 4879 0005 ae81 pea 5ae81 <map.6391+0x57> <== NOT EXECUTED
41fde: 2f39 0005 d250 movel 5d250 <print_context>,%sp@- <== NOT EXECUTED
41fe4: 4e90 jsr %a0@ <== NOT EXECUTED
41fe6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
}
41fea: 4cee 3c0c ffe0 moveml %fp@(-32),%d2-%d3/%a2-%a5 <== NOT EXECUTED
41ff0: 4e5e unlk %fp <== NOT EXECUTED
00041ff4 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
41ff4: 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 )
41ff8: 4ab9 0005 d248 tstl 5d248 <Stack_check_Initialized>
41ffe: 6668 bnes 42068 <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 ];
42000: 203c feed f00d movel #-17960947,%d0
42006: 23c0 0005 da50 movel %d0,5da50 <Stack_check_Pattern>
4200c: 203c 0bad 0d06 movel #195890438,%d0
42012: 23c0 0005 da54 movel %d0,5da54 <Stack_check_Pattern+0x4>
42018: 203c dead f00d movel #-559026163,%d0
4201e: 23c0 0005 da58 movel %d0,5da58 <Stack_check_Pattern+0x8>
42024: 203c 600d 0d06 movel #1611468038,%d0
4202a: 23c0 0005 da5c movel %d0,5da5c <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) {
42030: 2039 0005 dd44 movel 5dd44 <_Per_CPU_Information>,%d0
42036: 6728 beqs 42060 <Stack_check_Initialize+0x6c> <== NEVER TAKEN
42038: 2239 0005 dd48 movel 5dd48 <_Per_CPU_Information+0x4>,%d1
4203e: 6720 beqs 42060 <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 -
42040: 9280 subl %d0,%d1
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
42042: 2f01 movel %d1,%sp@-
42044: 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;
42048: 23c0 0005 da64 movel %d0,5da64 <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);
4204e: 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 -
42050: 23c1 0005 da60 movel %d1,5da60 <Stack_check_Interrupt_stack>
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
42056: 4eb9 0004 cbd4 jsr 4cbd4 <memset>
4205c: 4fef 000c lea %sp@(12),%sp
}
#endif
Stack_check_Initialized = 1;
42060: 7001 moveq #1,%d0
42062: 23c0 0005 d248 movel %d0,5d248 <Stack_check_Initialized>
}
42068: 4e5e unlk %fp <== NOT EXECUTED
000420ce <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)
{
420ce: 4e56 ffd0 linkw %fp,#-48 <== NOT EXECUTED
420d2: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED
420d6: 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");
420da: 45f9 0004 3a28 lea 43a28 <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);
420e0: 286b 00b4 moveal %a3@(180),%a4 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
420e4: 4879 0005 ae87 pea 5ae87 <map.6391+0x5d> <== NOT EXECUTED
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
420ea: 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");
420ee: 4e92 jsr %a2@ <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
420f0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
420f2: 4879 0005 ae97 pea 5ae97 <map.6391+0x6d> <== NOT EXECUTED
420f8: 4e92 jsr %a2@ <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
420fa: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
420fe: 4879 0005 aeb4 pea 5aeb4 <map.6391+0x8a> <== NOT EXECUTED
42104: 4e92 jsr %a2@ <== NOT EXECUTED
printk(
42106: 2f2b 000c movel %a3@(12),%sp@- <== NOT EXECUTED
4210a: 4879 0005 aec6 pea 5aec6 <map.6391+0x9c> <== NOT EXECUTED
42110: 4e92 jsr %a2@ <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
42112: 486e ffe0 pea %fp@(-32) <== NOT EXECUTED
42116: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
4211a: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
4211e: 4eb9 0004 59bc jsr 459bc <rtems_object_get_name> <== NOT EXECUTED
42124: 4fef 0024 lea %sp@(36),%sp <== NOT EXECUTED
42128: 2e80 movel %d0,%sp@ <== NOT EXECUTED
4212a: 4879 0005 aeda pea 5aeda <map.6391+0xb0> <== NOT EXECUTED
42130: 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)
42132: 206b 00b4 moveal %a3@(180),%a0 <== NOT EXECUTED
42136: 202b 00b0 movel %a3@(176),%d0 <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
4213a: 4870 0800 pea %a0@(00000000,%d0:l) <== NOT EXECUTED
4213e: 2f08 movel %a0,%sp@- <== NOT EXECUTED
42140: 2f00 movel %d0,%sp@- <== NOT EXECUTED
42142: 4879 0005 aef0 pea 5aef0 <map.6391+0xc6> <== NOT EXECUTED
42148: 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) {
4214a: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4214e: 4a02 tstb %d2 <== NOT EXECUTED
42150: 6618 bnes 4216a <Stack_check_report_blown_task+0x9c><== NOT EXECUTED
printk(
42152: 486c 0018 pea %a4@(24) <== NOT EXECUTED
42156: 486c 0008 pea %a4@(8) <== NOT EXECUTED
4215a: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
4215e: 4879 0005 af21 pea 5af21 <map.6391+0xf7> <== NOT EXECUTED
42164: 4e92 jsr %a2@ <== NOT EXECUTED
42166: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
4216a: 4878 0081 pea 81 <DBL_MANT_DIG+0x4c> <== NOT EXECUTED
4216e: 4eb9 0004 6278 jsr 46278 <rtems_fatal_error_occurred> <== NOT EXECUTED
0004af20 <TOD_MICROSECONDS_TO_TICKS>:
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
microseconds_per_tick = rtems_configuration_get_microseconds_per_tick();
ticks = microseconds / microseconds_per_tick;
4af20: 41f9 0006 0b18 lea 60b18 <Configuration+0xc>,%a0
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
4af26: 4e56 0000 linkw %fp,#0
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
microseconds_per_tick = rtems_configuration_get_microseconds_per_tick();
ticks = microseconds / microseconds_per_tick;
4af2a: 202e 0008 movel %fp@(8),%d0
4af2e: 4c50 0001 remul %a0@,%d1,%d0
4af32: 4c50 0000 remul %a0@,%d0,%d0
if ( (microseconds % microseconds_per_tick) != 0 )
4af36: 4a81 tstl %d1
4af38: 6702 beqs 4af3c <TOD_MICROSECONDS_TO_TICKS+0x1c> <== ALWAYS TAKEN
ticks += 1;
4af3a: 5280 addql #1,%d0 <== NOT EXECUTED
return ticks;
}
4af3c: 4e5e unlk %fp <== NOT EXECUTED
00046db0 <TOD_MILLISECONDS_TO_TICKS>:
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
46db0: 4e56 0000 linkw %fp,#0
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick();
46db4: 2039 0005 cde8 movel 5cde8 <Configuration+0xc>,%d0
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
46dba: 2f02 movel %d2,%sp@-
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick();
46dbc: 243c 0000 03e8 movel #1000,%d2
46dc2: 4c42 0000 remul %d2,%d0,%d0
ticks = milliseconds / milliseconds_per_tick;
46dc6: 242e 0008 movel %fp@(8),%d2
46dca: 4c40 2001 remul %d0,%d1,%d2
46dce: 4c40 2002 remul %d0,%d2,%d2
46dd2: 2002 movel %d2,%d0
if ( (milliseconds % milliseconds_per_tick) != 0 )
46dd4: 4a81 tstl %d1
46dd6: 6702 beqs 46dda <TOD_MILLISECONDS_TO_TICKS+0x2a> <== ALWAYS TAKEN
ticks += 1;
46dd8: 5280 addql #1,%d0 <== NOT EXECUTED
return ticks;
}
46dda: 241f movel %sp@+,%d2
46ddc: 4e5e unlk %fp <== NOT EXECUTED
0004cd80 <_CORE_barrier_Wait>:
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4cd80: 203c 0000 0700 movel #1792,%d0
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4cd86: 4e56 fff4 linkw %fp,#-12
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
4cd8a: 2279 0005 fa10 moveal 5fa10 <_Per_CPU_Information+0xc>,%a1
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4cd90: 48d7 001c moveml %d2-%d4,%sp@
4cd94: 206e 0008 moveal %fp@(8),%a0
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
4cd98: 42a9 0034 clrl %a1@(52)
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4cd9c: 242e 000c movel %fp@(12),%d2
4cda0: 262e 0014 movel %fp@(20),%d3
4cda4: 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 );
4cda8: 40c1 movew %sr,%d1
4cdaa: 8081 orl %d1,%d0
4cdac: 46c0 movew %d0,%sr
the_barrier->number_of_waiting_threads++;
4cdae: 2028 0048 movel %a0@(72),%d0
4cdb2: 5280 addql #1,%d0
4cdb4: 2140 0048 movel %d0,%a0@(72)
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
4cdb8: 4aa8 0040 tstl %a0@(64)
4cdbc: 6626 bnes 4cde4 <_CORE_barrier_Wait+0x64>
if ( the_barrier->number_of_waiting_threads ==
4cdbe: b0a8 0044 cmpl %a0@(68),%d0
4cdc2: 6620 bnes 4cde4 <_CORE_barrier_Wait+0x64>
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
4cdc4: 7001 moveq #1,%d0
4cdc6: 2340 0034 movel %d0,%a1@(52)
_ISR_Enable( level );
4cdca: 46c1 movew %d1,%sr
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
4cdcc: 2d44 0010 movel %d4,%fp@(16)
4cdd0: 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 );
}
4cdd4: 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 );
4cdd8: 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 );
}
4cddc: 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 );
4cdde: 4ef9 0004 cd4c jmp 4cd4c <_CORE_barrier_Release>
4cde4: 7001 moveq #1,%d0
4cde6: 2140 0030 movel %d0,%a0@(48)
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
4cdea: 2348 0044 movel %a0,%a1@(68)
executing->Wait.id = id;
4cdee: 2342 0020 movel %d2,%a1@(32)
_ISR_Enable( level );
4cdf2: 46c1 movew %d1,%sr
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
4cdf4: 2d43 000c movel %d3,%fp@(12)
4cdf8: 203c 0004 9eac movel #302764,%d0
4cdfe: 2d48 0008 movel %a0,%fp@(8)
}
4ce02: 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 );
4ce06: 2d40 0010 movel %d0,%fp@(16)
}
4ce0a: 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 );
4ce0c: 4ef9 0004 9bb4 jmp 49bb4 <_Thread_queue_Enqueue_with_handler>
...
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 ffe4 linkw %fp,#-28
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
4e14a: 2079 0006 62b4 moveal 662b4 <_Per_CPU_Information+0xc>,%a0
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
4e150: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
4e154: 246e 0008 moveal %fp@(8),%a2
4e158: 282e 000c movel %fp@(12),%d4
4e15c: 242e 0010 movel %fp@(16),%d2
4e160: 226e 0014 moveal %fp@(20),%a1
4e164: 262e 001c movel %fp@(28),%d3
4e168: 1a2e 001b moveb %fp@(27),%d5
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: 2c0a movel %a2,%d6
4e17a: 0681 0000 0050 addil #80,%d1
4e180: 0686 0000 0054 addil #84,%d6
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4e186: 266a 0050 moveal %a2@(80),%a3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4e18a: bc8b cmpl %a3,%d6
4e18c: 674a beqs 4e1d8 <_CORE_message_queue_Seize+0x98>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
4e18e: 2053 moveal %a3@,%a0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e190: 2141 0004 movel %d1,%a0@(4)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
4e194: 53aa 0048 subql #1,%a2@(72)
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
4e198: 2548 0050 movel %a0,%a2@(80)
_ISR_Enable( level );
4e19c: 46c0 movew %d0,%sr
*size_p = the_message->Contents.size;
4e19e: 22ab 0008 movel %a3@(8),%a1@
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 );
4e1a2: 45ea 0060 lea %a2@(96),%a2
_Thread_Executing->Wait.count =
4e1a6: 2079 0006 62b4 moveal 662b4 <_Per_CPU_Information+0xc>,%a0
4e1ac: 42a8 0024 clrl %a0@(36)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4e1b0: 2f11 movel %a1@,%sp@-
4e1b2: 486b 000c pea %a3@(12)
4e1b6: 2f02 movel %d2,%sp@-
4e1b8: 4eb9 0005 4810 jsr 54810 <memcpy>
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 );
4e1be: 4fef 000c lea %sp@(12),%sp
4e1c2: 2d4b 000c movel %a3,%fp@(12)
4e1c6: 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 );
}
4e1ca: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
4e1d0: 4e5e unlk %fp
4e1d2: 4ef9 0004 dfb8 jmp 4dfb8 <_Chain_Append>
return;
}
#endif
}
if ( !wait ) {
4e1d8: 4a05 tstb %d5
4e1da: 6612 bnes 4e1ee <_CORE_message_queue_Seize+0xae>
_ISR_Enable( level );
4e1dc: 46c0 movew %d0,%sr
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
4e1de: 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 );
}
4e1e0: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
#endif
}
if ( !wait ) {
_ISR_Enable( level );
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
4e1e6: 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 );
}
4e1ea: 4e5e unlk %fp
4e1ec: 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;
4e1ee: 7201 moveq #1,%d1
4e1f0: 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;
4e1f4: 2142 002c movel %d2,%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;
4e1f8: 214a 0044 movel %a2,%a0@(68)
executing->Wait.id = id;
4e1fc: 2144 0020 movel %d4,%a0@(32)
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
4e200: 2149 0028 movel %a1,%a0@(40)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
4e204: 46c0 movew %d0,%sr
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
4e206: 2d43 000c movel %d3,%fp@(12)
4e20a: 203c 0005 032c movel #328492,%d0
4e210: 2d4a 0008 movel %a2,%fp@(8)
}
4e214: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
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 );
4e21a: 2d40 0010 movel %d0,%fp@(16)
}
4e21e: 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 );
4e220: 4ef9 0005 0034 jmp 50034 <_Thread_queue_Enqueue_with_handler>
...
000463fc <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
463fc: 4e56 fff4 linkw %fp,#-12
46400: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
46404: 4878 000e pea e <OPER1+0x2>
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
46408: 266e 000c moveal %fp@(12),%a3
4640c: 246e 0008 moveal %fp@(8),%a2
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
46410: 2f0b movel %a3,%sp@-
46412: 486a 0040 pea %a2@(64)
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
46416: 242e 0010 movel %fp@(16),%d2
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
4641a: 4eb9 0004 c854 jsr 4c854 <memcpy>
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
46420: 4fef 000c lea %sp@(12),%sp
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
the_mutex->lock = initial_lock;
46424: 2542 004e movel %d2,%a2@(78)
the_mutex->blocked_count = 0;
46428: 42aa 0056 clrl %a2@(86)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
4642c: 4a82 tstl %d2
4642e: 6638 bnes 46468 <_CORE_mutex_Initialize+0x6c>
the_mutex->nest_count = 1;
46430: 7001 moveq #1,%d0
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
46432: 7202 moveq #2,%d1
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
46434: 2079 0005 d9bc moveal 5d9bc <_Per_CPU_Information+0xc>,%a0
the_mutex->Attributes = *the_mutex_attributes;
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
4643a: 2540 0052 movel %d0,%a2@(82)
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
4643e: 2568 0008 005e movel %a0@(8),%a2@(94)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
46444: 202a 0046 movel %a2@(70),%d0
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
46448: 2548 005a movel %a0,%a2@(90)
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
4644c: b280 cmpl %d0,%d1
4644e: 6708 beqs 46458 <_CORE_mutex_Initialize+0x5c>
46450: 123c 0003 moveb #3,%d1
46454: b280 cmpl %d0,%d1
46456: 661c bnes 46474 <_CORE_mutex_Initialize+0x78>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
46458: 202a 004a movel %a2@(74),%d0
4645c: b0a8 0014 cmpl %a0@(20),%d0
46460: 6236 bhis 46498 <_CORE_mutex_Initialize+0x9c> <== NEVER TAKEN
_Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif
_Thread_Executing->resource_count++;
46462: 52a8 001c addql #1,%a0@(28)
46466: 600c bras 46474 <_CORE_mutex_Initialize+0x78>
}
} else {
the_mutex->nest_count = 0;
46468: 42aa 0052 clrl %a2@(82)
the_mutex->holder = NULL;
4646c: 42aa 005a clrl %a2@(90)
the_mutex->holder_id = 0;
46470: 42aa 005e clrl %a2@(94)
}
_Thread_queue_Initialize(
46474: 4878 0004 pea 4 <CONTEXT_ARG>
46478: 4878 0400 pea 400 <D_BIAS+0x2>
4647c: 4aab 0006 tstl %a3@(6)
46480: 56c0 sne %d0
46482: 49c0 extbl %d0
46484: 4480 negl %d0
46486: 2f00 movel %d0,%sp@-
46488: 2f0a movel %a2,%sp@-
4648a: 4eb9 0004 8304 jsr 48304 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
46490: 4fef 0010 lea %sp@(16),%sp
46494: 4280 clrl %d0
46496: 6002 bras 4649a <_CORE_mutex_Initialize+0x9e>
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
the_mutex->Attributes.priority_ceiling )
return CORE_MUTEX_STATUS_CEILING_VIOLATED;
46498: 7005 moveq #5,%d0
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
4649a: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
464a0: 4e5e unlk %fp <== NOT EXECUTED
00046704 <_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
)
{
46704: 4e56 0000 linkw %fp,#0
46708: 2f0a movel %a2,%sp@-
4670a: 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)) ) {
4670e: 2f0a movel %a2,%sp@-
46710: 4eb9 0004 7f98 jsr 47f98 <_Thread_queue_Dequeue>
46716: 588f addql #4,%sp
46718: 4a80 tstl %d0
4671a: 6624 bnes 46740 <_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 );
4671c: 303c 0700 movew #1792,%d0
46720: 40c1 movew %sr,%d1
46722: 8081 orl %d1,%d0
46724: 46c0 movew %d0,%sr
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
46726: 202a 0048 movel %a2@(72),%d0
4672a: b0aa 0040 cmpl %a2@(64),%d0
4672e: 640a bccs 4673a <_CORE_semaphore_Surrender+0x36> <== NEVER TAKEN
the_semaphore->count += 1;
46730: 5280 addql #1,%d0
46732: 2540 0048 movel %d0,%a2@(72)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
46736: 4280 clrl %d0
46738: 6002 bras 4673c <_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;
4673a: 7004 moveq #4,%d0 <== NOT EXECUTED
_ISR_Enable( level );
4673c: 46c1 movew %d1,%sr
4673e: 6002 bras 46742 <_CORE_semaphore_Surrender+0x3e>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
46740: 4280 clrl %d0
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
46742: 246e fffc moveal %fp@(-4),%a2
46746: 4e5e unlk %fp
...
000455d8 <_Event_Surrender>:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
455d8: 203c 0000 0700 movel #1792,%d0
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
455de: 4e56 ffec linkw %fp,#-20
455e2: 48d7 043c moveml %d2-%d5/%a2,%sp@
455e6: 246e 0008 moveal %fp@(8),%a2
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
455ea: 206a 00fc moveal %a2@(252),%a0
option_set = (rtems_option) the_thread->Wait.option;
455ee: 282a 0030 movel %a2@(48),%d4
_ISR_Disable( level );
455f2: 40c1 movew %sr,%d1
455f4: 8081 orl %d1,%d0
455f6: 46c0 movew %d0,%sr
pending_events = api->pending_events;
event_condition = (rtems_event_set) the_thread->Wait.count;
455f8: 262a 0024 movel %a2@(36),%d3
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Get(
rtems_event_set the_event_set,
rtems_event_set the_event_condition
)
{
return ( the_event_set & the_event_condition );
455fc: 2003 movel %d3,%d0
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
pending_events = api->pending_events;
455fe: 2410 movel %a0@,%d2
45600: c082 andl %d2,%d0
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
45602: 6700 00ca beqw 456ce <_Event_Surrender+0xf6>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
45606: 4ab9 0005 d9b8 tstl 5d9b8 <_Per_CPU_Information+0x8>
4560c: 674a beqs 45658 <_Event_Surrender+0x80>
4560e: b5f9 0005 d9bc cmpal 5d9bc <_Per_CPU_Information+0xc>,%a2
45614: 6642 bnes 45658 <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
45616: 2279 0005 d9f8 moveal 5d9f8 <_Event_Sync_state>,%a1
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
4561c: 7a02 moveq #2,%d5
4561e: ba89 cmpl %a1,%d5
45620: 670e beqs 45630 <_Event_Surrender+0x58> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
45622: 2279 0005 d9f8 moveal 5d9f8 <_Event_Sync_state>,%a1
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
45628: 1a3c 0001 moveb #1,%d5
4562c: ba89 cmpl %a1,%d5
4562e: 6628 bnes 45658 <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
45630: b680 cmpl %d0,%d3
45632: 6708 beqs 4563c <_Event_Surrender+0x64>
45634: 0804 0001 btst #1,%d4
45638: 6700 0094 beqw 456ce <_Event_Surrender+0xf6>
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
4563c: 2600 movel %d0,%d3
4563e: 4683 notl %d3
45640: c682 andl %d2,%d3
45642: 2083 movel %d3,%a0@
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
45644: 206a 0028 moveal %a2@(40),%a0
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
45648: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
4564c: 2080 movel %d0,%a0@
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
4564e: 7003 moveq #3,%d0
45650: 23c0 0005 d9f8 movel %d0,5d9f8 <_Event_Sync_state>
45656: 6076 bras 456ce <_Event_Surrender+0xf6>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
45658: 2a2a 0010 movel %a2@(16),%d5
4565c: 0285 0000 0100 andil #256,%d5
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
45662: 676a beqs 456ce <_Event_Surrender+0xf6>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
45664: b680 cmpl %d0,%d3
45666: 6706 beqs 4566e <_Event_Surrender+0x96>
45668: 0804 0001 btst #1,%d4
4566c: 6760 beqs 456ce <_Event_Surrender+0xf6> <== NEVER TAKEN
4566e: 2600 movel %d0,%d3
45670: 4683 notl %d3
45672: c682 andl %d2,%d3
45674: 2083 movel %d3,%a0@
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
45676: 206a 0028 moveal %a2@(40),%a0
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
4567a: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
4567e: 2080 movel %d0,%a0@
_ISR_Flash( level );
45680: 203c 0000 0700 movel #1792,%d0
45686: 46c1 movew %d1,%sr
45688: 8081 orl %d1,%d0
4568a: 46c0 movew %d0,%sr
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4568c: 7a02 moveq #2,%d5
4568e: baaa 0050 cmpl %a2@(80),%d5
45692: 6714 beqs 456a8 <_Event_Surrender+0xd0>
_ISR_Enable( level );
45694: 46c1 movew %d1,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
45696: 2f3c 1003 fff8 movel #268697592,%sp@-
4569c: 2f0a movel %a2,%sp@-
4569e: 4eb9 0004 7954 jsr 47954 <_Thread_Clear_state>
456a4: 508f addql #8,%sp
456a6: 6028 bras 456d0 <_Event_Surrender+0xf8>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
456a8: 7003 moveq #3,%d0
456aa: 2540 0050 movel %d0,%a2@(80)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
456ae: 46c1 movew %d1,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
456b0: 486a 0048 pea %a2@(72)
456b4: 4eb9 0004 89c8 jsr 489c8 <_Watchdog_Remove>
456ba: 2f3c 1003 fff8 movel #268697592,%sp@-
456c0: 2f0a movel %a2,%sp@-
456c2: 4eb9 0004 7954 jsr 47954 <_Thread_Clear_state>
456c8: 4fef 000c lea %sp@(12),%sp
456cc: 6002 bras 456d0 <_Event_Surrender+0xf8>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
456ce: 46c1 movew %d1,%sr
}
456d0: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
456d6: 4e5e unlk %fp
...
000456dc <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
456dc: 4e56 fffc linkw %fp,#-4
456e0: 2f03 movel %d3,%sp@-
456e2: 2f02 movel %d2,%sp@-
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
456e4: 486e fffc pea %fp@(-4)
456e8: 2f2e 0008 movel %fp@(8),%sp@-
456ec: 4eb9 0004 7cf0 jsr 47cf0 <_Thread_Get>
switch ( location ) {
456f2: 508f addql #8,%sp
456f4: 4aae fffc tstl %fp@(-4)
456f8: 665c bnes 45756 <_Event_Timeout+0x7a> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
456fa: 223c 0000 0700 movel #1792,%d1
45700: 40c2 movew %sr,%d2
45702: 8282 orl %d2,%d1
45704: 46c1 movew %d1,%sr
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
45706: 2040 moveal %d0,%a0
45708: 42a8 0024 clrl %a0@(36)
if ( _Thread_Is_executing( the_thread ) ) {
4570c: b0b9 0005 d9bc cmpl 5d9bc <_Per_CPU_Information+0xc>,%d0
45712: 6614 bnes 45728 <_Event_Timeout+0x4c>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
45714: 2239 0005 d9f8 movel 5d9f8 <_Event_Sync_state>,%d1
4571a: 7601 moveq #1,%d3
4571c: b681 cmpl %d1,%d3
4571e: 6608 bnes 45728 <_Event_Timeout+0x4c>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
45720: 7202 moveq #2,%d1
45722: 23c1 0005 d9f8 movel %d1,5d9f8 <_Event_Sync_state>
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
45728: 7606 moveq #6,%d3
4572a: 2040 moveal %d0,%a0
4572c: 2143 0034 movel %d3,%a0@(52)
_ISR_Enable( level );
45730: 46c2 movew %d2,%sr
45732: 2f3c 1003 fff8 movel #268697592,%sp@-
45738: 2f00 movel %d0,%sp@-
4573a: 4eb9 0004 7954 jsr 47954 <_Thread_Clear_state>
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
return _Thread_Dispatch_disable_level;
45740: 508f addql #8,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
45742: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
45748: 5380 subql #1,%d0
4574a: 23c0 0005 d828 movel %d0,5d828 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45750: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
45756: 242e fff4 movel %fp@(-12),%d2
4575a: 262e fff8 movel %fp@(-8),%d3
4575e: 4e5e unlk %fp
...
0004a8e8 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
4a8e8: 4e56 ffcc linkw %fp,#-52
4a8ec: 202e 0010 movel %fp@(16),%d0
4a8f0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4a8f4: 246e 0008 moveal %fp@(8),%a2
4a8f8: 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;
4a8fc: 2403 movel %d3,%d2
4a8fe: d480 addl %d0,%d2
uintptr_t const free_size = stats->free_size;
4a900: 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;
4a904: 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;
4a908: 2a2a 0010 movel %a2@(16),%d5
uintptr_t const min_block_size = heap->min_block_size;
4a90c: 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;
4a910: 42ae fff8 clrl %fp@(-8)
Heap_Block *extend_last_block = NULL;
4a914: 42ae fffc clrl %fp@(-4)
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
uintptr_t const free_size = stats->free_size;
4a918: 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 ) {
4a91c: b682 cmpl %d2,%d3
4a91e: 6200 01a6 bhiw 4aac6 <_Heap_Extend+0x1de>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
4a922: 486e fffc pea %fp@(-4)
4a926: 486e fff8 pea %fp@(-8)
4a92a: 2f01 movel %d1,%sp@-
4a92c: 2f05 movel %d5,%sp@-
4a92e: 2f00 movel %d0,%sp@-
4a930: 2f03 movel %d3,%sp@-
4a932: 4eb9 0004 698e jsr 4698e <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
4a938: 4fef 0018 lea %sp@(24),%sp
4a93c: 4a00 tstb %d0
4a93e: 6700 0186 beqw 4aac6 <_Heap_Extend+0x1de>
4a942: 2044 moveal %d4,%a0
4a944: 9bcd subal %a5,%a5
4a946: 4281 clrl %d1
4a948: 97cb subal %a3,%a3
4a94a: 99cc subal %a4,%a4
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
4a94c: b888 cmpl %a0,%d4
4a94e: 6704 beqs 4a954 <_Heap_Extend+0x6c>
4a950: 2248 moveal %a0,%a1
4a952: 6004 bras 4a958 <_Heap_Extend+0x70>
4a954: 226a 0018 moveal %a2@(24),%a1
uintptr_t const sub_area_end = start_block->prev_size;
4a958: 2010 movel %a0@,%d0
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4a95a: b680 cmpl %d0,%d3
4a95c: 6406 bccs 4a964 <_Heap_Extend+0x7c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
4a95e: b3c2 cmpal %d2,%a1
4a960: 6500 0164 bcsw 4aac6 <_Heap_Extend+0x1de>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4a964: b3c2 cmpal %d2,%a1
4a966: 6706 beqs 4a96e <_Heap_Extend+0x86>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4a968: b082 cmpl %d2,%d0
4a96a: 6206 bhis 4a972 <_Heap_Extend+0x8a>
4a96c: 6006 bras 4a974 <_Heap_Extend+0x8c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4a96e: 2848 moveal %a0,%a4
4a970: 6002 bras 4a974 <_Heap_Extend+0x8c>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4a972: 2208 movel %a0,%d1
4a974: 2e00 movel %d0,%d7
4a976: 2240 moveal %d0,%a1
4a978: 5189 subql #8,%a1
4a97a: 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);
4a97e: 93c6 subal %d6,%a1
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4a980: b680 cmpl %d0,%d3
4a982: 6606 bnes 4a98a <_Heap_Extend+0xa2>
start_block->prev_size = extend_area_end;
4a984: 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 )
4a986: 2649 moveal %a1,%a3
4a988: 6006 bras 4a990 <_Heap_Extend+0xa8>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
4a98a: b680 cmpl %d0,%d3
4a98c: 6302 blss 4a990 <_Heap_Extend+0xa8>
4a98e: 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;
4a990: 70fe moveq #-2,%d0
4a992: 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);
4a996: 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 );
4a99a: b888 cmpl %a0,%d4
4a99c: 66ae bnes 4a94c <_Heap_Extend+0x64>
if ( extend_area_begin < heap->area_begin ) {
4a99e: b6aa 0018 cmpl %a2@(24),%d3
4a9a2: 6406 bccs 4a9aa <_Heap_Extend+0xc2>
heap->area_begin = extend_area_begin;
4a9a4: 2543 0018 movel %d3,%a2@(24)
4a9a8: 600a bras 4a9b4 <_Heap_Extend+0xcc>
} else if ( heap->area_end < extend_area_end ) {
4a9aa: b4aa 001c cmpl %a2@(28),%d2
4a9ae: 6304 blss 4a9b4 <_Heap_Extend+0xcc>
heap->area_end = extend_area_end;
4a9b0: 2542 001c movel %d2,%a2@(28)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4a9b4: 206e fffc moveal %fp@(-4),%a0
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4a9b8: 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;
4a9ba: 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;
4a9bc: 226e fff8 moveal %fp@(-8),%a1
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4a9c0: 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;
4a9c2: 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;
4a9c4: 2282 movel %d2,%a1@
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4a9c6: 2344 0004 movel %d4,%a1@(4)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
4a9ca: 2080 movel %d0,%a0@
extend_last_block->size_and_flag = 0;
4a9cc: 42a8 0004 clrl %a0@(4)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4a9d0: b3ea 0020 cmpal %a2@(32),%a1
4a9d4: 6406 bccs 4a9dc <_Heap_Extend+0xf4>
heap->first_block = extend_first_block;
4a9d6: 2549 0020 movel %a1,%a2@(32)
4a9da: 600a bras 4a9e6 <_Heap_Extend+0xfe>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4a9dc: b1ea 0024 cmpal %a2@(36),%a0
4a9e0: 6304 blss 4a9e6 <_Heap_Extend+0xfe>
heap->last_block = extend_last_block;
4a9e2: 2548 0024 movel %a0,%a2@(36)
}
if ( merge_below_block != NULL ) {
4a9e6: 4a8c tstl %a4
4a9e8: 6732 beqs 4aa1c <_Heap_Extend+0x134>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
4a9ea: 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 );
4a9ee: 5083 addql #8,%d3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
4a9f0: 2803 movel %d3,%d4
4a9f2: 4c40 4001 remul %d0,%d1,%d4
if ( remainder != 0 ) {
4a9f6: 4a81 tstl %d1
4a9f8: 6704 beqs 4a9fe <_Heap_Extend+0x116>
return value - remainder + alignment;
4a9fa: d680 addl %d0,%d3
4a9fc: 9681 subl %d1,%d3
uintptr_t const new_first_block_begin =
4a9fe: 2043 moveal %d3,%a0
4aa00: 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 =
4aa02: 200c movel %a4,%d0
4aa04: 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;
4aa06: 7201 moveq #1,%d1
4aa08: 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;
4aa0a: 2094 movel %a4@,%a0@
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4aa0c: 2141 0004 movel %d1,%a0@(4)
_Heap_Free_block( heap, new_first_block );
4aa10: 2f08 movel %a0,%sp@-
4aa12: 2f0a movel %a2,%sp@-
4aa14: 4eba feb6 jsr %pc@(4a8cc <_Heap_Free_block>)
4aa18: 508f addql #8,%sp
4aa1a: 600e bras 4aa2a <_Heap_Extend+0x142>
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
4aa1c: 4a81 tstl %d1
4aa1e: 670a beqs 4aa2a <_Heap_Extend+0x142>
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
4aa20: 9288 subl %a0,%d1
4aa22: 7801 moveq #1,%d4
4aa24: 8881 orl %d1,%d4
4aa26: 2144 0004 movel %d4,%a0@(4)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
4aa2a: 4a8b tstl %a3
4aa2c: 6734 beqs 4aa62 <_Heap_Extend+0x17a>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
4aa2e: 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(
4aa30: 948b subl %a3,%d2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4aa32: 2202 movel %d2,%d1
4aa34: 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;
4aa3a: 7201 moveq #1,%d1
4aa3c: 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)
4aa3e: 202b 0004 movel %a3@(4),%d0
4aa42: 9082 subl %d2,%d0
| HEAP_PREV_BLOCK_USED;
4aa44: 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;
4aa46: 7001 moveq #1,%d0
4aa48: 2781 2804 movel %d1,%a3@(00000004,%d2:l)
4aa4c: c0ab 0004 andl %a3@(4),%d0
block->size_and_flag = size | flag;
4aa50: 8480 orl %d0,%d2
4aa52: 2742 0004 movel %d2,%a3@(4)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
4aa56: 2f0b movel %a3,%sp@-
4aa58: 2f0a movel %a2,%sp@-
4aa5a: 4eba fe70 jsr %pc@(4a8cc <_Heap_Free_block>)
4aa5e: 508f addql #8,%sp
4aa60: 6020 bras 4aa82 <_Heap_Extend+0x19a>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
4aa62: 4a8d tstl %a5
4aa64: 671c beqs 4aa82 <_Heap_Extend+0x19a>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4aa66: 7201 moveq #1,%d1
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4aa68: 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 );
4aa6a: 202e fff8 movel %fp@(-8),%d0
4aa6e: 908d subl %a5,%d0
4aa70: c2ad 0004 andl %a5@(4),%d1
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
4aa74: 206e fffc moveal %fp@(-4),%a0
block->size_and_flag = size | flag;
4aa78: 8280 orl %d0,%d1
4aa7a: 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;
4aa7e: 89a8 0004 orl %d4,%a0@(4)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4aa82: 4a8c tstl %a4
4aa84: 6610 bnes 4aa96 <_Heap_Extend+0x1ae>
4aa86: 4a8b tstl %a3
4aa88: 660c bnes 4aa96 <_Heap_Extend+0x1ae>
_Heap_Free_block( heap, extend_first_block );
4aa8a: 2f2e fff8 movel %fp@(-8),%sp@-
4aa8e: 2f0a movel %a2,%sp@-
4aa90: 4eba fe3a jsr %pc@(4a8cc <_Heap_Free_block>)
4aa94: 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
4aa96: 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;
4aa9a: 7201 moveq #1,%d1
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
4aa9c: 202a 0020 movel %a2@(32),%d0
4aaa0: 9088 subl %a0,%d0
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4aaa2: c2a8 0004 andl %a0@(4),%d1
block->size_and_flag = size | flag;
4aaa6: 8280 orl %d0,%d1
4aaa8: 2141 0004 movel %d1,%a0@(4)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
4aaac: 202a 0030 movel %a2@(48),%d0
4aab0: 90ae fff4 subl %fp@(-12),%d0
/* Statistics */
stats->size += extended_size;
4aab4: d1aa 002c addl %d0,%a2@(44)
if ( extended_size_ptr != NULL )
4aab8: 4aae 0014 tstl %fp@(20)
4aabc: 670c beqs 4aaca <_Heap_Extend+0x1e2> <== NEVER TAKEN
*extended_size_ptr = extended_size;
4aabe: 206e 0014 moveal %fp@(20),%a0
4aac2: 2080 movel %d0,%a0@
4aac4: 6004 bras 4aaca <_Heap_Extend+0x1e2>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
4aac6: 4200 clrb %d0
4aac8: 6002 bras 4aacc <_Heap_Extend+0x1e4>
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
4aaca: 7001 moveq #1,%d0
}
4aacc: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5
4aad2: 4e5e unlk %fp
...
0004a898 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4a898: 4e56 ffe8 linkw %fp,#-24
4a89c: 206e 0008 moveal %fp@(8),%a0
4a8a0: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
4a8a4: 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 ) {
4a8a8: 6700 014e beqw 4a9f8 <_Heap_Free+0x160>
4a8ac: 2240 moveal %d0,%a1
4a8ae: 5189 subql #8,%a1
4a8b0: 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
4a8b6: 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);
4a8ba: 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;
4a8bc: b889 cmpl %a1,%d4
4a8be: 620c bhis 4a8cc <_Heap_Free+0x34>
4a8c0: b3e8 0024 cmpal %a0@(36),%a1
4a8c4: 53c0 sls %d0
4a8c6: 49c0 extbl %d0
4a8c8: 4480 negl %d0
4a8ca: 6002 bras 4a8ce <_Heap_Free+0x36>
4a8cc: 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 ) ) {
4a8ce: 4a00 tstb %d0
4a8d0: 6700 012a beqw 4a9fc <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4a8d4: 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;
4a8d8: 70fe moveq #-2,%d0
4a8da: 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);
4a8dc: 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;
4a8e0: b88a cmpl %a2,%d4
4a8e2: 620c bhis 4a8f0 <_Heap_Free+0x58> <== NEVER TAKEN
4a8e4: b5e8 0024 cmpal %a0@(36),%a2
4a8e8: 53c1 sls %d1
4a8ea: 49c1 extbl %d1
4a8ec: 4481 negl %d1
4a8ee: 6002 bras 4a8f2 <_Heap_Free+0x5a>
4a8f0: 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 ) ) {
4a8f2: 4a01 tstb %d1
4a8f4: 6700 0106 beqw 4a9fc <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4a8f8: 242a 0004 movel %a2@(4),%d2
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4a8fc: 0802 0000 btst #0,%d2
4a900: 6700 00fa beqw 4a9fc <_Heap_Free+0x164>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4a904: 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
4a906: 2668 0024 moveal %a0@(36),%a3
4a90a: c481 andl %d1,%d2
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4a90c: b7ca cmpal %a2,%a3
4a90e: 670c beqs 4a91c <_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;
4a910: 7201 moveq #1,%d1
4a912: c2b2 2804 andl %a2@(00000004,%d2:l),%d1
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
4a916: 5381 subql #1,%d1
4a918: 4481 negl %d1
4a91a: 6002 bras 4a91e <_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 ));
4a91c: 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
4a91e: 1a01 moveb %d1,%d5
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
4a920: 0803 0000 btst #0,%d3
4a924: 6660 bnes 4a986 <_Heap_Free+0xee>
uintptr_t const prev_size = block->prev_size;
4a926: 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);
4a928: 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;
4a92a: b889 cmpl %a1,%d4
4a92c: 620a bhis 4a938 <_Heap_Free+0xa0> <== NEVER TAKEN
4a92e: b3cb cmpal %a3,%a1
4a930: 53c1 sls %d1
4a932: 49c1 extbl %d1
4a934: 4481 negl %d1
4a936: 6002 bras 4a93a <_Heap_Free+0xa2>
4a938: 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 ) ) {
4a93a: 4a01 tstb %d1
4a93c: 6700 00be beqw 4a9fc <_Heap_Free+0x164>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4a940: 7201 moveq #1,%d1
4a942: 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) ) {
4a946: 6700 00b4 beqw 4a9fc <_Heap_Free+0x164>
4a94a: d680 addl %d0,%d3
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4a94c: 4a05 tstb %d5
4a94e: 6724 beqs 4a974 <_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;
4a950: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + prev_size + next_block_size;
4a954: d483 addl %d3,%d2
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a956: 7201 moveq #1,%d1
Heap_Block *prev = block->prev;
4a958: 246a 000c moveal %a2@(12),%a2
prev->next = next;
4a95c: 254b 0008 movel %a3,%a2@(8)
4a960: 8282 orl %d2,%d1
next->prev = prev;
4a962: 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;
4a966: 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;
4a96a: 2382 2800 movel %d2,%a1@(00000000,%d2:l)
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a96e: 2341 0004 movel %d1,%a1@(4)
4a972: 6078 bras 4a9ec <_Heap_Free+0x154>
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a974: 7401 moveq #1,%d2
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4a976: 72fe moveq #-2,%d1
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a978: 8483 orl %d3,%d2
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
4a97a: 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;
4a97c: 2342 0004 movel %d2,%a1@(4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4a980: c3aa 0004 andl %d1,%a2@(4)
4a984: 6066 bras 4a9ec <_Heap_Free+0x154>
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
4a986: 4a01 tstb %d1
4a988: 672a beqs 4a9b4 <_Heap_Free+0x11c>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
4a98a: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + next_block_size;
4a98e: 2202 movel %d2,%d1
4a990: d280 addl %d0,%d1
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a992: 7401 moveq #1,%d2
Heap_Block *prev = old_block->prev;
4a994: 246a 000c moveal %a2@(12),%a2
new_block->next = next;
4a998: 234b 0008 movel %a3,%a1@(8)
4a99c: 8481 orl %d1,%d2
new_block->prev = prev;
4a99e: 234a 000c movel %a2,%a1@(12)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4a9a2: 2381 1800 movel %d1,%a1@(00000000,%d1:l)
next->prev = new_block;
4a9a6: 2749 000c movel %a1,%a3@(12)
prev->next = new_block;
4a9aa: 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;
4a9ae: 2342 0004 movel %d2,%a1@(4)
4a9b2: 6038 bras 4a9ec <_Heap_Free+0x154>
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4a9b4: 7201 moveq #1,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4a9b6: 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;
4a9b8: 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;
4a9ba: 2668 0008 moveal %a0@(8),%a3
new_block->next = next;
new_block->prev = block_before;
4a9be: 2348 000c movel %a0,%a1@(12)
4a9c2: 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;
4a9c6: 2228 0038 movel %a0@(56),%d1
4a9ca: 5281 addql #1,%d1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4a9cc: 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;
4a9d0: c5aa 0004 andl %d2,%a2@(4)
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
4a9d4: 2749 000c movel %a1,%a3@(12)
next_block->prev_size = block_size;
4a9d8: 2480 movel %d0,%a2@
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
4a9da: 2149 0008 movel %a1,%a0@(8)
/* Statistics */
++stats->free_blocks;
4a9de: 2141 0038 movel %d1,%a0@(56)
if ( stats->max_free_blocks < stats->free_blocks ) {
4a9e2: b2a8 003c cmpl %a0@(60),%d1
4a9e6: 6304 blss 4a9ec <_Heap_Free+0x154>
stats->max_free_blocks = stats->free_blocks;
4a9e8: 2141 003c movel %d1,%a0@(60)
}
}
/* Statistics */
--stats->used_blocks;
4a9ec: 53a8 0040 subql #1,%a0@(64)
++stats->frees;
4a9f0: 52a8 0050 addql #1,%a0@(80)
stats->free_size += block_size;
4a9f4: 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;
4a9f8: 7001 moveq #1,%d0
4a9fa: 6002 bras 4a9fe <_Heap_Free+0x166>
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
_HAssert( false );
return( false );
4a9fc: 4200 clrb %d0
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4a9fe: 4cd7 0c3c moveml %sp@,%d2-%d5/%a2-%a3
4aa02: 4e5e unlk %fp
...
0005a070 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
5a070: 4e56 0000 linkw %fp,#0
5a074: 202e 000c movel %fp@(12),%d0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
5a078: 2040 moveal %d0,%a0
5a07a: 5188 subql #8,%a0
5a07c: 226e 0008 moveal %fp@(8),%a1
5a080: 2f02 movel %d2,%sp@-
5a082: 2400 movel %d0,%d2
5a084: 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
5a08a: 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);
5a08e: 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;
5a090: b488 cmpl %a0,%d2
5a092: 620c bhis 5a0a0 <_Heap_Size_of_alloc_area+0x30>
5a094: b1e9 0024 cmpal %a1@(36),%a0
5a098: 53c1 sls %d1
5a09a: 49c1 extbl %d1
5a09c: 4481 negl %d1
5a09e: 6002 bras 5a0a2 <_Heap_Size_of_alloc_area+0x32>
5a0a0: 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 ) ) {
5a0a2: 4a01 tstb %d1
5a0a4: 673a beqs 5a0e0 <_Heap_Size_of_alloc_area+0x70>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
5a0a6: 72fe moveq #-2,%d1
5a0a8: 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);
5a0ac: 41f0 1800 lea %a0@(00000000,%d1:l),%a0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
5a0b0: b488 cmpl %a0,%d2
5a0b2: 620c bhis 5a0c0 <_Heap_Size_of_alloc_area+0x50> <== NEVER TAKEN
5a0b4: b1e9 0024 cmpal %a1@(36),%a0
5a0b8: 53c1 sls %d1
5a0ba: 49c1 extbl %d1
5a0bc: 4481 negl %d1
5a0be: 6002 bras 5a0c2 <_Heap_Size_of_alloc_area+0x52>
5a0c0: 4281 clrl %d1 <== NOT EXECUTED
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
5a0c2: 4a01 tstb %d1
5a0c4: 671a beqs 5a0e0 <_Heap_Size_of_alloc_area+0x70> <== NEVER TAKEN
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
5a0c6: 7201 moveq #1,%d1
5a0c8: c2a8 0004 andl %a0@(4),%d1
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
5a0cc: 6712 beqs 5a0e0 <_Heap_Size_of_alloc_area+0x70> <== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
5a0ce: 7204 moveq #4,%d1
5a0d0: 9280 subl %d0,%d1
5a0d2: 2001 movel %d1,%d0
5a0d4: d088 addl %a0,%d0
5a0d6: 226e 0010 moveal %fp@(16),%a1
5a0da: 2280 movel %d0,%a1@
return true;
5a0dc: 7001 moveq #1,%d0
5a0de: 6002 bras 5a0e2 <_Heap_Size_of_alloc_area+0x72>
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
5a0e0: 4200 clrb %d0
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
5a0e2: 241f movel %sp@+,%d2
5a0e4: 4e5e unlk %fp <== NOT EXECUTED
000473be <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
473be: 4e56 ffd0 linkw %fp,#-48
473c2: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
473c6: 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;
473ca: 45fa ffac lea %pc@(47378 <_Heap_Walk_print_nothing>),%a2
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
473ce: 242e 000c movel %fp@(12),%d2
uintptr_t const page_size = heap->page_size;
473d2: 282b 0010 movel %a3@(16),%d4
uintptr_t const min_block_size = heap->min_block_size;
473d6: 2a2b 0014 movel %a3@(20),%d5
Heap_Block *const first_block = heap->first_block;
473da: 2c2b 0020 movel %a3@(32),%d6
Heap_Block *const last_block = heap->last_block;
473de: 2e2b 0024 movel %a3@(36),%d7
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
473e2: 4a2e 0013 tstb %fp@(19)
473e6: 6704 beqs 473ec <_Heap_Walk+0x2e>
473e8: 45fa ff96 lea %pc@(47380 <_Heap_Walk_print>),%a2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
473ec: 7003 moveq #3,%d0
473ee: b0b9 0005 fae0 cmpl 5fae0 <_System_state_Current>,%d0
473f4: 6600 02fc bnew 476f2 <_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)(
473f8: 2f2b 000c movel %a3@(12),%sp@-
473fc: 2f2b 0008 movel %a3@(8),%sp@-
47400: 2f07 movel %d7,%sp@-
47402: 2f06 movel %d6,%sp@-
47404: 2f2b 001c movel %a3@(28),%sp@-
47408: 2f2b 0018 movel %a3@(24),%sp@-
4740c: 2f05 movel %d5,%sp@-
4740e: 2f04 movel %d4,%sp@-
47410: 4879 0005 bfa7 pea 5bfa7 <_Status_Object_name_errors_to_status+0x5d>
47416: 42a7 clrl %sp@-
47418: 2f02 movel %d2,%sp@-
4741a: 4e92 jsr %a2@
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
4741c: 4fef 002c lea %sp@(44),%sp
47420: 4a84 tstl %d4
47422: 6608 bnes 4742c <_Heap_Walk+0x6e>
(*printer)( source, true, "page size is zero\n" );
47424: 4879 0005 c038 pea 5c038 <_Status_Object_name_errors_to_status+0xee>
4742a: 606c bras 47498 <_Heap_Walk+0xda>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
4742c: 7003 moveq #3,%d0
4742e: c084 andl %d4,%d0
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
47430: 670c beqs 4743e <_Heap_Walk+0x80>
(*printer)(
47432: 2f04 movel %d4,%sp@-
47434: 4879 0005 c04b pea 5c04b <_Status_Object_name_errors_to_status+0x101>
4743a: 6000 02ca braw 47706 <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4743e: 2205 movel %d5,%d1
47440: 4c44 1000 remul %d4,%d0,%d1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
47444: 4a80 tstl %d0
47446: 670c beqs 47454 <_Heap_Walk+0x96>
(*printer)(
47448: 2f05 movel %d5,%sp@-
4744a: 4879 0005 c069 pea 5c069 <_Status_Object_name_errors_to_status+0x11f>
47450: 6000 02b4 braw 47706 <_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;
47454: 2006 movel %d6,%d0
47456: 5080 addql #8,%d0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
47458: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if (
4745c: 4a81 tstl %d1
4745e: 670c beqs 4746c <_Heap_Walk+0xae>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
47460: 2f06 movel %d6,%sp@-
47462: 4879 0005 c08d pea 5c08d <_Status_Object_name_errors_to_status+0x143>
47468: 6000 029c braw 47706 <_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;
4746c: 7001 moveq #1,%d0
4746e: 2046 moveal %d6,%a0
47470: c0a8 0004 andl %a0@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
47474: 6608 bnes 4747e <_Heap_Walk+0xc0>
(*printer)(
47476: 4879 0005 c0be pea 5c0be <_Status_Object_name_errors_to_status+0x174>
4747c: 601a bras 47498 <_Heap_Walk+0xda>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4747e: 70fe moveq #-2,%d0
47480: 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);
47482: 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;
47484: 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);
47488: 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;
4748a: 7001 moveq #1,%d0
4748c: c0ac 0004 andl %a4@(4),%d0
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
47490: 6616 bnes 474a8 <_Heap_Walk+0xea>
(*printer)(
47492: 4879 0005 c0ec pea 5c0ec <_Status_Object_name_errors_to_status+0x1a2>
47498: 4878 0001 pea 1 <ADD>
4749c: 2f02 movel %d2,%sp@-
4749e: 4e92 jsr %a2@
474a0: 4fef 000c lea %sp@(12),%sp
474a4: 6000 009e braw 47544 <_Heap_Walk+0x186>
);
return false;
}
if (
474a8: bc8c cmpl %a4,%d6
474aa: 6708 beqs 474b4 <_Heap_Walk+0xf6>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
474ac: 4879 0005 c101 pea 5c101 <_Status_Object_name_errors_to_status+0x1b7>
474b2: 60e4 bras 47498 <_Heap_Walk+0xda>
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
474b4: 262b 0010 movel %a3@(16),%d3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
474b8: 220b movel %a3,%d1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
474ba: 206b 0008 moveal %a3@(8),%a0
474be: 2d44 fff8 movel %d4,%fp@(-8)
474c2: 2d43 fffc movel %d3,%fp@(-4)
474c6: 6000 0088 braw 47550 <_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;
474ca: b1eb 0020 cmpal %a3@(32),%a0
474ce: 650c bcss 474dc <_Heap_Walk+0x11e>
474d0: b1eb 0024 cmpal %a3@(36),%a0
474d4: 53c0 sls %d0
474d6: 49c0 extbl %d0
474d8: 4480 negl %d0
474da: 6002 bras 474de <_Heap_Walk+0x120>
474dc: 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 ) ) {
474de: 4a00 tstb %d0
474e0: 660c bnes 474ee <_Heap_Walk+0x130>
(*printer)(
474e2: 2f08 movel %a0,%sp@-
474e4: 4879 0005 c130 pea 5c130 <_Status_Object_name_errors_to_status+0x1e6>
474ea: 6000 021a braw 47706 <_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;
474ee: 4be8 0008 lea %a0@(8),%a5
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
474f2: 200d movel %a5,%d0
474f4: 262e fffc movel %fp@(-4),%d3
474f8: 4c43 0004 remul %d3,%d4,%d0
);
return false;
}
if (
474fc: 4a84 tstl %d4
474fe: 670c beqs 4750c <_Heap_Walk+0x14e>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
47500: 2f08 movel %a0,%sp@-
47502: 4879 0005 c150 pea 5c150 <_Status_Object_name_errors_to_status+0x206>
47508: 6000 01fc braw 47706 <_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;
4750c: 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;
4750e: 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;
47510: 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;
47514: c6b0 0804 andl %a0@(00000004,%d0:l),%d3
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
47518: 670c beqs 47526 <_Heap_Walk+0x168>
(*printer)(
4751a: 2f08 movel %a0,%sp@-
4751c: 4879 0005 c180 pea 5c180 <_Status_Object_name_errors_to_status+0x236>
47522: 6000 01e2 braw 47706 <_Heap_Walk+0x348>
);
return false;
}
if ( free_block->prev != prev_block ) {
47526: 2028 000c movel %a0@(12),%d0
4752a: b280 cmpl %d0,%d1
4752c: 671c beqs 4754a <_Heap_Walk+0x18c>
(*printer)(
4752e: 2f00 movel %d0,%sp@-
47530: 2f08 movel %a0,%sp@-
47532: 4879 0005 c19c pea 5c19c <_Status_Object_name_errors_to_status+0x252>
47538: 4878 0001 pea 1 <ADD>
4753c: 2f02 movel %d2,%sp@-
4753e: 4e92 jsr %a2@
47540: 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;
47544: 4200 clrb %d0
47546: 6000 01ac braw 476f4 <_Heap_Walk+0x336>
return false;
}
prev_block = free_block;
free_block = free_block->next;
4754a: 2208 movel %a0,%d1
4754c: 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 ) {
47550: b7c8 cmpal %a0,%a3
47552: 6600 ff76 bnew 474ca <_Heap_Walk+0x10c>
47556: 282e fff8 movel %fp@(-8),%d4
4755a: 6002 bras 4755e <_Heap_Walk+0x1a0>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
4755c: 284d moveal %a5,%a4
return true;
}
4755e: 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;
47562: 76fe moveq #-2,%d3
47564: c680 andl %d0,%d3
47566: 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);
4756a: 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;
4756e: bbeb 0020 cmpal %a3@(32),%a5
47572: 650c bcss 47580 <_Heap_Walk+0x1c2> <== NEVER TAKEN
47574: bbeb 0024 cmpal %a3@(36),%a5
47578: 53c0 sls %d0
4757a: 49c0 extbl %d0
4757c: 4480 negl %d0
4757e: 6002 bras 47582 <_Heap_Walk+0x1c4>
47580: 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 ) ) {
47582: 4a00 tstb %d0
47584: 660c bnes 47592 <_Heap_Walk+0x1d4>
(*printer)(
47586: 2f0d movel %a5,%sp@-
47588: 2f0c movel %a4,%sp@-
4758a: 4879 0005 c1ce pea 5c1ce <_Status_Object_name_errors_to_status+0x284>
47590: 60a6 bras 47538 <_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;
47592: be8c cmpl %a4,%d7
47594: 56c0 sne %d0
47596: 2200 movel %d0,%d1
47598: 4481 negl %d1
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4759a: 2003 movel %d3,%d0
4759c: 1d41 fffb moveb %d1,%fp@(-5)
475a0: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
475a4: 4a81 tstl %d1
475a6: 6714 beqs 475bc <_Heap_Walk+0x1fe>
475a8: 4a2e fffb tstb %fp@(-5)
475ac: 670e beqs 475bc <_Heap_Walk+0x1fe>
(*printer)(
475ae: 2f03 movel %d3,%sp@-
475b0: 2f0c movel %a4,%sp@-
475b2: 4879 0005 c1fb pea 5c1fb <_Status_Object_name_errors_to_status+0x2b1>
475b8: 6000 ff7e braw 47538 <_Heap_Walk+0x17a>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
475bc: ba83 cmpl %d3,%d5
475be: 6322 blss 475e2 <_Heap_Walk+0x224>
475c0: 4a2e fffb tstb %fp@(-5)
475c4: 671c beqs 475e2 <_Heap_Walk+0x224> <== NEVER TAKEN
(*printer)(
475c6: 2f05 movel %d5,%sp@-
475c8: 2f03 movel %d3,%sp@-
475ca: 2f0c movel %a4,%sp@-
475cc: 4879 0005 c229 pea 5c229 <_Status_Object_name_errors_to_status+0x2df>
475d2: 4878 0001 pea 1 <ADD>
475d6: 2f02 movel %d2,%sp@-
475d8: 4e92 jsr %a2@
block,
block_size,
min_block_size
);
return false;
475da: 4fef 0018 lea %sp@(24),%sp
475de: 6000 ff64 braw 47544 <_Heap_Walk+0x186>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
475e2: b9cd cmpal %a5,%a4
475e4: 6514 bcss 475fa <_Heap_Walk+0x23c>
475e6: 4a2e fffb tstb %fp@(-5)
475ea: 670e beqs 475fa <_Heap_Walk+0x23c>
(*printer)(
475ec: 2f0d movel %a5,%sp@-
475ee: 2f0c movel %a4,%sp@-
475f0: 4879 0005 c254 pea 5c254 <_Status_Object_name_errors_to_status+0x30a>
475f6: 6000 ff40 braw 47538 <_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;
475fa: 7001 moveq #1,%d0
475fc: c0ae fffc andl %fp@(-4),%d0
47600: 2d40 fffc movel %d0,%fp@(-4)
47604: 7001 moveq #1,%d0
47606: c0ad 0004 andl %a5@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
4760a: 6600 00ae bnew 476ba <_Heap_Walk+0x2fc>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
4760e: 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)(
47612: 43f9 0005 bf74 lea 5bf74 <_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 ?
47618: 206c 0008 moveal %a4@(8),%a0
4761c: 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)(
47620: b1eb 000c cmpal %a3@(12),%a0
47624: 6710 beqs 47636 <_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)" : "")
47626: 43f9 0005 bec0 lea 5bec0 <rtems_filesystem_default_pathconf+0xb4>,%a1
4762c: b7c8 cmpal %a0,%a3
4762e: 6606 bnes 47636 <_Heap_Walk+0x278>
47630: 43f9 0005 bf83 lea 5bf83 <_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 ?
47636: 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)(
4763a: 223c 0005 bf8d movel #376717,%d1
47640: b0ae fff8 cmpl %fp@(-8),%d0
47644: 6710 beqs 47656 <_Heap_Walk+0x298>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
47646: 223c 0005 bec0 movel #376512,%d1
4764c: b7c0 cmpal %d0,%a3
4764e: 6606 bnes 47656 <_Heap_Walk+0x298>
47650: 223c 0005 bf9d movel #376733,%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)(
47656: 2f09 movel %a1,%sp@-
47658: 2f08 movel %a0,%sp@-
4765a: 2f01 movel %d1,%sp@-
4765c: 2f00 movel %d0,%sp@-
4765e: 2f03 movel %d3,%sp@-
47660: 2f0c movel %a4,%sp@-
47662: 4879 0005 c288 pea 5c288 <_Status_Object_name_errors_to_status+0x33e>
47668: 42a7 clrl %sp@-
4766a: 2f02 movel %d2,%sp@-
4766c: 4e92 jsr %a2@
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
4766e: 2015 movel %a5@,%d0
47670: 4fef 0024 lea %sp@(36),%sp
47674: b083 cmpl %d3,%d0
47676: 671e beqs 47696 <_Heap_Walk+0x2d8>
(*printer)(
47678: 2f0d movel %a5,%sp@-
4767a: 2f00 movel %d0,%sp@-
4767c: 2f03 movel %d3,%sp@-
4767e: 2f0c movel %a4,%sp@-
47680: 4879 0005 c2bd pea 5c2bd <_Status_Object_name_errors_to_status+0x373>
47686: 4878 0001 pea 1 <ADD>
4768a: 2f02 movel %d2,%sp@-
4768c: 4e92 jsr %a2@
4768e: 4fef 001c lea %sp@(28),%sp
47692: 6000 feb0 braw 47544 <_Heap_Walk+0x186>
);
return false;
}
if ( !prev_used ) {
47696: 4aae fffc tstl %fp@(-4)
4769a: 660a bnes 476a6 <_Heap_Walk+0x2e8>
(*printer)(
4769c: 2f0c movel %a4,%sp@-
4769e: 4879 0005 c2f6 pea 5c2f6 <_Status_Object_name_errors_to_status+0x3ac>
476a4: 6060 bras 47706 <_Heap_Walk+0x348>
476a6: 206b 0008 moveal %a3@(8),%a0
476aa: 6008 bras 476b4 <_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 ) {
476ac: b9c8 cmpal %a0,%a4
476ae: 673c beqs 476ec <_Heap_Walk+0x32e>
return true;
}
free_block = free_block->next;
476b0: 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 ) {
476b4: b7c8 cmpal %a0,%a3
476b6: 66f4 bnes 476ac <_Heap_Walk+0x2ee>
476b8: 6044 bras 476fe <_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) {
476ba: 4aae fffc tstl %fp@(-4)
476be: 6716 beqs 476d6 <_Heap_Walk+0x318>
(*printer)(
476c0: 2f03 movel %d3,%sp@-
476c2: 2f0c movel %a4,%sp@-
476c4: 4879 0005 c325 pea 5c325 <_Status_Object_name_errors_to_status+0x3db>
476ca: 42a7 clrl %sp@-
476cc: 2f02 movel %d2,%sp@-
476ce: 4e92 jsr %a2@
476d0: 4fef 0014 lea %sp@(20),%sp
476d4: 6016 bras 476ec <_Heap_Walk+0x32e>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
476d6: 2f14 movel %a4@,%sp@-
476d8: 2f03 movel %d3,%sp@-
476da: 2f0c movel %a4,%sp@-
476dc: 4879 0005 c33c pea 5c33c <_Status_Object_name_errors_to_status+0x3f2>
476e2: 42a7 clrl %sp@-
476e4: 2f02 movel %d2,%sp@-
476e6: 4e92 jsr %a2@
476e8: 4fef 0018 lea %sp@(24),%sp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
476ec: bc8d cmpl %a5,%d6
476ee: 6600 fe6c bnew 4755c <_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;
476f2: 7001 moveq #1,%d0
block = next_block;
} while ( block != first_block );
return true;
}
476f4: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
476fa: 4e5e unlk %fp
476fc: 4e75 rts
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
476fe: 2f0c movel %a4,%sp@-
47700: 4879 0005 c361 pea 5c361 <_Status_Object_name_errors_to_status+0x417>
47706: 4878 0001 pea 1 <ADD>
4770a: 2f02 movel %d2,%sp@-
4770c: 4e92 jsr %a2@
4770e: 4fef 0010 lea %sp@(16),%sp
47712: 6000 fe30 braw 47544 <_Heap_Walk+0x186>
...
00046b84 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
46b84: 4e56 0000 linkw %fp,#0
46b88: 222e 000c movel %fp@(12),%d1
46b8c: 2f02 movel %d2,%sp@-
46b8e: 242e 0010 movel %fp@(16),%d2
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
46b92: 13c1 0005 d8c2 moveb %d1,5d8c2 <_Internal_errors_What_happened+0x4>
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
46b98: 2f02 movel %d2,%sp@-
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
46b9a: 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 );
46b9e: 0281 0000 00ff andil #255,%d1
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
46ba4: 23c0 0005 d8be movel %d0,5d8be <_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 );
46baa: 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;
46bac: 23c2 0005 d8c4 movel %d2,5d8c4 <_Internal_errors_What_happened+0x6>
_User_extensions_Fatal( the_source, is_internal, the_error );
46bb2: 2f00 movel %d0,%sp@-
46bb4: 4eb9 0004 875a jsr 4875a <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
46bba: 7005 moveq #5,%d0
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
46bbc: 2042 moveal %d2,%a0
46bbe: 243c 0000 0700 movel #1792,%d2
46bc4: 23c0 0005 d968 movel %d0,5d968 <_System_state_Current>
46bca: 40c0 movew %sr,%d0
46bcc: 8082 orl %d2,%d0
46bce: 46c0 movew %d0,%sr
46bd0: 2008 movel %a0,%d0 <== NOT EXECUTED
46bd2: 223c dead beef movel #-559038737,%d1 <== NOT EXECUTED
46bd8: 4ac8 halt <== NOT EXECUTED
46bda: 4fef 000c lea %sp@(12),%sp
46bde: 60fe bras 46bde <_Internal_error_Occurred+0x5a>
00046c40 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
46c40: 4e56 fff0 linkw %fp,#-16
46c44: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
46c48: 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 )
46c4c: 4aaa 0014 tstl %a2@(20)
46c50: 675e beqs 46cb0 <_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 );
46c52: 240a movel %a2,%d2
46c54: 0682 0000 001c addil #28,%d2
46c5a: 47f9 0004 63bc lea 463bc <_Chain_Get>,%a3
46c60: 2f02 movel %d2,%sp@-
46c62: 4e93 jsr %a3@
if ( information->auto_extend ) {
46c64: 588f addql #4,%sp
46c66: 4a2a 0010 tstb %a2@(16)
46c6a: 6746 beqs 46cb2 <_Objects_Allocate+0x72>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
46c6c: 4a80 tstl %d0
46c6e: 6612 bnes 46c82 <_Objects_Allocate+0x42>
_Objects_Extend_information( information );
46c70: 2f0a movel %a2,%sp@-
46c72: 4eb9 0004 6ce4 jsr 46ce4 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
46c78: 2f02 movel %d2,%sp@-
46c7a: 4e93 jsr %a3@
}
if ( the_object ) {
46c7c: 508f addql #8,%sp
46c7e: 4a80 tstl %d0
46c80: 6730 beqs 46cb2 <_Objects_Allocate+0x72>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46c82: 2040 moveal %d0,%a0
46c84: 4281 clrl %d1
46c86: 4282 clrl %d2
46c88: 3228 000a movew %a0@(10),%d1
46c8c: 342a 0008 movew %a2@(8),%d2
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
46c90: 206a 002a moveal %a2@(42),%a0
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46c94: 9282 subl %d2,%d1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
46c96: 342a 0012 movew %a2@(18),%d2
46c9a: 4c42 1001 remul %d2,%d1,%d1
information->inactive_per_block[ block ]--;
46c9e: e589 lsll #2,%d1
46ca0: d1c1 addal %d1,%a0
46ca2: 5390 subql #1,%a0@
information->inactive--;
46ca4: 322a 0028 movew %a2@(40),%d1
46ca8: 5381 subql #1,%d1
46caa: 3541 0028 movew %d1,%a2@(40)
46cae: 6002 bras 46cb2 <_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;
46cb0: 4280 clrl %d0 <== NOT EXECUTED
);
}
#endif
return the_object;
}
46cb2: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
46cb8: 4e5e unlk %fp <== NOT EXECUTED
00046cbc <_Objects_Close>:
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46cbc: 4280 clrl %d0
void _Objects_Close(
Objects_Information *information,
Objects_Control *the_object
)
{
46cbe: 4e56 0000 linkw %fp,#0
46cc2: 206e 0008 moveal %fp@(8),%a0
46cc6: 226e 000c moveal %fp@(12),%a1
46cca: 2f0a movel %a2,%sp@-
46ccc: 2468 0018 moveal %a0@(24),%a2
46cd0: 3029 000a movew %a1@(10),%d0
46cd4: 42b2 0c00 clrl %a2@(00000000,%d0:l:4)
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
}
46cd8: 245f moveal %sp@+,%a2
46cda: 4e5e unlk %fp
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
46cdc: 4ef9 0004 71ec jmp 471ec <_Objects_Namespace_remove>
...
00046fec <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
46fec: 4e56 0000 linkw %fp,#0
46ff0: 2f03 movel %d3,%sp@-
46ff2: 362e 000e movew %fp@(14),%d3
46ff6: 2f02 movel %d2,%sp@-
46ff8: 242e 0008 movel %fp@(8),%d2
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
46ffc: 4a43 tstw %d3
46ffe: 673a beqs 4703a <_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 );
47000: 2f02 movel %d2,%sp@-
47002: 4eb9 0004 aa08 jsr 4aa08 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
47008: 588f addql #4,%sp
4700a: 4a80 tstl %d0
4700c: 672c beqs 4703a <_Objects_Get_information+0x4e>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
4700e: 0283 0000 ffff andil #65535,%d3
47014: b083 cmpl %d3,%d0
47016: 6522 bcss 4703a <_Objects_Get_information+0x4e>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
47018: 41f9 0005 d7e4 lea 5d7e4 <_Objects_Information_table>,%a0
4701e: 2070 2c00 moveal %a0@(00000000,%d2:l:4),%a0
47022: 4a88 tstl %a0
47024: 6714 beqs 4703a <_Objects_Get_information+0x4e> <== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
47026: 2030 3c00 movel %a0@(00000000,%d3:l:4),%d0
if ( !info )
4702a: 6710 beqs 4703c <_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;
4702c: 2040 moveal %d0,%a0
4702e: 4a68 000e tstw %a0@(14)
47032: 56c1 sne %d1
47034: 49c1 extbl %d1
47036: c081 andl %d1,%d0
47038: 6002 bras 4703c <_Objects_Get_information+0x50>
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
return NULL;
4703a: 4280 clrl %d0
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
4703c: 242e fff8 movel %fp@(-8),%d2
47040: 262e fffc movel %fp@(-4),%d3
47044: 4e5e unlk %fp <== NOT EXECUTED
00053ce0 <_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;
53ce0: 7001 moveq #1,%d0
if ( information->maximum >= index ) {
53ce2: 4281 clrl %d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
53ce4: 4e56 0000 linkw %fp,#0
53ce8: 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;
53cec: 90a8 0006 subl %a0@(6),%d0
53cf0: d0ae 000c addl %fp@(12),%d0
if ( information->maximum >= index ) {
53cf4: 3228 000e movew %a0@(14),%d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
53cf8: 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 ) {
53cfc: b081 cmpl %d1,%d0
53cfe: 620e bhis 53d0e <_Objects_Get_no_protection+0x2e>
if ( (the_object = information->local_table[ index ]) != NULL ) {
53d00: 2068 0018 moveal %a0@(24),%a0
53d04: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
53d08: 6704 beqs 53d0e <_Objects_Get_no_protection+0x2e><== NEVER TAKEN
*location = OBJECTS_LOCAL;
53d0a: 4291 clrl %a1@
return the_object;
53d0c: 6006 bras 53d14 <_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;
53d0e: 7001 moveq #1,%d0
53d10: 2280 movel %d0,%a1@
return NULL;
53d12: 4280 clrl %d0
}
53d14: 4e5e unlk %fp <== NOT EXECUTED
000477a4 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
477a4: 4e56 fffc linkw %fp,#-4
477a8: 222e 0008 movel %fp@(8),%d1
477ac: 2f02 movel %d2,%sp@-
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
477ae: 4a81 tstl %d1
477b0: 660a bnes 477bc <_Objects_Id_to_name+0x18>
477b2: 2079 0005 e914 moveal 5e914 <_Per_CPU_Information+0xc>,%a0
477b8: 2228 0008 movel %a0@(8),%d1
477bc: 7418 moveq #24,%d2
477be: 2001 movel %d1,%d0
477c0: e4a8 lsrl %d2,%d0
477c2: 143c 0007 moveb #7,%d2
477c6: c082 andl %d2,%d0
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
477c8: 143c 0002 moveb #2,%d2
477cc: 2040 moveal %d0,%a0
477ce: 5388 subql #1,%a0
477d0: b488 cmpl %a0,%d2
477d2: 6538 bcss 4780c <_Objects_Id_to_name+0x68>
477d4: 6040 bras 47816 <_Objects_Id_to_name+0x72>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
477d6: 2001 movel %d1,%d0
477d8: 741b moveq #27,%d2
477da: 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 ];
477dc: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
if ( !information )
477e0: 672a beqs 4780c <_Objects_Id_to_name+0x68> <== NEVER TAKEN
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
477e2: 486e fffc pea %fp@(-4)
477e6: 2f01 movel %d1,%sp@-
477e8: 2f00 movel %d0,%sp@-
477ea: 4eb9 0004 773c jsr 4773c <_Objects_Get>
if ( !the_object )
477f0: 4fef 000c lea %sp@(12),%sp
477f4: 4a80 tstl %d0
477f6: 6714 beqs 4780c <_Objects_Id_to_name+0x68>
return OBJECTS_INVALID_ID;
*name = the_object->name;
477f8: 206e 000c moveal %fp@(12),%a0
477fc: 2240 moveal %d0,%a1
477fe: 20a9 000c movel %a1@(12),%a0@
_Thread_Enable_dispatch();
47802: 4eb9 0004 8374 jsr 48374 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
47808: 4280 clrl %d0
4780a: 6002 bras 4780e <_Objects_Id_to_name+0x6a>
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;
4780c: 7003 moveq #3,%d0
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
4780e: 242e fff8 movel %fp@(-8),%d2
47812: 4e5e unlk %fp
47814: 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 ] )
47816: 41f9 0005 e73c lea 5e73c <_Objects_Information_table>,%a0
4781c: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
47820: 4a88 tstl %a0
47822: 66b2 bnes 477d6 <_Objects_Id_to_name+0x32>
47824: 60e6 bras 4780c <_Objects_Id_to_name+0x68>
...
0004b31e <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
4b31e: 4e56 ffec linkw %fp,#-20
4b322: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
4b326: 286e 0008 moveal %fp@(8),%a4
4b32a: 246e 000c moveal %fp@(12),%a2
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
4b32e: 4a8a tstl %a2
4b330: 6700 0110 beqw 4b442 <_RBTree_Extract_unprotected+0x124>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
4b334: b5ec 0008 cmpal %a4@(8),%a2
4b338: 661a bnes 4b354 <_RBTree_Extract_unprotected+0x36>
if (the_node->child[RBT_RIGHT])
4b33a: 202a 0008 movel %a2@(8),%d0
4b33e: 6706 beqs 4b346 <_RBTree_Extract_unprotected+0x28>
the_rbtree->first[RBT_LEFT] = the_node->child[RBT_RIGHT];
4b340: 2940 0008 movel %d0,%a4@(8)
4b344: 600e bras 4b354 <_RBTree_Extract_unprotected+0x36>
else {
the_rbtree->first[RBT_LEFT] = the_node->parent;
4b346: 2012 movel %a2@,%d0
4b348: 2940 0008 movel %d0,%a4@(8)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
4b34c: b08c cmpl %a4,%d0
4b34e: 6604 bnes 4b354 <_RBTree_Extract_unprotected+0x36>
the_rbtree->first[RBT_LEFT]))
the_rbtree->first[RBT_LEFT] = NULL;
4b350: 42ac 0008 clrl %a4@(8)
4b354: 2a6a 0004 moveal %a2@(4),%a5
}
}
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
4b358: b5ec 000c cmpal %a4@(12),%a2
4b35c: 6618 bnes 4b376 <_RBTree_Extract_unprotected+0x58>
if (the_node->child[RBT_LEFT])
4b35e: 4a8d tstl %a5
4b360: 6706 beqs 4b368 <_RBTree_Extract_unprotected+0x4a>
the_rbtree->first[RBT_RIGHT] = the_node->child[RBT_LEFT];
4b362: 294d 000c movel %a5,%a4@(12)
4b366: 600e bras 4b376 <_RBTree_Extract_unprotected+0x58>
else {
the_rbtree->first[RBT_RIGHT] = the_node->parent;
4b368: 2012 movel %a2@,%d0
4b36a: 2940 000c movel %d0,%a4@(12)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
4b36e: b08c cmpl %a4,%d0
4b370: 6604 bnes 4b376 <_RBTree_Extract_unprotected+0x58>
the_rbtree->first[RBT_RIGHT]))
the_rbtree->first[RBT_RIGHT] = NULL;
4b372: 42ac 000c clrl %a4@(12)
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
4b376: 264d moveal %a5,%a3
4b378: 4a8d tstl %a5
4b37a: 6778 beqs 4b3f4 <_RBTree_Extract_unprotected+0xd6>
4b37c: 4aaa 0008 tstl %a2@(8)
4b380: 6604 bnes 4b386 <_RBTree_Extract_unprotected+0x68>
4b382: 6078 bras 4b3fc <_RBTree_Extract_unprotected+0xde>
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
4b384: 2640 moveal %d0,%a3
4b386: 202b 0008 movel %a3@(8),%d0
4b38a: 66f8 bnes 4b384 <_RBTree_Extract_unprotected+0x66>
* target's position (target is the right child of target->parent)
* when target vacates it. if there is no child, then target->parent
* should become NULL. This may cause the coloring to be violated.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = target->child[RBT_LEFT];
4b38c: 2a6b 0004 moveal %a3@(4),%a5
if(leaf) {
4b390: 4a8d tstl %a5
4b392: 6704 beqs 4b398 <_RBTree_Extract_unprotected+0x7a>
leaf->parent = target->parent;
4b394: 2a93 movel %a3@,%a5@
4b396: 600a bras 4b3a2 <_RBTree_Extract_unprotected+0x84>
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
4b398: 2f0b movel %a3,%sp@-
4b39a: 4eb9 0004 b1d8 jsr 4b1d8 <_RBTree_Extract_validate_unprotected>
4b3a0: 588f addql #4,%sp
}
victim_color = target->color;
dir = target != target->parent->child[0];
4b3a2: 2053 moveal %a3@,%a0
4b3a4: b7e8 0004 cmpal %a0@(4),%a3
4b3a8: 56c1 sne %d1
target->parent->child[dir] = leaf;
4b3aa: 7401 moveq #1,%d2
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
4b3ac: 49c1 extbl %d1
target->parent->child[dir] = leaf;
4b3ae: 9481 subl %d1,%d2
4b3b0: 218d 2c00 movel %a5,%a0@(00000000,%d2:l:4)
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
the_node->parent->child[dir] = target;
4b3b4: 7401 moveq #1,%d2
victim_color = target->color;
dir = target != target->parent->child[0];
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4b3b6: 2052 moveal %a2@,%a0
4b3b8: b5e8 0004 cmpal %a0@(4),%a2
4b3bc: 56c1 sne %d1
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
4b3be: 202b 000c movel %a3@(12),%d0
dir = target != target->parent->child[0];
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4b3c2: 49c1 extbl %d1
the_node->parent->child[dir] = target;
4b3c4: 9481 subl %d1,%d2
4b3c6: 218b 2c00 movel %a3,%a0@(00000000,%d2:l:4)
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
4b3ca: 276a 0008 0008 movel %a2@(8),%a3@(8)
if (the_node->child[RBT_RIGHT])
4b3d0: 206a 0008 moveal %a2@(8),%a0
4b3d4: 4a88 tstl %a0
4b3d6: 6702 beqs 4b3da <_RBTree_Extract_unprotected+0xbc><== NEVER TAKEN
the_node->child[RBT_RIGHT]->parent = target;
4b3d8: 208b movel %a3,%a0@
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
4b3da: 276a 0004 0004 movel %a2@(4),%a3@(4)
if (the_node->child[RBT_LEFT])
4b3e0: 206a 0004 moveal %a2@(4),%a0
4b3e4: 4a88 tstl %a0
4b3e6: 6702 beqs 4b3ea <_RBTree_Extract_unprotected+0xcc>
the_node->child[RBT_LEFT]->parent = target;
4b3e8: 208b movel %a3,%a0@
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
4b3ea: 2692 movel %a2@,%a3@
target->color = the_node->color;
4b3ec: 276a 000c 000c movel %a2@(12),%a3@(12)
4b3f2: 602c bras 4b420 <_RBTree_Extract_unprotected+0x102>
* the_node's location in the tree. This may cause the coloring to be
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
4b3f4: 2a6a 0008 moveal %a2@(8),%a5
if( leaf ) {
4b3f8: 4a8d tstl %a5
4b3fa: 6704 beqs 4b400 <_RBTree_Extract_unprotected+0xe2>
leaf->parent = the_node->parent;
4b3fc: 2a92 movel %a2@,%a5@
4b3fe: 600a bras 4b40a <_RBTree_Extract_unprotected+0xec>
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
4b400: 2f0a movel %a2,%sp@-
4b402: 4eb9 0004 b1d8 jsr 4b1d8 <_RBTree_Extract_validate_unprotected>
4b408: 588f addql #4,%sp
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4b40a: 2052 moveal %a2@,%a0
4b40c: b5e8 0004 cmpal %a0@(4),%a2
4b410: 56c1 sne %d1
the_node->parent->child[dir] = leaf;
4b412: 7401 moveq #1,%d2
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4b414: 49c1 extbl %d1
the_node->parent->child[dir] = leaf;
4b416: 9481 subl %d1,%d2
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
4b418: 202a 000c movel %a2@(12),%d0
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
the_node->parent->child[dir] = leaf;
4b41c: 218d 2c00 movel %a5,%a0@(00000000,%d2:l:4)
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
4b420: 4a80 tstl %d0
4b422: 6608 bnes 4b42c <_RBTree_Extract_unprotected+0x10e>
if (leaf) {
4b424: 4a8d tstl %a5
4b426: 6704 beqs 4b42c <_RBTree_Extract_unprotected+0x10e>
leaf->color = RBT_BLACK; /* case 2 */
4b428: 42ad 000c clrl %a5@(12)
/* Wipe the_node */
_RBTree_Set_off_rbtree(the_node);
/* set root to black, if it exists */
if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK;
4b42c: 206c 0004 moveal %a4@(4),%a0
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(
RBTree_Node *node
)
{
node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
4b430: 42aa 0008 clrl %a2@(8)
4b434: 42aa 0004 clrl %a2@(4)
4b438: 4292 clrl %a2@
4b43a: 4a88 tstl %a0
4b43c: 6704 beqs 4b442 <_RBTree_Extract_unprotected+0x124>
4b43e: 42a8 000c clrl %a0@(12)
}
4b442: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
4b448: 4e5e unlk %fp <== NOT EXECUTED
0004b1d8 <_RBTree_Extract_validate_unprotected>:
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
4b1d8: 4e56 ffe8 linkw %fp,#-24
4b1dc: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
4b1e0: 266e 0008 moveal %fp@(8),%a3
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
4b1e4: 2453 moveal %a3@,%a2
if(!parent->parent) return;
4b1e6: 4a92 tstl %a2@
4b1e8: 6700 012a beqw 4b314 <_RBTree_Extract_validate_unprotected+0x13c>
sibling = _RBTree_Sibling(the_node);
4b1ec: 2f0b movel %a3,%sp@-
4b1ee: 49fa ff6c lea %pc@(4b15c <_RBTree_Sibling>),%a4
4b1f2: 4e94 jsr %a4@
4b1f4: 588f addql #4,%sp
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
_RBTree_Rotate(parent, dir);
4b1f6: 4bfa ff8e lea %pc@(4b186 <_RBTree_Rotate>),%a5
RBTree_Direction dir;
parent = the_node->parent;
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
4b1fa: 2040 moveal %d0,%a0
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
4b1fc: 6000 00ec braw 4b2ea <_RBTree_Extract_validate_unprotected+0x112>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4b200: 4a88 tstl %a0
4b202: 6730 beqs 4b234 <_RBTree_Extract_validate_unprotected+0x5c><== NEVER TAKEN
4b204: 7001 moveq #1,%d0
4b206: b0a8 000c cmpl %a0@(12),%d0
4b20a: 6628 bnes 4b234 <_RBTree_Extract_validate_unprotected+0x5c>
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
4b20c: b7ea 0004 cmpal %a2@(4),%a3
4b210: 56c2 sne %d2
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
4b212: 2540 000c movel %d0,%a2@(12)
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
4b216: 49c2 extbl %d2
4b218: 4482 negl %d2
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
4b21a: 42a8 000c clrl %a0@(12)
dir = the_node != parent->child[0];
_RBTree_Rotate(parent, dir);
4b21e: 2f02 movel %d2,%sp@-
4b220: 2f0a movel %a2,%sp@-
4b222: 4e95 jsr %a5@
sibling = parent->child[!dir];
4b224: 508f addql #8,%sp
4b226: 4a82 tstl %d2
4b228: 57c0 seq %d0
4b22a: 7201 moveq #1,%d1
4b22c: 49c0 extbl %d0
4b22e: 9280 subl %d0,%d1
4b230: 2072 1c00 moveal %a2@(00000000,%d1:l:4),%a0
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4b234: 2268 0008 moveal %a0@(8),%a1
4b238: 4a89 tstl %a1
4b23a: 670e beqs 4b24a <_RBTree_Extract_validate_unprotected+0x72>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
4b23c: 7001 moveq #1,%d0
4b23e: b0a9 000c cmpl %a1@(12),%d0
4b242: 57c0 seq %d0
4b244: 49c0 extbl %d0
4b246: 4480 negl %d0
4b248: 6002 bras 4b24c <_RBTree_Extract_validate_unprotected+0x74>
4b24a: 4280 clrl %d0
_RBTree_Rotate(parent, dir);
sibling = parent->child[!dir];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4b24c: 4a00 tstb %d0
4b24e: 6630 bnes 4b280 <_RBTree_Extract_validate_unprotected+0xa8>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
4b250: 2268 0004 moveal %a0@(4),%a1
4b254: 4a89 tstl %a1
4b256: 670e beqs 4b266 <_RBTree_Extract_validate_unprotected+0x8e>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
4b258: 7201 moveq #1,%d1
4b25a: b2a9 000c cmpl %a1@(12),%d1
4b25e: 57c0 seq %d0
4b260: 49c0 extbl %d0
4b262: 4480 negl %d0
4b264: 6002 bras 4b268 <_RBTree_Extract_validate_unprotected+0x90>
4b266: 4280 clrl %d0
_RBTree_Rotate(parent, dir);
sibling = parent->child[!dir];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4b268: 4a00 tstb %d0
4b26a: 6614 bnes 4b280 <_RBTree_Extract_validate_unprotected+0xa8>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
4b26c: 7001 moveq #1,%d0
4b26e: 2140 000c movel %d0,%a0@(12)
4b272: b0aa 000c cmpl %a2@(12),%d0
4b276: 6600 008c bnew 4b304 <_RBTree_Extract_validate_unprotected+0x12c>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
4b27a: 42aa 000c clrl %a2@(12)
break;
4b27e: 6078 bras 4b2f8 <_RBTree_Extract_validate_unprotected+0x120>
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
4b280: b7ea 0004 cmpal %a2@(4),%a3
4b284: 56c2 sne %d2
4b286: 49c2 extbl %d2
4b288: 4482 negl %d2
if (!_RBTree_Is_red(sibling->child[!dir])) {
4b28a: 57c3 seq %d3
4b28c: 49c3 extbl %d3
4b28e: 4483 negl %d3
4b290: 2270 3c04 moveal %a0@(00000004,%d3:l:4),%a1
4b294: 4a89 tstl %a1
4b296: 670e beqs 4b2a6 <_RBTree_Extract_validate_unprotected+0xce>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
4b298: 7201 moveq #1,%d1
4b29a: b2a9 000c cmpl %a1@(12),%d1
4b29e: 57c0 seq %d0
4b2a0: 49c0 extbl %d0
4b2a2: 4480 negl %d0
4b2a4: 6002 bras 4b2a8 <_RBTree_Extract_validate_unprotected+0xd0>
4b2a6: 4280 clrl %d0
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
4b2a8: 4a00 tstb %d0
4b2aa: 6620 bnes 4b2cc <_RBTree_Extract_validate_unprotected+0xf4>
sibling->color = RBT_RED;
4b2ac: 7001 moveq #1,%d0
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
4b2ae: 7201 moveq #1,%d1
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
4b2b0: 2270 2c04 moveal %a0@(00000004,%d2:l:4),%a1
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
4b2b4: 2140 000c movel %d0,%a0@(12)
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
4b2b8: b581 eorl %d2,%d1
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
4b2ba: 42a9 000c clrl %a1@(12)
_RBTree_Rotate(sibling, !dir);
4b2be: 2f01 movel %d1,%sp@-
4b2c0: 2f08 movel %a0,%sp@-
4b2c2: 4eba fec2 jsr %pc@(4b186 <_RBTree_Rotate>)
sibling = parent->child[!dir];
4b2c6: 508f addql #8,%sp
4b2c8: 2072 3c04 moveal %a2@(00000004,%d3:l:4),%a0
}
sibling->color = parent->color;
4b2cc: 216a 000c 000c movel %a2@(12),%a0@(12)
parent->color = RBT_BLACK;
sibling->child[!dir]->color = RBT_BLACK;
4b2d2: 2070 3c04 moveal %a0@(00000004,%d3:l:4),%a0
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
sibling = parent->child[!dir];
}
sibling->color = parent->color;
parent->color = RBT_BLACK;
4b2d6: 42aa 000c clrl %a2@(12)
sibling->child[!dir]->color = RBT_BLACK;
4b2da: 42a8 000c clrl %a0@(12)
_RBTree_Rotate(parent, dir);
4b2de: 2f02 movel %d2,%sp@-
4b2e0: 2f0a movel %a2,%sp@-
4b2e2: 4eba fea2 jsr %pc@(4b186 <_RBTree_Rotate>)
break; /* done */
4b2e6: 508f addql #8,%sp
4b2e8: 600e bras 4b2f8 <_RBTree_Extract_validate_unprotected+0x120>
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
4b2ea: 7001 moveq #1,%d0
4b2ec: b0ab 000c cmpl %a3@(12),%d0
4b2f0: 6706 beqs 4b2f8 <_RBTree_Extract_validate_unprotected+0x120>
4b2f2: 4a92 tstl %a2@
4b2f4: 6600 ff0a bnew 4b200 <_RBTree_Extract_validate_unprotected+0x28>
sibling->child[!dir]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4b2f8: 2053 moveal %a3@,%a0
4b2fa: 4a90 tstl %a0@
4b2fc: 6616 bnes 4b314 <_RBTree_Extract_validate_unprotected+0x13c>
4b2fe: 42ab 000c clrl %a3@(12)
4b302: 6010 bras 4b314 <_RBTree_Extract_validate_unprotected+0x13c>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
4b304: 2412 movel %a2@,%d2
sibling = _RBTree_Sibling(the_node);
4b306: 264a moveal %a2,%a3
4b308: 2f0a movel %a2,%sp@-
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
4b30a: 2442 moveal %d2,%a2
sibling = _RBTree_Sibling(the_node);
4b30c: 4e94 jsr %a4@
4b30e: 588f addql #4,%sp
4b310: 2040 moveal %d0,%a0
4b312: 60d6 bras 4b2ea <_RBTree_Extract_validate_unprotected+0x112>
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
4b314: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
4b31a: 4e5e unlk %fp <== NOT EXECUTED
00048a58 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
48a58: 4e56 ffec linkw %fp,#-20
48a5c: 202e 001c movel %fp@(28),%d0
48a60: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
48a64: 246e 0008 moveal %fp@(8),%a2
48a68: 262e 0014 movel %fp@(20),%d3
48a6c: 282e 0018 movel %fp@(24),%d4
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
48a70: 4a8a tstl %a2
48a72: 6734 beqs 48aa8 <_RBTree_Initialize+0x50> <== NEVER TAKEN
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
48a74: 4292 clrl %a2@
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
48a76: 256e 000c 0010 movel %fp@(12),%a2@(16)
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
48a7c: 242e 0010 movel %fp@(16),%d2
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
48a80: 42aa 0004 clrl %a2@(4)
while ( count-- ) {
_RBTree_Insert(the_rbtree, next);
48a84: 47f9 0004 8a2c lea 48a2c <_RBTree_Insert>,%a3
the_rbtree->first[0] = NULL;
48a8a: 42aa 0008 clrl %a2@(8)
the_rbtree->first[1] = NULL;
48a8e: 42aa 000c clrl %a2@(12)
the_rbtree->compare_function = compare_function;
the_rbtree->is_unique = is_unique;
48a92: 1540 0014 moveb %d0,%a2@(20)
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
48a96: 600c bras 48aa4 <_RBTree_Initialize+0x4c>
_RBTree_Insert(the_rbtree, next);
48a98: 2f02 movel %d2,%sp@-
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
48a9a: d484 addl %d4,%d2
48a9c: 5383 subql #1,%d3
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
_RBTree_Insert(the_rbtree, next);
48a9e: 2f0a movel %a2,%sp@-
48aa0: 4e93 jsr %a3@
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
48aa2: 508f addql #8,%sp
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
48aa4: 4a83 tstl %d3
48aa6: 66f0 bnes 48a98 <_RBTree_Initialize+0x40>
_RBTree_Insert(the_rbtree, next);
next = (RBTree_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
}
48aa8: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
48aae: 4e5e unlk %fp
...
0004b15c <_RBTree_Sibling>:
* exists, and NULL if not.
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
RBTree_Node *the_node
)
{
4b15c: 4e56 0000 linkw %fp,#0
4b160: 226e 0008 moveal %fp@(8),%a1
if(!the_node) return NULL;
4b164: 4a89 tstl %a1
4b166: 6718 beqs 4b180 <_RBTree_Sibling+0x24>
if(!(the_node->parent)) return NULL;
4b168: 2051 moveal %a1@,%a0
4b16a: 4a88 tstl %a0
4b16c: 6712 beqs 4b180 <_RBTree_Sibling+0x24> <== NEVER TAKEN
if(!(the_node->parent->parent)) return NULL;
4b16e: 4a90 tstl %a0@
4b170: 670e beqs 4b180 <_RBTree_Sibling+0x24>
if(the_node == the_node->parent->child[RBT_LEFT])
4b172: 2028 0004 movel %a0@(4),%d0
4b176: b089 cmpl %a1,%d0
4b178: 6608 bnes 4b182 <_RBTree_Sibling+0x26>
return the_node->parent->child[RBT_RIGHT];
4b17a: 2028 0008 movel %a0@(8),%d0
4b17e: 6002 bras 4b182 <_RBTree_Sibling+0x26>
RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
4b180: 4280 clrl %d0
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
else
return the_node->parent->child[RBT_LEFT];
}
4b182: 4e5e unlk %fp <== NOT EXECUTED
0004b4ca <_RBTree_Validate_insert_unprotected>:
* append operation.
*/
void _RBTree_Validate_insert_unprotected(
RBTree_Node *the_node
)
{
4b4ca: 4e56 fff0 linkw %fp,#-16
4b4ce: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
4b4d2: 266e 0008 moveal %fp@(8),%a3
}
the_node->parent->color = RBT_BLACK;
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
4b4d6: 49fa ffa0 lea %pc@(4b478 <_RBTree_Rotate>),%a4
RBTree_Node *u,*g;
/* note: the insert root case is handled already */
/* if the parent is black, nothing needs to be done
* otherwise may need to loop a few times */
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
4b4da: 604e bras 4b52a <_RBTree_Validate_insert_unprotected+0x60>
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
4b4dc: 4a92 tstl %a2@
4b4de: 6762 beqs 4b542 <_RBTree_Validate_insert_unprotected+0x78><== NEVER TAKEN
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
4b4e0: 226a 0004 moveal %a2@(4),%a1
4b4e4: b3c8 cmpal %a0,%a1
4b4e6: 6604 bnes 4b4ec <_RBTree_Validate_insert_unprotected+0x22>
return the_node->parent->child[RBT_RIGHT];
4b4e8: 226a 0008 moveal %a2@(8),%a1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4b4ec: 4a89 tstl %a1
4b4ee: 6752 beqs 4b542 <_RBTree_Validate_insert_unprotected+0x78>
4b4f0: 7001 moveq #1,%d0
4b4f2: b0a9 000c cmpl %a1@(12),%d0
4b4f6: 664a bnes 4b542 <_RBTree_Validate_insert_unprotected+0x78>
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
4b4f8: 42a8 000c clrl %a0@(12)
u->color = RBT_BLACK;
g->color = RBT_RED;
4b4fc: 264a moveal %a2,%a3
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
4b4fe: 42a9 000c clrl %a1@(12)
g->color = RBT_RED;
4b502: 2540 000c movel %d0,%a2@(12)
4b506: 6022 bras 4b52a <_RBTree_Validate_insert_unprotected+0x60>
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
4b508: 2f02 movel %d2,%sp@-
4b50a: 2f08 movel %a0,%sp@-
4b50c: 4e94 jsr %a4@
the_node = the_node->child[pdir];
4b50e: 508f addql #8,%sp
4b510: 2673 2c04 moveal %a3@(00000004,%d2:l:4),%a3
}
the_node->parent->color = RBT_BLACK;
4b514: 2053 moveal %a3@,%a0
g->color = RBT_RED;
4b516: 7001 moveq #1,%d0
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
4b518: 42a8 000c clrl %a0@(12)
g->color = RBT_RED;
4b51c: 2540 000c movel %d0,%a2@(12)
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
4b520: 9082 subl %d2,%d0
4b522: 2f00 movel %d0,%sp@-
4b524: 2f0a movel %a2,%sp@-
4b526: 4e94 jsr %a4@
4b528: 508f addql #8,%sp
ISR_Level level;
_ISR_Disable( level );
return _RBTree_Insert_unprotected( tree, node );
_ISR_Enable( level );
}
4b52a: 2053 moveal %a3@,%a0
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
4b52c: 2450 moveal %a0@,%a2
4b52e: 4a8a tstl %a2
4b530: 670a beqs 4b53c <_RBTree_Validate_insert_unprotected+0x72>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4b532: 7001 moveq #1,%d0
4b534: b0a8 000c cmpl %a0@(12),%d0
4b538: 6622 bnes 4b55c <_RBTree_Validate_insert_unprotected+0x92>
4b53a: 60a0 bras 4b4dc <_RBTree_Validate_insert_unprotected+0x12>
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4b53c: 42ab 000c clrl %a3@(12)
4b540: 601a bras 4b55c <_RBTree_Validate_insert_unprotected+0x92>
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
4b542: b1ea 0004 cmpal %a2@(4),%a0
4b546: 56c2 sne %d2
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4b548: b7e8 0004 cmpal %a0@(4),%a3
4b54c: 56c0 sne %d0
RBTree_Direction pdir = the_node->parent != g->child[0];
4b54e: 49c2 extbl %d2
4b550: 4482 negl %d2
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4b552: 49c0 extbl %d0
4b554: 4480 negl %d0
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
4b556: b480 cmpl %d0,%d2
4b558: 66ae bnes 4b508 <_RBTree_Validate_insert_unprotected+0x3e>
4b55a: 60b8 bras 4b514 <_RBTree_Validate_insert_unprotected+0x4a>
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
4b55c: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
4b562: 4e5e unlk %fp <== NOT EXECUTED
0004a35c <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
4a35c: 4e56 ffec linkw %fp,#-20
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4a360: 206e 0008 moveal %fp@(8),%a0
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
4a364: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4a368: 2468 00fc moveal %a0@(252),%a2
if ( !api )
4a36c: 4a8a tstl %a2
4a36e: 6754 beqs 4a3c4 <_RTEMS_tasks_Post_switch_extension+0x68><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
4a370: 203c 0000 0700 movel #1792,%d0
4a376: 40c1 movew %sr,%d1
4a378: 8081 orl %d1,%d0
4a37a: 46c0 movew %d0,%sr
signal_set = asr->signals_posted;
4a37c: 262a 0012 movel %a2@(18),%d3
asr->signals_posted = 0;
4a380: 42aa 0012 clrl %a2@(18)
_ISR_Enable( level );
4a384: 46c1 movew %d1,%sr
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
4a386: 4a83 tstl %d3
4a388: 673a beqs 4a3c4 <_RTEMS_tasks_Post_switch_extension+0x68>
return;
asr->nest_level += 1;
4a38a: 52aa 001a addql #1,%a2@(26)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4a38e: 240e movel %fp,%d2
4a390: 5982 subql #4,%d2
4a392: 47f9 0004 bc34 lea 4bc34 <rtems_task_mode>,%a3
4a398: 2f02 movel %d2,%sp@-
4a39a: 2f3c 0000 ffff movel #65535,%sp@-
4a3a0: 2f2a 000e movel %a2@(14),%sp@-
4a3a4: 4e93 jsr %a3@
(*asr->handler)( signal_set );
4a3a6: 2f03 movel %d3,%sp@-
4a3a8: 206a 000a moveal %a2@(10),%a0
4a3ac: 4e90 jsr %a0@
asr->nest_level -= 1;
4a3ae: 53aa 001a subql #1,%a2@(26)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4a3b2: 2f02 movel %d2,%sp@-
4a3b4: 2f3c 0000 ffff movel #65535,%sp@-
4a3ba: 2f2e fffc movel %fp@(-4),%sp@-
4a3be: 4e93 jsr %a3@
4a3c0: 4fef 001c lea %sp@(28),%sp
}
4a3c4: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4a3ca: 4e5e unlk %fp <== NOT EXECUTED
00047a84 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
47a84: 4e56 0000 linkw %fp,#0
47a88: 2f0a movel %a2,%sp@-
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
47a8a: 4878 0018 pea 18 <OPER2+0x4>
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
47a8e: 246e 0008 moveal %fp@(8),%a2
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
47a92: 4eb9 0004 924c jsr 4924c <_Workspace_Allocate>
if ( sched ) {
47a98: 588f addql #4,%sp
47a9a: 4a80 tstl %d0
47a9c: 670e beqs 47aac <_Scheduler_EDF_Allocate+0x28> <== NEVER TAKEN
the_thread->scheduler_info = sched;
47a9e: 2540 008a movel %d0,%a2@(138)
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
47aa2: 2040 moveal %d0,%a0
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
47aa4: 7202 moveq #2,%d1
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
if ( sched ) {
the_thread->scheduler_info = sched;
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
47aa6: 208a movel %a2,%a0@
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
47aa8: 2141 0014 movel %d1,%a0@(20)
}
return sched;
}
47aac: 246e fffc moveal %fp@(-4),%a2
47ab0: 4e5e unlk %fp <== NOT EXECUTED
00047ab4 <_Scheduler_EDF_Block>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Block(
Thread_Control *the_thread
)
{
47ab4: 4e56 0000 linkw %fp,#0
47ab8: 2f02 movel %d2,%sp@-
47aba: 242e 0008 movel %fp@(8),%d2
_Scheduler_EDF_Extract( the_thread );
47abe: 2f02 movel %d2,%sp@-
47ac0: 4eb9 0004 7b2c jsr 47b2c <_Scheduler_EDF_Extract>
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
47ac6: 588f addql #4,%sp
47ac8: b4b9 0005 ee58 cmpl 5ee58 <_Per_CPU_Information+0x10>,%d2
47ace: 6606 bnes 47ad6 <_Scheduler_EDF_Block+0x22> <== NEVER TAKEN
_Scheduler_EDF_Schedule();
47ad0: 4eb9 0004 7c4c jsr 47c4c <_Scheduler_EDF_Schedule>
if ( _Thread_Is_executing( the_thread ) )
47ad6: b4b9 0005 ee54 cmpl 5ee54 <_Per_CPU_Information+0xc>,%d2
47adc: 6608 bnes 47ae6 <_Scheduler_EDF_Block+0x32> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
47ade: 7001 moveq #1,%d0
47ae0: 13c0 0005 ee60 moveb %d0,5ee60 <_Per_CPU_Information+0x18>
}
47ae6: 242e fffc movel %fp@(-4),%d2
47aea: 4e5e unlk %fp
...
00047b58 <_Scheduler_EDF_Free>:
#include <rtems/score/wkspace.h>
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
47b58: 4e56 0000 linkw %fp,#0
_Workspace_Free( the_thread->scheduler_info );
47b5c: 206e 0008 moveal %fp@(8),%a0
47b60: 2d68 008a 0008 movel %a0@(138),%fp@(8)
}
47b66: 4e5e unlk %fp
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
47b68: 4ef9 0004 9268 jmp 49268 <_Workspace_Free>
...
00047c10 <_Scheduler_EDF_Release_job>:
void _Scheduler_EDF_Release_job(
Thread_Control *the_thread,
uint32_t deadline
)
{
47c10: 4e56 0000 linkw %fp,#0
47c14: 206e 0008 moveal %fp@(8),%a0
47c18: 202e 000c movel %fp@(12),%d0
Priority_Control new_priority;
if (deadline) {
47c1c: 670e beqs 47c2c <_Scheduler_EDF_Release_job+0x1c><== NEVER TAKEN
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
47c1e: 2239 0005 edc0 movel 5edc0 <_Watchdog_Ticks_since_boot>,%d1
47c24: d081 addl %d1,%d0
47c26: 0880 001f bclr #31,%d0
47c2a: 6004 bras 47c30 <_Scheduler_EDF_Release_job+0x20>
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
47c2c: 2028 00ac movel %a0@(172),%d0 <== NOT EXECUTED
}
the_thread->real_priority = new_priority;
47c30: 2140 0018 movel %d0,%a0@(24)
_Thread_Change_priority(the_thread, new_priority, true);
47c34: 4878 0001 pea 1 <ADD>
47c38: 2f00 movel %d0,%sp@-
47c3a: 2f08 movel %a0,%sp@-
47c3c: 4eb9 0004 7f24 jsr 47f24 <_Thread_Change_priority>
47c42: 4fef 000c lea %sp@(12),%sp
}
47c46: 4e5e unlk %fp
...
00047c70 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
47c70: 4e56 0000 linkw %fp,#0
47c74: 2f0a movel %a2,%sp@-
47c76: 246e 0008 moveal %fp@(8),%a2
_Scheduler_EDF_Enqueue(the_thread);
47c7a: 2f0a movel %a2,%sp@-
47c7c: 4eb9 0004 7afc jsr 47afc <_Scheduler_EDF_Enqueue>
47c82: 2f2a 0014 movel %a2@(20),%sp@-
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
47c86: 2079 0005 ee58 moveal 5ee58 <_Per_CPU_Information+0x10>,%a0
47c8c: 2f28 0014 movel %a0@(20),%sp@-
47c90: 2079 0005 d40e moveal 5d40e <_Scheduler+0x30>,%a0
47c96: 4e90 jsr %a0@
47c98: 4fef 000c lea %sp@(12),%sp
47c9c: 4a80 tstl %d0
47c9e: 6c20 bges 47cc0 <_Scheduler_EDF_Unblock+0x50>
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
47ca0: 2079 0005 ee54 moveal 5ee54 <_Per_CPU_Information+0xc>,%a0
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
47ca6: 23ca 0005 ee58 movel %a2,5ee58 <_Per_CPU_Information+0x10>
if ( _Thread_Executing->is_preemptible ||
47cac: 4a28 0074 tstb %a0@(116)
47cb0: 6606 bnes 47cb8 <_Scheduler_EDF_Unblock+0x48> <== ALWAYS TAKEN
47cb2: 4aaa 0014 tstl %a2@(20) <== NOT EXECUTED
47cb6: 6608 bnes 47cc0 <_Scheduler_EDF_Unblock+0x50> <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
47cb8: 7001 moveq #1,%d0
47cba: 13c0 0005 ee60 moveb %d0,5ee60 <_Per_CPU_Information+0x18>
}
}
47cc0: 246e fffc moveal %fp@(-4),%a2
47cc4: 4e5e unlk %fp <== NOT EXECUTED
00047cc8 <_Scheduler_EDF_Update>:
{
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
47cc8: 7002 moveq #2,%d0
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
47cca: 4e56 0000 linkw %fp,#0
47cce: 2f0a movel %a2,%sp@-
47cd0: 246e 0008 moveal %fp@(8),%a2
Scheduler_EDF_Per_thread *sched_info =
47cd4: 206a 008a moveal %a2@(138),%a0
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
47cd8: 2f02 movel %d2,%sp@-
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
47cda: b0a8 0014 cmpl %a0@(20),%d0
47cde: 6618 bnes 47cf8 <_Scheduler_EDF_Update+0x30>
/* Shifts the priority to the region of background tasks. */
the_thread->Start.initial_priority |= (SCHEDULER_EDF_PRIO_MSB);
47ce0: 202a 00ac movel %a2@(172),%d0
47ce4: 08c0 001f bset #31,%d0
47ce8: 2540 00ac movel %d0,%a2@(172)
the_thread->real_priority = the_thread->Start.initial_priority;
47cec: 2540 0018 movel %d0,%a2@(24)
the_thread->current_priority = the_thread->Start.initial_priority;
47cf0: 2540 0014 movel %d0,%a2@(20)
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
47cf4: 42a8 0014 clrl %a0@(20)
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
47cf8: 7001 moveq #1,%d0
47cfa: b0a8 0014 cmpl %a0@(20),%d0
47cfe: 664c bnes 47d4c <_Scheduler_EDF_Update+0x84> <== ALWAYS TAKEN
Thread_Control *the_thread
)
{
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
47d00: 2408 movel %a0,%d2 <== NOT EXECUTED
47d02: 5882 addql #4,%d2 <== NOT EXECUTED
the_thread->current_priority = the_thread->Start.initial_priority;
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
_RBTree_Extract(&_Scheduler_EDF_Ready_queue, the_node);
47d04: 2f02 movel %d2,%sp@- <== NOT EXECUTED
47d06: 4879 0005 ee6a pea 5ee6a <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47d0c: 4eb9 0004 b44c jsr 4b44c <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert(&_Scheduler_EDF_Ready_queue, the_node);
47d12: 2f02 movel %d2,%sp@- <== NOT EXECUTED
47d14: 4879 0005 ee6a pea 5ee6a <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47d1a: 4eb9 0004 b610 jsr 4b610 <_RBTree_Insert> <== NOT EXECUTED
_Scheduler_EDF_Schedule();
47d20: 4eb9 0004 7c4c jsr 47c4c <_Scheduler_EDF_Schedule> <== NOT EXECUTED
if ( _Thread_Executing != _Thread_Heir ) {
47d26: 2079 0005 ee54 moveal 5ee54 <_Per_CPU_Information+0xc>,%a0 <== NOT EXECUTED
47d2c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
47d30: b1f9 0005 ee58 cmpal 5ee58 <_Per_CPU_Information+0x10>,%a0 <== NOT EXECUTED
47d36: 6714 beqs 47d4c <_Scheduler_EDF_Update+0x84> <== NOT EXECUTED
if ( _Thread_Executing->is_preemptible ||
47d38: 4a28 0074 tstb %a0@(116) <== NOT EXECUTED
47d3c: 6606 bnes 47d44 <_Scheduler_EDF_Update+0x7c> <== NOT EXECUTED
47d3e: 4aaa 0014 tstl %a2@(20) <== NOT EXECUTED
47d42: 6608 bnes 47d4c <_Scheduler_EDF_Update+0x84> <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
47d44: 7001 moveq #1,%d0 <== NOT EXECUTED
47d46: 13c0 0005 ee60 moveb %d0,5ee60 <_Per_CPU_Information+0x18> <== NOT EXECUTED
}
}
}
47d4c: 242e fff8 movel %fp@(-8),%d2
47d50: 246e fffc moveal %fp@(-4),%a2
47d54: 4e5e unlk %fp <== NOT EXECUTED
00047d58 <_Scheduler_EDF_Yield>:
Thread_Control *executing = _Thread_Executing;
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
47d58: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
47d5e: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
47d62: 48d7 040c moveml %d2-%d3/%a2,%sp@ <== NOT EXECUTED
Scheduler_EDF_Per_thread *first_info;
RBTree_Node *first_node;
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
47d66: 2479 0005 ee54 moveal 5ee54 <_Per_CPU_Information+0xc>,%a2 <== NOT EXECUTED
Scheduler_EDF_Per_thread *executing_info =
47d6c: 262a 008a movel %a2@(138),%d3 <== NOT EXECUTED
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
47d70: 40c2 movew %sr,%d2 <== NOT EXECUTED
47d72: 8082 orl %d2,%d0 <== NOT EXECUTED
47d74: 46c0 movew %d0,%sr <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _RBTree_Has_only_one_node(
const RBTree_Control *the_rbtree
)
{
if(!the_rbtree) return NULL; /* TODO: expected behavior? */
return (the_rbtree->root->child[RBT_LEFT] == NULL && the_rbtree->root->child[RBT_RIGHT] == NULL);
47d76: 2079 0005 ee6e moveal 5ee6e <_Scheduler_EDF_Ready_queue+0x4>,%a0<== NOT EXECUTED
47d7c: 4aa8 0004 tstl %a0@(4) <== NOT EXECUTED
47d80: 660c bnes 47d8e <_Scheduler_EDF_Yield+0x36> <== NOT EXECUTED
#include <rtems/score/isr.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
47d82: 4aa8 0008 tstl %a0@(8) <== NOT EXECUTED
47d86: 57c0 seq %d0 <== NOT EXECUTED
47d88: 49c0 extbl %d0 <== NOT EXECUTED
47d8a: 4480 negl %d0 <== NOT EXECUTED
47d8c: 6002 bras 47d90 <_Scheduler_EDF_Yield+0x38> <== NOT EXECUTED
47d8e: 4280 clrl %d0 <== NOT EXECUTED
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
if ( !_RBTree_Has_only_one_node(&_Scheduler_EDF_Ready_queue) ) {
47d90: 4a00 tstb %d0 <== NOT EXECUTED
47d92: 6652 bnes 47de6 <_Scheduler_EDF_Yield+0x8e> <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
47d94: 5883 addql #4,%d3 <== NOT EXECUTED
if ( !_RBTree_Has_only_one_node(&_Scheduler_EDF_Ready_queue) ) {
/*
* The RBTree has more than one node, enqueue behind the tasks
* with the same priority in case there are such ones.
*/
_RBTree_Extract( &_Scheduler_EDF_Ready_queue, executing_node );
47d96: 2f03 movel %d3,%sp@- <== NOT EXECUTED
47d98: 4879 0005 ee6a pea 5ee6a <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47d9e: 4eb9 0004 b44c jsr 4b44c <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
47da4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
47da6: 4879 0005 ee6a pea 5ee6a <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47dac: 4eb9 0004 b610 jsr 4b610 <_RBTree_Insert> <== NOT EXECUTED
_ISR_Flash( level );
47db2: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
47db8: 46c2 movew %d2,%sr <== NOT EXECUTED
47dba: 8082 orl %d2,%d0 <== NOT EXECUTED
47dbc: 46c0 movew %d0,%sr <== NOT EXECUTED
if ( _Thread_Is_heir( executing ) ) {
47dbe: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
47dc2: b5f9 0005 ee58 cmpal 5ee58 <_Per_CPU_Information+0x10>,%a2 <== NOT EXECUTED
47dc8: 6624 bnes 47dee <_Scheduler_EDF_Yield+0x96> <== NOT EXECUTED
first_node = _RBTree_Peek( &_Scheduler_EDF_Ready_queue, RBT_LEFT );
47dca: 42a7 clrl %sp@- <== NOT EXECUTED
47dcc: 4879 0005 ee6a pea 5ee6a <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED
47dd2: 4eb9 0004 b63c jsr 4b63c <_RBTree_Peek> <== NOT EXECUTED
first_info =
_RBTree_Container_of(first_node, Scheduler_EDF_Per_thread, Node);
_Thread_Heir = first_info->thread;
47dd8: 508f addql #8,%sp <== NOT EXECUTED
47dda: 2040 moveal %d0,%a0 <== NOT EXECUTED
47ddc: 5988 subql #4,%a0 <== NOT EXECUTED
47dde: 23d0 0005 ee58 movel %a0@,5ee58 <_Per_CPU_Information+0x10><== NOT EXECUTED
47de4: 6008 bras 47dee <_Scheduler_EDF_Yield+0x96> <== NOT EXECUTED
}
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
47de6: b5f9 0005 ee58 cmpal 5ee58 <_Per_CPU_Information+0x10>,%a2 <== NOT EXECUTED
47dec: 6708 beqs 47df6 <_Scheduler_EDF_Yield+0x9e> <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
47dee: 7001 moveq #1,%d0 <== NOT EXECUTED
47df0: 13c0 0005 ee60 moveb %d0,5ee60 <_Per_CPU_Information+0x18> <== NOT EXECUTED
_ISR_Enable( level );
47df6: 46c2 movew %d2,%sr <== NOT EXECUTED
}
47df8: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 <== NOT EXECUTED
47dfe: 4e5e unlk %fp <== NOT EXECUTED
...
000473a8 <_Scheduler_Handler_initialization>:
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
473a8: 4e56 0000 linkw %fp,#0
(*_Scheduler.Operations.initialize)();
}
473ac: 4e5e unlk %fp
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
(*_Scheduler.Operations.initialize)();
473ae: 2279 0005 bfb2 moveal 5bfb2 <_Scheduler+0x4>,%a1
473b4: 4ed1 jmp %a1@
...
00047580 <_Scheduler_priority_Free>:
#include <rtems/score/wkspace.h>
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
47580: 4e56 0000 linkw %fp,#0
_Workspace_Free( the_thread->scheduler_info );
47584: 206e 0008 moveal %fp@(8),%a0
47588: 2d68 008a 0008 movel %a0@(138),%fp@(8)
}
4758e: 4e5e unlk %fp
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
47590: 4ef9 0004 8b3c jmp 48b3c <_Workspace_Free>
...
000461e4 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
461e4: 4e56 0000 linkw %fp,#0
461e8: 206e 0008 moveal %fp@(8),%a0
461ec: 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();
461ee: 2039 0005 dcd8 movel 5dcd8 <Configuration+0xc>,%d0
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
461f4: 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) ||
461f6: 4a88 tstl %a0
461f8: 6762 beqs 4625c <_TOD_Validate+0x78> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
461fa: 243c 000f 4240 movel #1000000,%d2
46200: 4c40 2002 remul %d0,%d2,%d2
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
46204: b4a8 0018 cmpl %a0@(24),%d2
46208: 6352 blss 4625c <_TOD_Validate+0x78>
(the_tod->ticks >= ticks_per_second) ||
4620a: 763b moveq #59,%d3
4620c: b6a8 0014 cmpl %a0@(20),%d3
46210: 654a bcss 4625c <_TOD_Validate+0x78>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
46212: b6a8 0010 cmpl %a0@(16),%d3
46216: 6544 bcss 4625c <_TOD_Validate+0x78>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
46218: 7017 moveq #23,%d0
4621a: b0a8 000c cmpl %a0@(12),%d0
4621e: 653c bcss 4625c <_TOD_Validate+0x78>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
46220: 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) ||
46224: 6736 beqs 4625c <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->month == 0) ||
46226: 720c moveq #12,%d1
46228: b280 cmpl %d0,%d1
4622a: 6530 bcss 4625c <_TOD_Validate+0x78>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
4622c: 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) ||
4622e: 0c82 0000 07c3 cmpil #1987,%d2
46234: 6326 blss 4625c <_TOD_Validate+0x78>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
46236: 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) ||
4623a: 6720 beqs 4625c <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
4623c: 163c 0003 moveb #3,%d3
46240: 41f9 0005 cf28 lea 5cf28 <_TOD_Days_per_month>,%a0
46246: c483 andl %d3,%d2
46248: 6606 bnes 46250 <_TOD_Validate+0x6c>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
4624a: 2030 0c34 movel %a0@(00000034,%d0:l:4),%d0
4624e: 6004 bras 46254 <_TOD_Validate+0x70>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
46250: 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(
46254: b081 cmpl %d1,%d0
46256: 54c0 scc %d0
46258: 4480 negl %d0
4625a: 6002 bras 4625e <_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;
4625c: 4200 clrb %d0
if ( the_tod->day > days_in_month )
return false;
return true;
}
4625e: 241f movel %sp@+,%d2
46260: 261f movel %sp@+,%d3
46262: 4e5e unlk %fp
...
00047878 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47878: 4e56 fff0 linkw %fp,#-16
4787c: 48d7 041c moveml %d2-%d4/%a2,%sp@
47880: 246e 0008 moveal %fp@(8),%a2
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
47884: 282a 0010 movel %a2@(16),%d4
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47888: 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 );
4788c: 2f0a movel %a2,%sp@-
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
4788e: 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 );
47892: 4eb9 0004 8464 jsr 48464 <_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 )
47898: 588f addql #4,%sp
4789a: b4aa 0014 cmpl %a2@(20),%d2
4789e: 670c beqs 478ac <_Thread_Change_priority+0x34>
_Thread_Set_priority( the_thread, new_priority );
478a0: 2f02 movel %d2,%sp@-
478a2: 2f0a movel %a2,%sp@-
478a4: 4eb9 0004 8408 jsr 48408 <_Thread_Set_priority>
478aa: 508f addql #8,%sp
_ISR_Disable( level );
478ac: 203c 0000 0700 movel #1792,%d0
478b2: 40c2 movew %sr,%d2
478b4: 8082 orl %d2,%d0
478b6: 46c0 movew %d0,%sr
478b8: 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;
478ba: 202a 0010 movel %a2@(16),%d0
478be: c284 andl %d4,%d1
if ( state != STATES_TRANSIENT ) {
478c0: 7804 moveq #4,%d4
478c2: b880 cmpl %d0,%d4
478c4: 672e beqs 478f4 <_Thread_Change_priority+0x7c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
478c6: 4a81 tstl %d1
478c8: 6608 bnes 478d2 <_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);
478ca: 72fb moveq #-5,%d1
478cc: c280 andl %d0,%d1
478ce: 2541 0010 movel %d1,%a2@(16)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
478d2: 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);
478d4: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
478da: 676c beqs 47948 <_Thread_Change_priority+0xd0>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
478dc: 2d4a 000c movel %a2,%fp@(12)
478e0: 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 );
}
478e6: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
478ec: 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 );
478ee: 4ef9 0004 8368 jmp 48368 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
478f4: 4a81 tstl %d1
478f6: 661e bnes 47916 <_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 );
478f8: 42aa 0010 clrl %a2@(16)
if ( prepend_it )
478fc: 4a03 tstb %d3
478fe: 670a beqs 4790a <_Thread_Change_priority+0x92>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
47900: 2f0a movel %a2,%sp@-
47902: 2079 0005 bfd6 moveal 5bfd6 <_Scheduler+0x28>,%a0
47908: 6008 bras 47912 <_Thread_Change_priority+0x9a>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
4790a: 2079 0005 bfd2 moveal 5bfd2 <_Scheduler+0x24>,%a0
47910: 2f0a movel %a2,%sp@-
47912: 4e90 jsr %a0@
47914: 588f addql #4,%sp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
47916: 203c 0000 0700 movel #1792,%d0
4791c: 46c2 movew %d2,%sr
4791e: 8082 orl %d2,%d0
47920: 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();
47922: 2079 0005 bfb6 moveal 5bfb6 <_Scheduler+0x8>,%a0
47928: 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 );
4792a: 2079 0005 d9bc moveal 5d9bc <_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() &&
47930: b1f9 0005 d9c0 cmpal 5d9c0 <_Per_CPU_Information+0x10>,%a0
47936: 670e beqs 47946 <_Thread_Change_priority+0xce>
47938: 4a28 0074 tstb %a0@(116)
4793c: 6708 beqs 47946 <_Thread_Change_priority+0xce>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
4793e: 7801 moveq #1,%d4
47940: 13c4 0005 d9c8 moveb %d4,5d9c8 <_Per_CPU_Information+0x18>
_ISR_Enable( level );
47946: 46c2 movew %d2,%sr
}
47948: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4794e: 4e5e unlk %fp
...
00047b2c <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
47b2c: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
47b30: 486e fffc pea %fp@(-4)
47b34: 2f2e 0008 movel %fp@(8),%sp@-
47b38: 4eb9 0004 7cf0 jsr 47cf0 <_Thread_Get>
switch ( location ) {
47b3e: 508f addql #8,%sp
47b40: 4aae fffc tstl %fp@(-4)
47b44: 6624 bnes 47b6a <_Thread_Delay_ended+0x3e> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
47b46: 2f3c 1000 0018 movel #268435480,%sp@-
47b4c: 2f00 movel %d0,%sp@-
47b4e: 4eb9 0004 7954 jsr 47954 <_Thread_Clear_state>
47b54: 508f addql #8,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
47b56: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
47b5c: 5380 subql #1,%d0
47b5e: 23c0 0005 d828 movel %d0,5d828 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47b64: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
47b6a: 4e5e unlk %fp
...
00047b70 <_Thread_Dispatch>:
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
47b70: 4e56 ffd0 linkw %fp,#-48
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
47b74: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
47b7a: 5280 addql #1,%d0
47b7c: 23c0 0005 d828 movel %d0,5d828 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47b82: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
47b88: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
47b8c: 223c 0000 0700 movel #1792,%d1
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
47b92: 2479 0005 d9bc moveal 5d9bc <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
47b98: 40c0 movew %sr,%d0
47b9a: 8280 orl %d0,%d1
47b9c: 46c1 movew %d1,%sr
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47b9e: 260e movel %fp,%d3
_Timestamp_Subtract(
47ba0: 240e movel %fp,%d2
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47ba2: 0683 ffff fff0 addil #-16,%d3
47ba8: 2a3c 0004 a6c8 movel #304840,%d5
_Timestamp_Subtract(
47bae: 5182 subql #8,%d2
47bb0: 283c 0004 85ec movel #296428,%d4
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47bb6: 4bf9 0004 85b4 lea 485b4 <_Timespec_Add_to>,%a5
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
47bbc: 49f9 0004 886c lea 4886c <_User_extensions_Thread_switch>,%a4
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
47bc2: 6000 00d2 braw 47c96 <_Thread_Dispatch+0x126>
heir = _Thread_Heir;
47bc6: 2679 0005 d9c0 moveal 5d9c0 <_Per_CPU_Information+0x10>,%a3
_Thread_Dispatch_necessary = false;
47bcc: 4201 clrb %d1
_Thread_Executing = heir;
47bce: 23cb 0005 d9bc movel %a3,5d9bc <_Per_CPU_Information+0xc>
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
47bd4: 13c1 0005 d9c8 moveb %d1,5d9c8 <_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 )
47bda: b5cb cmpal %a3,%a2
47bdc: 6700 00c2 beqw 47ca0 <_Thread_Dispatch+0x130>
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
47be0: 7201 moveq #1,%d1
47be2: b2ab 007a cmpl %a3@(122),%d1
47be6: 660a bnes 47bf2 <_Thread_Dispatch+0x82>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
47be8: 41f9 0005 d7e0 lea 5d7e0 <_Thread_Ticks_per_timeslice>,%a0
47bee: 2750 0076 movel %a0@,%a3@(118)
_ISR_Enable( level );
47bf2: 46c0 movew %d0,%sr
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47bf4: 2f03 movel %d3,%sp@-
47bf6: 2045 moveal %d5,%a0
47bf8: 4e90 jsr %a0@
_Timestamp_Subtract(
47bfa: 2044 moveal %d4,%a0
47bfc: 2f02 movel %d2,%sp@-
47bfe: 2f03 movel %d3,%sp@-
47c00: 4879 0005 d9ca pea 5d9ca <_Per_CPU_Information+0x1a>
47c06: 4e90 jsr %a0@
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47c08: 2f02 movel %d2,%sp@-
47c0a: 486a 0082 pea %a2@(130)
47c0e: 4e95 jsr %a5@
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
47c10: 2079 0005 d8ae moveal 5d8ae <_Thread_libc_reent>,%a0
47c16: 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;
47c1a: 202e fff0 movel %fp@(-16),%d0
47c1e: 222e fff4 movel %fp@(-12),%d1
47c22: 23c0 0005 d9ca movel %d0,5d9ca <_Per_CPU_Information+0x1a>
47c28: 23c1 0005 d9ce movel %d1,5d9ce <_Per_CPU_Information+0x1e>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
47c2e: 4a88 tstl %a0
47c30: 6708 beqs 47c3a <_Thread_Dispatch+0xca> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
47c32: 2550 00f8 movel %a0@,%a2@(248)
*_Thread_libc_reent = heir->libc_reent;
47c36: 20ab 00f8 movel %a3@(248),%a0@
}
_User_extensions_Thread_switch( executing, heir );
47c3a: 2f0b movel %a3,%sp@-
47c3c: 2f0a movel %a2,%sp@-
47c3e: 4e94 jsr %a4@
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
47c40: 486b 00c0 pea %a3@(192)
47c44: 486a 00c0 pea %a2@(192)
47c48: 4eb9 0004 8b8c jsr 48b8c <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
47c4e: 4fef 0010 lea %sp@(16),%sp
47c52: 4aaa 00f4 tstl %a2@(244)
47c56: 672c beqs 47c84 <_Thread_Dispatch+0x114>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
47c58: 2079 0005 d8aa moveal 5d8aa <_Thread_Allocated_fp>,%a0
47c5e: b1ca cmpal %a2,%a0
47c60: 6722 beqs 47c84 <_Thread_Dispatch+0x114>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
47c62: 4a88 tstl %a0
47c64: 670c beqs 47c72 <_Thread_Dispatch+0x102>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
47c66: 4868 00f4 pea %a0@(244)
47c6a: 4eb9 0004 8cd2 jsr 48cd2 <_CPU_Context_save_fp>
47c70: 588f addql #4,%sp
_Context_Restore_fp( &executing->fp_context );
47c72: 486a 00f4 pea %a2@(244)
47c76: 4eb9 0004 8cf4 jsr 48cf4 <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
47c7c: 588f addql #4,%sp
47c7e: 23ca 0005 d8aa movel %a2,5d8aa <_Thread_Allocated_fp>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
47c84: 2479 0005 d9bc moveal 5d9bc <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
47c8a: 223c 0000 0700 movel #1792,%d1
47c90: 40c0 movew %sr,%d0
47c92: 8280 orl %d0,%d1
47c94: 46c1 movew %d1,%sr
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
47c96: 1239 0005 d9c8 moveb 5d9c8 <_Per_CPU_Information+0x18>,%d1
47c9c: 6600 ff28 bnew 47bc6 <_Thread_Dispatch+0x56>
_ISR_Disable( level );
}
post_switch:
_ISR_Enable( level );
47ca0: 46c0 movew %d0,%sr
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
47ca2: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
47ca8: 5380 subql #1,%d0
47caa: 23c0 0005 d828 movel %d0,5d828 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47cb0: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
47cb6: 4eb9 0004 6230 jsr 46230 <_API_extensions_Run_postswitch>
}
47cbc: 4cee 3c3c ffd0 moveml %fp@(-48),%d2-%d5/%a2-%a5
47cc2: 4e5e unlk %fp
...
00047cf0 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
47cf0: 4e56 0000 linkw %fp,#0
47cf4: 202e 0008 movel %fp@(8),%d0
47cf8: 2f03 movel %d3,%sp@-
47cfa: 206e 000c moveal %fp@(12),%a0
47cfe: 2f02 movel %d2,%sp@-
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
47d00: 4a80 tstl %d0
47d02: 661e bnes 47d22 <_Thread_Get+0x32>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
47d04: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
47d0a: 5280 addql #1,%d0
47d0c: 23c0 0005 d828 movel %d0,5d828 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47d12: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
47d18: 4290 clrl %a0@
tp = _Thread_Executing;
47d1a: 2039 0005 d9bc movel 5d9bc <_Per_CPU_Information+0xc>,%d0
goto done;
47d20: 6044 bras 47d66 <_Thread_Get+0x76>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
47d22: 7418 moveq #24,%d2
47d24: 2200 movel %d0,%d1
47d26: e4a9 lsrl %d2,%d1
47d28: 7607 moveq #7,%d3
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47d2a: 143c 0002 moveb #2,%d2
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
47d2e: c283 andl %d3,%d1
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47d30: 2241 moveal %d1,%a1
47d32: 5389 subql #1,%a1
47d34: b489 cmpl %a1,%d2
47d36: 643a bccs 47d72 <_Thread_Get+0x82>
47d38: 6014 bras 47d4e <_Thread_Get+0x5e>
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
47d3a: 43f9 0005 d7e4 lea 5d7e4 <_Objects_Information_table>,%a1
47d40: 2271 1c00 moveal %a1@(00000000,%d1:l:4),%a1
* There is no way for this to happen if POSIX is enabled. But there
* is actually a test case in sp43 for this which trips it whether or
* not POSIX is enabled. So in the interest of safety, this is left
* on in all configurations.
*/
if ( !api_information ) {
47d44: 4a89 tstl %a1
47d46: 6706 beqs 47d4e <_Thread_Get+0x5e>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
47d48: 2229 0004 movel %a1@(4),%d1
if ( !information ) {
47d4c: 6608 bnes 47d56 <_Thread_Get+0x66>
*location = OBJECTS_ERROR;
47d4e: 7001 moveq #1,%d0
47d50: 2080 movel %d0,%a0@
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
47d52: 4280 clrl %d0
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
goto done;
47d54: 6010 bras 47d66 <_Thread_Get+0x76>
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
47d56: 2f08 movel %a0,%sp@-
47d58: 2f00 movel %d0,%sp@-
47d5a: 2f01 movel %d1,%sp@-
47d5c: 4eb9 0004 70a0 jsr 470a0 <_Objects_Get>
47d62: 4fef 000c lea %sp@(12),%sp
done:
return tp;
}
47d66: 242e fff8 movel %fp@(-8),%d2
47d6a: 262e fffc movel %fp@(-4),%d3
47d6e: 4e5e unlk %fp
47d70: 4e75 rts
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
47d72: 761b moveq #27,%d3
47d74: 2400 movel %d0,%d2
47d76: e6aa lsrl %d3,%d2
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
47d78: 163c 0001 moveb #1,%d3
47d7c: b682 cmpl %d2,%d3
47d7e: 67ba beqs 47d3a <_Thread_Get+0x4a>
47d80: 60cc bras 47d4e <_Thread_Get+0x5e>
...
0004beb4 <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4beb4: 4e56 0000 linkw %fp,#0
4beb8: 2f0a movel %a2,%sp@-
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
4beba: 2479 0005 d9bc moveal 5d9bc <_Per_CPU_Information+0xc>,%a2
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4bec0: 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;
4bec2: 222a 00a8 movel %a2@(168),%d1
_ISR_Set_level(level);
4bec6: 40c0 movew %sr,%d0
4bec8: e189 lsll #8,%d1
4beca: 0280 0000 f8ff andil #63743,%d0
4bed0: 8081 orl %d1,%d0
4bed2: 46c0 movew %d0,%sr
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
doneConstructors = true;
4bed4: 7001 moveq #1,%d0
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
4bed6: 1439 0005 cfec moveb 5cfec <doneConstructors.3388>,%d2
doneConstructors = true;
4bedc: 13c0 0005 cfec moveb %d0,5cfec <doneConstructors.3388>
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
4bee2: 4aaa 00f4 tstl %a2@(244)
4bee6: 6720 beqs 4bf08 <_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 );
4bee8: 2079 0005 d8aa moveal 5d8aa <_Thread_Allocated_fp>,%a0
4beee: b1ca cmpal %a2,%a0
4bef0: 6716 beqs 4bf08 <_Thread_Handler+0x54>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
4bef2: 4a88 tstl %a0
4bef4: 670c beqs 4bf02 <_Thread_Handler+0x4e>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
4bef6: 4868 00f4 pea %a0@(244)
4befa: 4eb9 0004 8cd2 jsr 48cd2 <_CPU_Context_save_fp>
4bf00: 588f addql #4,%sp
_Thread_Allocated_fp = executing;
4bf02: 23ca 0005 d8aa movel %a2,5d8aa <_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 );
4bf08: 2f0a movel %a2,%sp@-
4bf0a: 4eb9 0004 86e8 jsr 486e8 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4bf10: 4eb9 0004 7cc8 jsr 47cc8 <_Thread_Enable_dispatch>
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (doCons) /* && (volatile void *)_init) */ {
4bf16: 588f addql #4,%sp
4bf18: 4a02 tstb %d2
4bf1a: 6606 bnes 4bf22 <_Thread_Handler+0x6e>
INIT_NAME ();
4bf1c: 4eb9 0005 a17c jsr 5a17c <_init>
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4bf22: 4aaa 0092 tstl %a2@(146)
4bf26: 6610 bnes 4bf38 <_Thread_Handler+0x84> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
4bf28: 2f2a 009a movel %a2@(154),%sp@-
4bf2c: 206a 008e moveal %a2@(142),%a0
4bf30: 4e90 jsr %a0@
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
4bf32: 588f addql #4,%sp
4bf34: 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 );
4bf38: 2f0a movel %a2,%sp@-
4bf3a: 4eb9 0004 8720 jsr 48720 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
4bf40: 4878 0005 pea 5 <COMPARE>
4bf44: 4878 0001 pea 1 <ADD>
4bf48: 42a7 clrl %sp@-
4bf4a: 4eb9 0004 6b84 jsr 46b84 <_Internal_error_Occurred>
00048a04 <_Thread_Restart>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
48a04: 7001 moveq #1,%d0
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
48a06: 4e56 0000 linkw %fp,#0
48a0a: 2f0a movel %a2,%sp@-
48a0c: 246e 0008 moveal %fp@(8),%a2
48a10: c0aa 0010 andl %a2@(16),%d0
if ( !_States_Is_dormant( the_thread->current_state ) ) {
48a14: 6664 bnes 48a7a <_Thread_Restart+0x76>
_Thread_Set_transient( the_thread );
48a16: 2f0a movel %a2,%sp@-
48a18: 4eb9 0004 8ae4 jsr 48ae4 <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
48a1e: 2f2e 0010 movel %fp@(16),%sp@-
48a22: 2f2e 000c movel %fp@(12),%sp@-
48a26: 2f0a movel %a2,%sp@-
48a28: 4eb9 0004 b3ac jsr 4b3ac <_Thread_Reset>
_Thread_Load_environment( the_thread );
48a2e: 2f0a movel %a2,%sp@-
48a30: 4eb9 0004 b0f0 jsr 4b0f0 <_Thread_Load_environment>
_Thread_Ready( the_thread );
48a36: 2f0a movel %a2,%sp@-
48a38: 4eb9 0004 b37c jsr 4b37c <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
48a3e: 2f0a movel %a2,%sp@-
48a40: 4eb9 0004 8eac jsr 48eac <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
48a46: 4fef 001c lea %sp@(28),%sp
48a4a: b5f9 0005 e2c4 cmpal 5e2c4 <_Per_CPU_Information+0xc>,%a2
48a50: 662c bnes 48a7e <_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 )
48a52: 4aaa 00f4 tstl %a2@(244)
48a56: 670c beqs 48a64 <_Thread_Restart+0x60>
_Context_Restore_fp( &_Thread_Executing->fp_context );
48a58: 486a 00f4 pea %a2@(244)
48a5c: 4eb9 0004 93b4 jsr 493b4 <_CPU_Context_restore_fp>
48a62: 588f addql #4,%sp
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
48a64: 2079 0005 e2c4 moveal 5e2c4 <_Per_CPU_Information+0xc>,%a0
48a6a: 41e8 00c0 lea %a0@(192),%a0
48a6e: 2f08 movel %a0,%sp@-
48a70: 4eb9 0004 9262 jsr 49262 <_CPU_Context_Restart_self>
48a76: 588f addql #4,%sp <== NOT EXECUTED
48a78: 6004 bras 48a7e <_Thread_Restart+0x7a> <== NOT EXECUTED
_Thread_Restart_self();
return true;
}
return false;
48a7a: 4200 clrb %d0
48a7c: 6002 bras 48a80 <_Thread_Restart+0x7c>
_User_extensions_Thread_restart( the_thread );
if ( _Thread_Is_executing ( the_thread ) )
_Thread_Restart_self();
return true;
48a7e: 7001 moveq #1,%d0
}
return false;
}
48a80: 246e fffc moveal %fp@(-4),%a2
48a84: 4e5e unlk %fp <== NOT EXECUTED
00047828 <_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 ) ) {
47828: 7202 moveq #2,%d1
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
4782a: 4e56 0000 linkw %fp,#0
4782e: 202e 0010 movel %fp@(16),%d0
47832: 2f0a movel %a2,%sp@-
47834: 246e 000c moveal %fp@(12),%a2
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
47838: 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 ) ) {
4783c: b2aa 0050 cmpl %a2@(80),%d1
47840: 6618 bnes 4785a <_Thread_blocking_operation_Cancel+0x32>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
47842: 123c 0003 moveb #3,%d1
47846: 2541 0050 movel %d1,%a2@(80)
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4784a: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
4784c: 486a 0048 pea %a2@(72)
47850: 4eb9 0004 89c8 jsr 489c8 <_Watchdog_Remove>
47856: 588f addql #4,%sp
47858: 6002 bras 4785c <_Thread_blocking_operation_Cancel+0x34>
} else
_ISR_Enable( level );
4785a: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4785c: 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
}
47860: 246e fffc moveal %fp@(-4),%a2
47864: 203c 1003 fff8 movel #268697592,%d0
4786a: 2d40 000c movel %d0,%fp@(12)
4786e: 4e5e unlk %fp
47870: 4ef9 0004 7954 jmp 47954 <_Thread_Clear_state>
...
0004bf50 <_Thread_queue_Extract_fifo>:
Thread_Control *the_thread
)
{
ISR_Level level;
_ISR_Disable( level );
4bf50: 223c 0000 0700 movel #1792,%d1
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4bf56: 4e56 0000 linkw %fp,#0
4bf5a: 2f0a movel %a2,%sp@-
4bf5c: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
_ISR_Disable( level );
4bf60: 40c0 movew %sr,%d0
4bf62: 8280 orl %d0,%d1
4bf64: 46c1 movew %d1,%sr
4bf66: 222a 0010 movel %a2@(16),%d1
4bf6a: 0281 0003 bee0 andil #245472,%d1
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4bf70: 660a bnes 4bf7c <_Thread_queue_Extract_fifo+0x2c>
_ISR_Enable( level );
4bf72: 46c0 movew %d0,%sr
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
4bf74: 246e fffc moveal %fp@(-4),%a2
4bf78: 4e5e unlk %fp
4bf7a: 4e75 rts
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4bf7c: 2252 moveal %a2@,%a1
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4bf7e: 7202 moveq #2,%d1
previous = the_node->previous;
4bf80: 206a 0004 moveal %a2@(4),%a0
next->previous = previous;
4bf84: 2348 0004 movel %a0,%a1@(4)
previous->next = next;
4bf88: 2089 movel %a1,%a0@
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
4bf8a: 42aa 0044 clrl %a2@(68)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4bf8e: b2aa 0050 cmpl %a2@(80),%d1
4bf92: 6704 beqs 4bf98 <_Thread_queue_Extract_fifo+0x48>
_ISR_Enable( level );
4bf94: 46c0 movew %d0,%sr
4bf96: 6014 bras 4bfac <_Thread_queue_Extract_fifo+0x5c>
4bf98: 7203 moveq #3,%d1
4bf9a: 2541 0050 movel %d1,%a2@(80)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4bf9e: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
4bfa0: 486a 0048 pea %a2@(72)
4bfa4: 4eb9 0004 89c8 jsr 489c8 <_Watchdog_Remove>
4bfaa: 588f addql #4,%sp
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4bfac: 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
}
4bfb0: 246e fffc moveal %fp@(-4),%a2
4bfb4: 203c 1003 fff8 movel #268697592,%d0
4bfba: 2d40 000c movel %d0,%fp@(12)
4bfbe: 4e5e unlk %fp
4bfc0: 4ef9 0004 7954 jmp 47954 <_Thread_Clear_state>
...
00048368 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
48368: 4e56 fff0 linkw %fp,#-16
4836c: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
48370: 246e 0008 moveal %fp@(8),%a2
48374: 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 )
48378: 4a8a tstl %a2
4837a: 6746 beqs 483c2 <_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 ) {
4837c: 7001 moveq #1,%d0
4837e: b0aa 0034 cmpl %a2@(52),%d0
48382: 663e bnes 483c2 <_Thread_queue_Requeue+0x5a> <== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
48384: 303c 0700 movew #1792,%d0
48388: 40c2 movew %sr,%d2
4838a: 8082 orl %d2,%d0
4838c: 46c0 movew %d0,%sr
4838e: 202b 0010 movel %a3@(16),%d0
48392: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
48398: 6726 beqs 483c0 <_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;
4839a: 7001 moveq #1,%d0
4839c: 2540 0030 movel %d0,%a2@(48)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
483a0: 4878 0001 pea 1 <ADD>
483a4: 2f0b movel %a3,%sp@-
483a6: 2f0a movel %a2,%sp@-
483a8: 4eb9 0004 abb4 jsr 4abb4 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
483ae: 486e fffc pea %fp@(-4)
483b2: 2f0b movel %a3,%sp@-
483b4: 2f0a movel %a2,%sp@-
483b6: 4eb9 0004 816c jsr 4816c <_Thread_queue_Enqueue_priority>
483bc: 4fef 0018 lea %sp@(24),%sp
}
_ISR_Enable( level );
483c0: 46c2 movew %d2,%sr
}
}
483c2: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
483c8: 4e5e unlk %fp <== NOT EXECUTED
000483cc <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
483cc: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
483d0: 486e fffc pea %fp@(-4)
483d4: 2f2e 0008 movel %fp@(8),%sp@-
483d8: 4eb9 0004 7cf0 jsr 47cf0 <_Thread_Get>
switch ( location ) {
483de: 508f addql #8,%sp
483e0: 4aae fffc tstl %fp@(-4)
483e4: 661e bnes 48404 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
483e6: 2f00 movel %d0,%sp@-
483e8: 4eb9 0004 ac78 jsr 4ac78 <_Thread_queue_Process_timeout>
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
return _Thread_Dispatch_disable_level;
483ee: 588f addql #4,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
483f0: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
483f6: 5380 subql #1,%d0
483f8: 23c0 0005 d828 movel %d0,5d828 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
483fe: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
_Thread_Unnest_dispatch();
break;
}
}
48404: 4e5e unlk %fp <== NOT EXECUTED
000519e0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
519e0: 4e56 ffc0 linkw %fp,#-64
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
519e4: 200e movel %fp,%d0
519e6: 41ee ffec lea %fp@(-20),%a0
519ea: 5180 subql #8,%d0
519ec: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
519f0: 246e 0008 moveal %fp@(8),%a2
519f4: 2e0e movel %fp,%d7
519f6: 260e movel %fp,%d3
519f8: 0687 ffff ffe8 addil #-24,%d7
519fe: 0683 ffff fff4 addil #-12,%d3
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a04: 2a0a movel %a2,%d5
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
51a06: 240a movel %a2,%d2
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a08: 0685 0000 0030 addil #48,%d5
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
51a0e: 0682 0000 0068 addil #104,%d2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51a14: 2c08 movel %a0,%d6
51a16: 2800 movel %d0,%d4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
51a18: 2d48 ffe8 movel %a0,%fp@(-24)
head->previous = NULL;
51a1c: 42ae ffec clrl %fp@(-20)
tail->previous = head;
51a20: 2d47 fff0 movel %d7,%fp@(-16)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
51a24: 2d40 fff4 movel %d0,%fp@(-12)
head->previous = NULL;
51a28: 42ae fff8 clrl %fp@(-8)
tail->previous = head;
51a2c: 2d43 fffc movel %d3,%fp@(-4)
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
51a30: 2547 0078 movel %d7,%a2@(120)
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a34: 47f9 0005 56c0 lea 556c0 <_Watchdog_Adjust_to_chain>,%a3
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
51a3a: 4bf9 0005 5640 lea 55640 <_Watchdog_Adjust>,%a5
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
51a40: 2039 0007 5764 movel 75764 <_Watchdog_Ticks_since_boot>,%d0
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
51a46: 222a 003c movel %a2@(60),%d1
watchdogs->last_snapshot = snapshot;
51a4a: 2540 003c movel %d0,%a2@(60)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a4e: 9081 subl %d1,%d0
51a50: 2f03 movel %d3,%sp@-
51a52: 2f00 movel %d0,%sp@-
51a54: 2f05 movel %d5,%sp@-
51a56: 4e93 jsr %a3@
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
51a58: 2879 0007 56ee moveal 756ee <_TOD_Now>,%a4
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
51a5e: 4fef 000c lea %sp@(12),%sp
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
51a62: 202a 0074 movel %a2@(116),%d0
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
51a66: b08c cmpl %a4,%d0
51a68: 640e bccs 51a78 <_Timer_server_Body+0x98>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a6a: 2f03 movel %d3,%sp@-
51a6c: 220c movel %a4,%d1
51a6e: 9280 subl %d0,%d1
51a70: 2f01 movel %d1,%sp@-
51a72: 2f02 movel %d2,%sp@-
51a74: 4e93 jsr %a3@
51a76: 6010 bras 51a88 <_Timer_server_Body+0xa8>
} else if ( snapshot < last_snapshot ) {
51a78: b08c cmpl %a4,%d0
51a7a: 6310 blss 51a8c <_Timer_server_Body+0xac>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
51a7c: 908c subl %a4,%d0
51a7e: 2f00 movel %d0,%sp@-
51a80: 4878 0001 pea 1 <ADD>
51a84: 2f02 movel %d2,%sp@-
51a86: 4e95 jsr %a5@
51a88: 4fef 000c lea %sp@(12),%sp
}
watchdogs->last_snapshot = snapshot;
51a8c: 254c 0074 movel %a4,%a2@(116)
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51a90: 49f9 0005 574c lea 5574c <_Watchdog_Insert>,%a4
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
51a96: 202a 0078 movel %a2@(120),%d0
51a9a: 2f00 movel %d0,%sp@-
51a9c: 4eb9 0005 2468 jsr 52468 <_Chain_Get>
if ( timer == NULL ) {
51aa2: 588f addql #4,%sp
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
51aa4: 2040 moveal %d0,%a0
if ( timer == NULL ) {
51aa6: 4a80 tstl %d0
51aa8: 6724 beqs 51ace <_Timer_server_Body+0xee>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51aaa: 2028 0038 movel %a0@(56),%d0
51aae: 7201 moveq #1,%d1
51ab0: b280 cmpl %d0,%d1
51ab2: 6608 bnes 51abc <_Timer_server_Body+0xdc>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
51ab4: 4868 0010 pea %a0@(16)
51ab8: 2f05 movel %d5,%sp@-
51aba: 600c bras 51ac8 <_Timer_server_Body+0xe8>
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
51abc: 7203 moveq #3,%d1
51abe: b280 cmpl %d0,%d1
51ac0: 66d4 bnes 51a96 <_Timer_server_Body+0xb6> <== NEVER TAKEN
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51ac2: 4868 0010 pea %a0@(16)
51ac6: 2f02 movel %d2,%sp@-
51ac8: 4e94 jsr %a4@
51aca: 508f addql #8,%sp
51acc: 60c8 bras 51a96 <_Timer_server_Body+0xb6>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
51ace: 203c 0000 0700 movel #1792,%d0
51ad4: 40c1 movew %sr,%d1
51ad6: 8081 orl %d1,%d0
51ad8: 46c0 movew %d0,%sr
if ( _Chain_Is_empty( insert_chain ) ) {
51ada: bcae ffe8 cmpl %fp@(-24),%d6
51ade: 6612 bnes 51af2 <_Timer_server_Body+0x112> <== NEVER TAKEN
ts->insert_chain = NULL;
51ae0: 42aa 0078 clrl %a2@(120)
_ISR_Enable( level );
51ae4: 46c1 movew %d1,%sr
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
51ae6: 367c 0700 moveaw #1792,%a3
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
51aea: b8ae fff4 cmpl %fp@(-12),%d4
51aee: 6608 bnes 51af8 <_Timer_server_Body+0x118>
51af0: 603e bras 51b30 <_Timer_server_Body+0x150>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
51af2: 46c1 movew %d1,%sr <== NOT EXECUTED
51af4: 6000 ff4a braw 51a40 <_Timer_server_Body+0x60> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
51af8: 200b movel %a3,%d0
51afa: 40c1 movew %sr,%d1
51afc: 8081 orl %d1,%d0
51afe: 46c0 movew %d0,%sr
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51b00: 206e fff4 moveal %fp@(-12),%a0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
51b04: b888 cmpl %a0,%d4
51b06: 6722 beqs 51b2a <_Timer_server_Body+0x14a>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
51b08: 2250 moveal %a0@,%a1
head->next = new_first;
new_first->previous = head;
51b0a: 2343 0004 movel %d3,%a1@(4)
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
51b0e: 42a8 0008 clrl %a0@(8)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
51b12: 2d49 fff4 movel %a1,%fp@(-12)
_ISR_Enable( level );
51b16: 46c1 movew %d1,%sr
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
51b18: 2f28 0024 movel %a0@(36),%sp@-
51b1c: 2f28 0020 movel %a0@(32),%sp@-
51b20: 2068 001c moveal %a0@(28),%a0
51b24: 4e90 jsr %a0@
}
51b26: 508f addql #8,%sp
51b28: 60ce bras 51af8 <_Timer_server_Body+0x118>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
51b2a: 46c1 movew %d1,%sr
51b2c: 6000 ff02 braw 51a30 <_Timer_server_Body+0x50>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
51b30: 47f9 0005 5870 lea 55870 <_Watchdog_Remove>,%a3
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
51b36: 4200 clrb %d0
51b38: 1540 007c moveb %d0,%a2@(124)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
51b3c: 4eba fdc2 jsr %pc@(51900 <_Thread_Disable_dispatch>)
_Thread_Set_state( ts->thread, STATES_DELAYING );
51b40: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
51b44: 2f12 movel %a2@,%sp@-
51b46: 4eb9 0005 511c jsr 5511c <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
51b4c: 2f0a movel %a2,%sp@-
51b4e: 4eba fdcc jsr %pc@(5191c <_Timer_server_Reset_interval_system_watchdog>)
_Timer_server_Reset_tod_system_watchdog( ts );
51b52: 2f0a movel %a2,%sp@-
51b54: 4eba fe26 jsr %pc@(5197c <_Timer_server_Reset_tod_system_watchdog>)
_Thread_Enable_dispatch();
51b58: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
ts->active = true;
51b5e: 7201 moveq #1,%d1
51b60: 1541 007c moveb %d1,%a2@(124)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
51b64: 486a 0008 pea %a2@(8)
51b68: 4e93 jsr %a3@
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
51b6a: 486a 0040 pea %a2@(64)
51b6e: 4e93 jsr %a3@
51b70: 4fef 0018 lea %sp@(24),%sp
51b74: 6000 feba braw 51a30 <_Timer_server_Body+0x50>
00051b78 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
51b78: 4e56 fff0 linkw %fp,#-16
51b7c: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
51b80: 246e 0008 moveal %fp@(8),%a2
51b84: 266e 000c moveal %fp@(12),%a3
if ( ts->insert_chain == NULL ) {
51b88: 202a 0078 movel %a2@(120),%d0
51b8c: 6600 00ea bnew 51c78 <_Timer_server_Schedule_operation_method+0x100>
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
51b90: 4eba fd6e jsr %pc@(51900 <_Thread_Disable_dispatch>)
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51b94: 202b 0038 movel %a3@(56),%d0
51b98: 7201 moveq #1,%d1
51b9a: b280 cmpl %d0,%d1
51b9c: 665c bnes 51bfa <_Timer_server_Schedule_operation_method+0x82>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
51b9e: 203c 0000 0700 movel #1792,%d0
51ba4: 40c2 movew %sr,%d2
51ba6: 8082 orl %d2,%d0
51ba8: 46c0 movew %d0,%sr
snapshot = _Watchdog_Ticks_since_boot;
51baa: 2039 0007 5764 movel 75764 <_Watchdog_Ticks_since_boot>,%d0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51bb0: 43ea 0034 lea %a2@(52),%a1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
51bb4: 222a 003c movel %a2@(60),%d1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51bb8: 206a 0030 moveal %a2@(48),%a0
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
51bbc: b3c8 cmpal %a0,%a1
51bbe: 6716 beqs 51bd6 <_Timer_server_Schedule_operation_method+0x5e>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
51bc0: 2240 moveal %d0,%a1
51bc2: 93c1 subal %d1,%a1
delta_interval = first_watchdog->delta_interval;
51bc4: 2228 0010 movel %a0@(16),%d1
if (delta_interval > delta) {
51bc8: b3c1 cmpal %d1,%a1
51bca: 6404 bccs 51bd0 <_Timer_server_Schedule_operation_method+0x58>
delta_interval -= delta;
51bcc: 9289 subl %a1,%d1
51bce: 6002 bras 51bd2 <_Timer_server_Schedule_operation_method+0x5a>
} else {
delta_interval = 0;
51bd0: 4281 clrl %d1
}
first_watchdog->delta_interval = delta_interval;
51bd2: 2141 0010 movel %d1,%a0@(16)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
51bd6: 2540 003c movel %d0,%a2@(60)
_ISR_Enable( level );
51bda: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
51bdc: 486b 0010 pea %a3@(16)
51be0: 486a 0030 pea %a2@(48)
51be4: 4eb9 0005 574c jsr 5574c <_Watchdog_Insert>
if ( !ts->active ) {
51bea: 508f addql #8,%sp
51bec: 102a 007c moveb %a2@(124),%d0
51bf0: 6678 bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_interval_system_watchdog( ts );
51bf2: 2f0a movel %a2,%sp@-
51bf4: 4eba fd26 jsr %pc@(5191c <_Timer_server_Reset_interval_system_watchdog>)
51bf8: 606e bras 51c68 <_Timer_server_Schedule_operation_method+0xf0>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
51bfa: 7203 moveq #3,%d1
51bfc: b280 cmpl %d0,%d1
51bfe: 666a bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
51c00: 203c 0000 0700 movel #1792,%d0
51c06: 40c2 movew %sr,%d2
51c08: 8082 orl %d2,%d0
51c0a: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51c0c: 200a movel %a2,%d0
51c0e: 0680 0000 006c addil #108,%d0
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
51c14: 2239 0007 56ee movel 756ee <_TOD_Now>,%d1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
51c1a: 226a 0074 moveal %a2@(116),%a1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51c1e: 206a 0068 moveal %a2@(104),%a0
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
51c22: b088 cmpl %a0,%d0
51c24: 6720 beqs 51c46 <_Timer_server_Schedule_operation_method+0xce>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
51c26: 2028 0010 movel %a0@(16),%d0
if ( snapshot > last_snapshot ) {
51c2a: b3c1 cmpal %d1,%a1
51c2c: 640c bccs 51c3a <_Timer_server_Schedule_operation_method+0xc2>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
51c2e: 2841 moveal %d1,%a4
51c30: 99c9 subal %a1,%a4
if (delta_interval > delta) {
51c32: b9c0 cmpal %d0,%a4
51c34: 640a bccs 51c40 <_Timer_server_Schedule_operation_method+0xc8><== NEVER TAKEN
delta_interval -= delta;
51c36: 908c subl %a4,%d0
51c38: 6008 bras 51c42 <_Timer_server_Schedule_operation_method+0xca>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
51c3a: d089 addl %a1,%d0
delta_interval += delta;
51c3c: 9081 subl %d1,%d0
51c3e: 6002 bras 51c42 <_Timer_server_Schedule_operation_method+0xca>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
51c40: 4280 clrl %d0 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
51c42: 2140 0010 movel %d0,%a0@(16)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
51c46: 2541 0074 movel %d1,%a2@(116)
_ISR_Enable( level );
51c4a: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51c4c: 486b 0010 pea %a3@(16)
51c50: 486a 0068 pea %a2@(104)
51c54: 4eb9 0005 574c jsr 5574c <_Watchdog_Insert>
if ( !ts->active ) {
51c5a: 508f addql #8,%sp
51c5c: 102a 007c moveb %a2@(124),%d0
51c60: 6608 bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_tod_system_watchdog( ts );
51c62: 2f0a movel %a2,%sp@-
51c64: 4eba fd16 jsr %pc@(5197c <_Timer_server_Reset_tod_system_watchdog>)
51c68: 588f addql #4,%sp
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
51c6a: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
51c70: 4e5e unlk %fp
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
51c72: 4ef9 0005 4940 jmp 54940 <_Thread_Enable_dispatch>
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
51c78: 202a 0078 movel %a2@(120),%d0
51c7c: 2d4b 000c movel %a3,%fp@(12)
}
}
51c80: 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 );
51c86: 2d40 0008 movel %d0,%fp@(8)
}
}
51c8a: 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 );
51c8c: 4ef9 0005 2408 jmp 52408 <_Chain_Append>
00048634 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
48634: 4e56 ffe8 linkw %fp,#-24
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48638: 203c 0005 d970 movel #383344,%d0
4863e: 23c0 0005 d96c movel %d0,5d96c <_User_extensions_List>
head->previous = NULL;
tail->previous = head;
48644: 203c 0005 d96c movel #383340,%d0
4864a: 23c0 0005 d974 movel %d0,5d974 <_User_extensions_List+0x8>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48650: 203c 0005 d830 movel #383024,%d0
48656: 23c0 0005 d82c movel %d0,5d82c <_User_extensions_Switches_list>
head->previous = NULL;
tail->previous = head;
4865c: 203c 0005 d82c movel #383020,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
48662: 42b9 0005 d970 clrl 5d970 <_User_extensions_List+0x4>
48668: 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;
4866c: 2839 0005 bf02 movel 5bf02 <Configuration+0x36>,%d4
initial_extensions = Configuration.User_extension_table;
48672: 2639 0005 bf06 movel 5bf06 <Configuration+0x3a>,%d3
48678: 42b9 0005 d830 clrl 5d830 <_User_extensions_Switches_list+0x4>
tail->previous = head;
4867e: 23c0 0005 d834 movel %d0,5d834 <_User_extensions_Switches_list+0x8>
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
48684: 4a83 tstl %d3
48686: 6754 beqs 486dc <_User_extensions_Handler_initialization+0xa8><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
48688: 7434 moveq #52,%d2
4868a: 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;
4868e: 49f9 0004 c854 lea 4c854 <memcpy>,%a4
_User_extensions_Add_set( extension );
48694: 47f9 0004 acec lea 4acec <_User_extensions_Add_set>,%a3
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
4869a: 2f02 movel %d2,%sp@-
4869c: 4eb9 0004 8b56 jsr 48b56 <_Workspace_Allocate_or_fatal_error>
486a2: 2440 moveal %d0,%a2
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
486a4: 2f02 movel %d2,%sp@-
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
486a6: 4282 clrl %d2
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
486a8: 42a7 clrl %sp@-
486aa: 2f00 movel %d0,%sp@-
486ac: 4eb9 0004 c8c4 jsr 4c8c4 <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
486b2: 4fef 0010 lea %sp@(16),%sp
486b6: 6020 bras 486d8 <_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;
486b8: 4878 0020 pea 20 <OPER2+0xc>
486bc: 5282 addql #1,%d2
486be: 2f03 movel %d3,%sp@-
486c0: 486a 0014 pea %a2@(20)
486c4: 0683 0000 0020 addil #32,%d3
486ca: 4e94 jsr %a4@
_User_extensions_Add_set( extension );
486cc: 2f0a movel %a2,%sp@-
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
486ce: 45ea 0034 lea %a2@(52),%a2
486d2: 4e93 jsr %a3@
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
486d4: 4fef 0010 lea %sp@(16),%sp
486d8: b882 cmpl %d2,%d4
486da: 66dc bnes 486b8 <_User_extensions_Handler_initialization+0x84>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
486dc: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
486e2: 4e5e unlk %fp
...
00049b64 <_Watchdog_Adjust>:
Watchdog_Interval units
)
{
ISR_Level level;
_ISR_Disable( level );
49b64: 327c 0700 moveaw #1792,%a1
49b68: 2209 movel %a1,%d1
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
49b6a: 4e56 ffec linkw %fp,#-20
49b6e: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@
49b72: 266e 0008 moveal %fp@(8),%a3
49b76: 262e 000c movel %fp@(12),%d3
49b7a: 242e 0010 movel %fp@(16),%d2
ISR_Level level;
_ISR_Disable( level );
49b7e: 40c0 movew %sr,%d0
49b80: 8280 orl %d0,%d1
49b82: 46c1 movew %d1,%sr
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
49b84: 244b moveal %a3,%a2
49b86: 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 ) ) {
49b88: b5c8 cmpal %a0,%a2
49b8a: 674c beqs 49bd8 <_Watchdog_Adjust+0x74>
switch ( direction ) {
49b8c: 4a83 tstl %d3
49b8e: 673c beqs 49bcc <_Watchdog_Adjust+0x68>
49b90: 7201 moveq #1,%d1
49b92: b283 cmpl %d3,%d1
49b94: 6642 bnes 49bd8 <_Watchdog_Adjust+0x74> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
49b96: d5a8 0010 addl %d2,%a0@(16)
break;
49b9a: 603c bras 49bd8 <_Watchdog_Adjust+0x74>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
49b9c: 2053 moveal %a3@,%a0
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
49b9e: 2228 0010 movel %a0@(16),%d1
49ba2: b282 cmpl %d2,%d1
49ba4: 6308 blss 49bae <_Watchdog_Adjust+0x4a>
_Watchdog_First( header )->delta_interval -= units;
49ba6: 9282 subl %d2,%d1
49ba8: 2141 0010 movel %d1,%a0@(16)
break;
49bac: 602a bras 49bd8 <_Watchdog_Adjust+0x74>
} else {
units -= _Watchdog_First( header )->delta_interval;
49bae: 9481 subl %d1,%d2
_Watchdog_First( header )->delta_interval = 1;
49bb0: 7201 moveq #1,%d1
49bb2: 2141 0010 movel %d1,%a0@(16)
_ISR_Enable( level );
49bb6: 46c0 movew %d0,%sr
_Watchdog_Tickle( header );
49bb8: 2f0b movel %a3,%sp@-
49bba: 4e94 jsr %a4@
_ISR_Disable( level );
49bbc: 2203 movel %d3,%d1
49bbe: 40c0 movew %sr,%d0
49bc0: 8280 orl %d0,%d1
49bc2: 46c1 movew %d1,%sr
if ( _Chain_Is_empty( header ) )
49bc4: 588f addql #4,%sp
49bc6: b5d3 cmpal %a3@,%a2
49bc8: 660a bnes 49bd4 <_Watchdog_Adjust+0x70>
49bca: 600c bras 49bd8 <_Watchdog_Adjust+0x74>
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
_Watchdog_Tickle( header );
49bcc: 49f9 0004 9d84 lea 49d84 <_Watchdog_Tickle>,%a4
_ISR_Disable( level );
49bd2: 2609 movel %a1,%d3
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
49bd4: 4a82 tstl %d2
49bd6: 66c4 bnes 49b9c <_Watchdog_Adjust+0x38> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
49bd8: 46c0 movew %d0,%sr
}
49bda: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
49be0: 4e5e unlk %fp <== NOT EXECUTED
000488a4 <_Watchdog_Insert>:
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
_ISR_Disable( level );
488a4: 327c 0700 moveaw #1792,%a1
488a8: 2009 movel %a1,%d0
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
488aa: 4e56 ffec linkw %fp,#-20
488ae: 206e 000c moveal %fp@(12),%a0
488b2: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
488b6: 266e 0008 moveal %fp@(8),%a3
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
488ba: 2439 0005 d9b8 movel 5d9b8 <_Per_CPU_Information+0x8>,%d2
_ISR_Disable( level );
488c0: 40c1 movew %sr,%d1
488c2: 8081 orl %d1,%d0
488c4: 46c0 movew %d0,%sr
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
488c6: 4aa8 0008 tstl %a0@(8)
488ca: 6600 0098 bnew 48964 <_Watchdog_Insert+0xc0>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
488ce: 7001 moveq #1,%d0
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
488d0: 2449 moveal %a1,%a2
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
488d2: 2140 0008 movel %d0,%a0@(8)
_Watchdog_Sync_count++;
488d6: 2039 0005 d924 movel 5d924 <_Watchdog_Sync_count>,%d0
488dc: 5280 addql #1,%d0
488de: 23c0 0005 d924 movel %d0,5d924 <_Watchdog_Sync_count>
restart:
delta_interval = the_watchdog->initial;
488e4: 2028 000c movel %a0@(12),%d0
488e8: 2253 moveal %a3@,%a1
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
488ea: 4a80 tstl %d0
488ec: 673c beqs 4892a <_Watchdog_Insert+0x86>
488ee: 4a91 tstl %a1@
488f0: 6738 beqs 4892a <_Watchdog_Insert+0x86>
break;
if ( delta_interval < after->delta_interval ) {
488f2: 2629 0010 movel %a1@(16),%d3
488f6: b680 cmpl %d0,%d3
488f8: 6308 blss 48902 <_Watchdog_Insert+0x5e>
after->delta_interval -= delta_interval;
488fa: 9680 subl %d0,%d3
488fc: 2343 0010 movel %d3,%a1@(16)
break;
48900: 6028 bras 4892a <_Watchdog_Insert+0x86>
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
48902: 280a movel %a2,%d4
48904: 46c1 movew %d1,%sr
48906: 8881 orl %d1,%d4
48908: 46c4 movew %d4,%sr
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
4890a: 7801 moveq #1,%d4
4890c: b8a8 0008 cmpl %a0@(8),%d4
48910: 663e bnes 48950 <_Watchdog_Insert+0xac> <== NEVER TAKEN
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
48912: 2839 0005 d8cc movel 5d8cc <_Watchdog_Sync_level>,%d4
48918: b484 cmpl %d4,%d2
4891a: 6408 bccs 48924 <_Watchdog_Insert+0x80>
_Watchdog_Sync_level = insert_isr_nest_level;
4891c: 23c2 0005 d8cc movel %d2,5d8cc <_Watchdog_Sync_level>
goto restart;
48922: 60c0 bras 488e4 <_Watchdog_Insert+0x40>
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
48924: 2251 moveal %a1@,%a1
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
48926: 9083 subl %d3,%d0
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
goto restart;
}
}
48928: 60c0 bras 488ea <_Watchdog_Insert+0x46>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
4892a: 2269 0004 moveal %a1@(4),%a1
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
4892e: 7602 moveq #2,%d3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
48930: 2451 moveal %a1@,%a2
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
48932: 2140 0010 movel %d0,%a0@(16)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
48936: 2039 0005 d928 movel 5d928 <_Watchdog_Ticks_since_boot>,%d0
4893c: 2143 0008 movel %d3,%a0@(8)
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
48940: 2149 0004 movel %a1,%a0@(4)
before_node = after_node->next;
after_node->next = the_node;
48944: 2288 movel %a0,%a1@
the_node->next = before_node;
before_node->previous = the_node;
48946: 2548 0004 movel %a0,%a2@(4)
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
4894a: 208a movel %a2,%a0@
4894c: 2140 0014 movel %d0,%a0@(20)
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
48950: 23c2 0005 d8cc movel %d2,5d8cc <_Watchdog_Sync_level>
_Watchdog_Sync_count--;
48956: 2039 0005 d924 movel 5d924 <_Watchdog_Sync_count>,%d0
4895c: 5380 subql #1,%d0
4895e: 23c0 0005 d924 movel %d0,5d924 <_Watchdog_Sync_count>
_ISR_Enable( level );
48964: 46c1 movew %d1,%sr
}
48966: 4cd7 0c1c moveml %sp@,%d2-%d4/%a2-%a3
4896a: 4e5e unlk %fp
...
000489c8 <_Watchdog_Remove>:
{
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
489c8: 203c 0000 0700 movel #1792,%d0
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
489ce: 4e56 0000 linkw %fp,#0
489d2: 206e 0008 moveal %fp@(8),%a0
489d6: 2f0a movel %a2,%sp@-
489d8: 2f02 movel %d2,%sp@-
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
489da: 40c1 movew %sr,%d1
489dc: 8081 orl %d1,%d0
489de: 46c0 movew %d0,%sr
previous_state = the_watchdog->state;
489e0: 2028 0008 movel %a0@(8),%d0
switch ( previous_state ) {
489e4: 7401 moveq #1,%d2
489e6: b480 cmpl %d0,%d2
489e8: 670c beqs 489f6 <_Watchdog_Remove+0x2e>
489ea: 6242 bhis 48a2e <_Watchdog_Remove+0x66>
489ec: 143c 0003 moveb #3,%d2
489f0: b480 cmpl %d0,%d2
489f2: 653a bcss 48a2e <_Watchdog_Remove+0x66> <== NEVER TAKEN
489f4: 6006 bras 489fc <_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;
489f6: 42a8 0008 clrl %a0@(8)
break;
489fa: 6032 bras 48a2e <_Watchdog_Remove+0x66>
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
489fc: 2250 moveal %a0@,%a1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
489fe: 42a8 0008 clrl %a0@(8)
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
48a02: 4a91 tstl %a1@
48a04: 6708 beqs 48a0e <_Watchdog_Remove+0x46>
next_watchdog->delta_interval += the_watchdog->delta_interval;
48a06: 2428 0010 movel %a0@(16),%d2
48a0a: d5a9 0010 addl %d2,%a1@(16)
if ( _Watchdog_Sync_count )
48a0e: 2479 0005 d924 moveal 5d924 <_Watchdog_Sync_count>,%a2
48a14: 4a8a tstl %a2
48a16: 670c beqs 48a24 <_Watchdog_Remove+0x5c>
_Watchdog_Sync_level = _ISR_Nest_level;
48a18: 45f9 0005 d9b8 lea 5d9b8 <_Per_CPU_Information+0x8>,%a2
48a1e: 23d2 0005 d8cc movel %a2@,5d8cc <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
48a24: 2468 0004 moveal %a0@(4),%a2
next->previous = previous;
48a28: 234a 0004 movel %a2,%a1@(4)
previous->next = next;
48a2c: 2489 movel %a1,%a2@
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
48a2e: 2279 0005 d928 moveal 5d928 <_Watchdog_Ticks_since_boot>,%a1
48a34: 2149 0018 movel %a1,%a0@(24)
_ISR_Enable( level );
48a38: 46c1 movew %d1,%sr
return( previous_state );
}
48a3a: 241f movel %sp@+,%d2
48a3c: 245f moveal %sp@+,%a2
48a3e: 4e5e unlk %fp
...
00059b78 <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
59b78: 4280 clrl %d0 <== NOT EXECUTED
return 0;
}
#endif
int __kill( pid_t pid, int sig )
{
59b7a: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return 0;
}
59b7e: 4e5e unlk %fp <== NOT EXECUTED
...
00059a60 <_calloc_r>:
void *_calloc_r(
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
59a60: 4e56 0000 linkw %fp,#0
59a64: 202e 000c movel %fp@(12),%d0
return calloc( elements, size );
59a68: 2d6e 0010 000c movel %fp@(16),%fp@(12)
59a6e: 2d40 0008 movel %d0,%fp@(8)
}
59a72: 4e5e unlk %fp
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
return calloc( elements, size );
59a74: 4ef9 0004 27cc jmp 427cc <calloc>
...
00049be0 <_close_r>:
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
49be0: 4e56 0000 linkw %fp,#0
return close( fd );
49be4: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
49bea: 4e5e unlk %fp
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return close( fd );
49bec: 4ef9 0004 9b70 jmp 49b70 <close>
...
00043334 <_exit>:
extern void FINI_SYMBOL( void );
#endif
void EXIT_SYMBOL(int status)
{
43334: 4e56 0000 linkw %fp,#0
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(FINI_SYMBOL)
FINI_SYMBOL();
43338: 4eb9 0005 a190 jsr 5a190 <_fini>
* We need to do the exit processing on the global reentrancy structure.
* This has already been done on the per task reentrancy structure
* associated with this task.
*/
libc_wrapup();
4333e: 4eb9 0004 32d0 jsr 432d0 <libc_wrapup>
rtems_shutdown_executive(status);
43344: 2f2e 0008 movel %fp@(8),%sp@-
43348: 4eb9 0004 602c jsr 4602c <rtems_shutdown_executive>
...
000507c2 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
507c2: 4e56 ffd4 linkw %fp,#-44
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
507c6: 206e 0008 moveal %fp@(8),%a0
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
507ca: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
507ce: 244e moveal %fp,%a2
void *buff
)
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
507d0: 4283 clrl %d3
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
507d2: 4bf9 0005 04b0 lea 504b0 <fat_buf_access>,%a5
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
507d8: 49f9 0005 87d8 lea 587d8 <memcpy>,%a4
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
507de: 282e 0014 movel %fp@(20),%d4
507e2: 2e2e 0018 movel %fp@(24),%d7
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
507e6: 2668 0034 moveal %a0@(52),%a3
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
507ea: 42a2 clrl %a2@-
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
507ec: 2c2e 0010 movel %fp@(16),%d6
)
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
507f0: 2a2e 000c movel %fp@(12),%d5
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
507f4: 6040 bras 50836 <_fat_block_read+0x74>
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
507f6: 2f0a movel %a2,%sp@-
507f8: 4878 0001 pea 1 <ADD>
507fc: 2f05 movel %d5,%sp@-
507fe: 2f0b movel %a3,%sp@-
50800: 4e95 jsr %a5@
if (rc != RC_OK)
50802: 4fef 0010 lea %sp@(16),%sp
50806: 4a80 tstl %d0
50808: 6632 bnes 5083c <_fat_block_read+0x7a> <== NEVER TAKEN
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
5080a: 4282 clrl %d2
5080c: 3413 movew %a3@,%d2
5080e: 9486 subl %d6,%d2
50810: b882 cmpl %d2,%d4
50812: 6402 bccs 50816 <_fat_block_read+0x54>
50814: 2404 movel %d4,%d2
memcpy((buff + cmpltd), (block->buffer + ofs), c);
50816: 206e fffc moveal %fp@(-4),%a0
count -= c;
5081a: 9882 subl %d2,%d4
cmpltd += c;
blk++;
5081c: 5285 addql #1,%d5
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
5081e: 2f02 movel %d2,%sp@-
50820: dca8 001e addl %a0@(30),%d6
50824: 2047 moveal %d7,%a0
50826: 2f06 movel %d6,%sp@-
50828: 4870 3800 pea %a0@(00000000,%d3:l)
count -= c;
cmpltd += c;
blk++;
ofs = 0;
5082c: 4286 clrl %d6
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
count -= c;
cmpltd += c;
5082e: d682 addl %d2,%d3
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
50830: 4e94 jsr %a4@
count -= c;
cmpltd += c;
blk++;
ofs = 0;
50832: 4fef 000c lea %sp@(12),%sp
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
50836: 4a84 tstl %d4
50838: 66bc bnes 507f6 <_fat_block_read+0x34>
5083a: 6002 bras 5083e <_fat_block_read+0x7c>
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
5083c: 76ff moveq #-1,%d3 <== NOT EXECUTED
cmpltd += c;
blk++;
ofs = 0;
}
return cmpltd;
}
5083e: 2003 movel %d3,%d0
50840: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
50846: 4e5e unlk %fp <== NOT EXECUTED
000508e6 <_fat_block_release>:
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
508e6: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
508ea: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
508ee: 2d68 0034 0008 movel %a0@(52),%fp@(8) <== NOT EXECUTED
}
508f4: 4e5e unlk %fp <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
508f6: 4ef9 0005 0690 jmp 50690 <fat_buf_release> <== NOT EXECUTED
0005084a <_fat_block_write>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
5084a: 4e56 ffd4 linkw %fp,#-44
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
5084e: 206e 0008 moveal %fp@(8),%a0
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
50852: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
50856: 244e moveal %fp,%a2
uint32_t count,
const void *buff)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
50858: 4283 clrl %d3
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
5085a: 49f9 0005 04b0 lea 504b0 <fat_buf_access>,%a4
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
50860: 4bf9 0005 87d8 lea 587d8 <memcpy>,%a5
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
50866: 282e 0014 movel %fp@(20),%d4
5086a: 2e2e 0018 movel %fp@(24),%d7
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
5086e: 2668 0034 moveal %a0@(52),%a3
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
50872: 42a2 clrl %a2@-
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
50874: 2c2e 0010 movel %fp@(16),%d6
const void *buff)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
50878: 2a2e 000c movel %fp@(12),%d5
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
5087c: 6054 bras 508d2 <_fat_block_write+0x88>
{
c = MIN(count, (fs_info->vol.bps - ofs));
5087e: 4280 clrl %d0
50880: 3013 movew %a3@,%d0
50882: 2400 movel %d0,%d2
50884: 9486 subl %d6,%d2
50886: b882 cmpl %d2,%d4
50888: 6402 bccs 5088c <_fat_block_write+0x42>
5088a: 2404 movel %d4,%d2
if (c == fs_info->vol.bps)
5088c: b082 cmpl %d2,%d0
5088e: 6608 bnes 50898 <_fat_block_write+0x4e>
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
50890: 2f0a movel %a2,%sp@-
50892: 4878 0002 pea 2 <DOUBLE_FLOAT>
50896: 6006 bras 5089e <_fat_block_write+0x54>
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
50898: 2f0a movel %a2,%sp@-
5089a: 4878 0001 pea 1 <ADD>
5089e: 2f05 movel %d5,%sp@-
508a0: 2f0b movel %a3,%sp@-
508a2: 4e94 jsr %a4@
508a4: 4fef 0010 lea %sp@(16),%sp
if (rc != RC_OK)
508a8: 4a80 tstl %d0
508aa: 662c bnes 508d8 <_fat_block_write+0x8e> <== NEVER TAKEN
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
508ac: 2f02 movel %d2,%sp@-
508ae: 2047 moveal %d7,%a0
508b0: 4870 3800 pea %a0@(00000000,%d3:l)
fat_buf_mark_modified(fs_info);
count -= c;
508b4: 9882 subl %d2,%d4
cmpltd +=c;
508b6: d682 addl %d2,%d3
blk++;
508b8: 5285 addql #1,%d5
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
508ba: 206e fffc moveal %fp@(-4),%a0
508be: dca8 001e addl %a0@(30),%d6
508c2: 2f06 movel %d6,%sp@-
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
ofs = 0;
508c4: 4286 clrl %d6
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
508c6: 4e95 jsr %a5@
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
ofs = 0;
508c8: 4fef 000c lea %sp@(12),%sp
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
508cc: 7001 moveq #1,%d0
508ce: 1740 0076 moveb %d0,%a3@(118)
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
508d2: 4a84 tstl %d4
508d4: 66a8 bnes 5087e <_fat_block_write+0x34>
508d6: 6002 bras 508da <_fat_block_write+0x90>
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
508d8: 76ff moveq #-1,%d3 <== NOT EXECUTED
cmpltd +=c;
blk++;
ofs = 0;
}
return cmpltd;
}
508da: 2003 movel %d3,%d0
508dc: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
508e2: 4e5e unlk %fp <== NOT EXECUTED
0005b0bc <_fcntl_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
int cmd,
int arg
)
{
5b0bc: 4e56 0000 linkw %fp,#0
5b0c0: 222e 0010 movel %fp@(16),%d1
5b0c4: 202e 000c movel %fp@(12),%d0
return fcntl( fd, cmd, arg );
5b0c8: 2d6e 0014 0010 movel %fp@(20),%fp@(16)
5b0ce: 2d41 000c movel %d1,%fp@(12)
5b0d2: 2d40 0008 movel %d0,%fp@(8)
}
5b0d6: 4e5e unlk %fp
int fd,
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
5b0d8: 4ef9 0005 af54 jmp 5af54 <fcntl>
...
00059a7c <_free_r>:
void _free_r(
struct _reent *ignored __attribute__((unused)),
void *ptr
)
{
59a7c: 4e56 0000 linkw %fp,#0
free( ptr );
59a80: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
59a86: 4e5e unlk %fp
void _free_r(
struct _reent *ignored __attribute__((unused)),
void *ptr
)
{
free( ptr );
59a88: 4ef9 0004 2b68 jmp 42b68 <free>
...
00042c68 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
42c68: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return gettimeofday( tp, tzp );
}
42c6c: 4e5e unlk %fp <== NOT EXECUTED
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
42c6e: 4ef9 0004 2bf0 jmp 42bf0 <gettimeofday> <== NOT EXECUTED
0004f9c6 <_hash_search>:
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
4f9c6: 7001 moveq #1,%d0
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
4f9c8: 4e56 ffe8 linkw %fp,#-24
4f9cc: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
4f9d0: 242e 0010 movel %fp@(16),%d2
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
4f9d4: 49fa ff9e lea %pc@(4f974 <fat_construct_key>),%a4
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
4f9d8: c082 andl %d2,%d0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4f9da: 266e 000c moveal %fp@(12),%a3
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4f9de: 2200 movel %d0,%d1
4f9e0: e988 lsll #4,%d0
4f9e2: e589 lsll #2,%d1
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
4f9e4: 282e 0008 movel %fp@(8),%d4
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4f9e8: 9081 subl %d1,%d0
4f9ea: d7c0 addal %d0,%a3
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
4f9ec: 262e 0014 movel %fp@(20),%d3
4f9f0: 245b moveal %a3@+,%a2
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4f9f2: 6024 bras 4fa18 <_hash_search+0x52>
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
4f9f4: 486a 0020 pea %a2@(32)
4f9f8: 2f04 movel %d4,%sp@-
4f9fa: 4e94 jsr %a4@
4f9fc: 508f addql #8,%sp
if ( (key1) == ck)
4f9fe: b082 cmpl %d2,%d0
4fa00: 6614 bnes 4fa16 <_hash_search+0x50>
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
4fa02: 4a83 tstl %d3
4fa04: 6706 beqs 4fa0c <_hash_search+0x46> <== ALWAYS TAKEN
4fa06: b6aa 000c cmpl %a2@(12),%d3 <== NOT EXECUTED
4fa0a: 660a bnes 4fa16 <_hash_search+0x50> <== NOT EXECUTED
{
*ret = (void *)the_node;
4fa0c: 206e 0018 moveal %fp@(24),%a0
return 0;
4fa10: 4280 clrl %d0
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
{
*ret = (void *)the_node;
4fa12: 208a movel %a2,%a0@
return 0;
4fa14: 6008 bras 4fa1e <_hash_search+0x58>
}
}
the_node = the_node->next;
4fa16: 2452 moveal %a2@,%a2
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4fa18: b7ca cmpal %a2,%a3
4fa1a: 66d8 bnes 4f9f4 <_hash_search+0x2e>
return 0;
}
}
the_node = the_node->next;
}
return -1;
4fa1c: 70ff moveq #-1,%d0
}
4fa1e: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
4fa24: 4e5e unlk %fp <== NOT EXECUTED
00059b50 <_isatty_r>:
int _isatty_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
59b50: 4e56 0000 linkw %fp,#0
return isatty( fd );
59b54: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
59b5a: 4e5e unlk %fp
int _isatty_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return isatty( fd );
59b5c: 4ef9 0005 a0e8 jmp 5a0e8 <isatty>
...
00059c50 <_lseek_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
off_t offset,
int whence
)
{
59c50: 4e56 0000 linkw %fp,#0
59c54: 206e 000c moveal %fp@(12),%a0
59c58: 202e 0010 movel %fp@(16),%d0
59c5c: 222e 0014 movel %fp@(20),%d1
return lseek( fd, offset, whence );
59c60: 2d6e 0018 0014 movel %fp@(24),%fp@(20)
59c66: 2d40 000c movel %d0,%fp@(12)
59c6a: 2d41 0010 movel %d1,%fp@(16)
59c6e: 2d48 0008 movel %a0,%fp@(8)
}
59c72: 4e5e unlk %fp
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
59c74: 4ef9 0005 9b84 jmp 59b84 <lseek>
...
00059c7c <_malloc_r>:
void *_malloc_r(
struct _reent *ignored __attribute__((unused)),
size_t size
)
{
59c7c: 4e56 0000 linkw %fp,#0
return malloc( size );
59c80: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
59c86: 4e5e unlk %fp
void *_malloc_r(
struct _reent *ignored __attribute__((unused)),
size_t size
)
{
return malloc( size );
59c88: 4ef9 0004 2e54 jmp 42e54 <malloc>
...
00059d2c <_read_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
void *buf,
size_t nbytes
)
{
59d2c: 4e56 0000 linkw %fp,#0
59d30: 222e 0010 movel %fp@(16),%d1
59d34: 202e 000c movel %fp@(12),%d0
return read( fd, buf, nbytes );
59d38: 2d6e 0014 0010 movel %fp@(20),%fp@(16)
59d3e: 2d41 000c movel %d1,%fp@(12)
59d42: 2d40 0008 movel %d0,%fp@(8)
}
59d46: 4e5e unlk %fp
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
59d48: 4ef9 0005 9c90 jmp 59c90 <read>
...
00059d50 <_realloc_r>:
void *_realloc_r(
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
59d50: 4e56 0000 linkw %fp,#0
59d54: 202e 000c movel %fp@(12),%d0
return realloc( ptr, size );
59d58: 2d6e 0010 000c movel %fp@(16),%fp@(12)
59d5e: 2d40 0008 movel %d0,%fp@(8)
}
59d62: 4e5e unlk %fp
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
59d64: 4ef9 0005 9d90 jmp 59d90 <realloc>
...
00043514 <_stat_r>:
int _STAT_R_NAME(
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
43514: 4e56 0000 linkw %fp,#0
43518: 202e 000c movel %fp@(12),%d0
return _STAT_NAME( path, buf );
4351c: 2d6e 0010 000c movel %fp@(16),%fp@(12)
43522: 2d40 0008 movel %d0,%fp@(8)
}
43526: 4e5e unlk %fp
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
43528: 4ef9 0004 348c jmp 4348c <stat>
...
000451d4 <_times_r>:
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
451d4: 4e56 0000 linkw %fp,#0
return _times( ptms );
451d8: 2d6e 000c 0008 movel %fp@(12),%fp@(8)
}
451de: 4e5e unlk %fp
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
return _times( ptms );
451e0: 4ef9 0004 5130 jmp 45130 <_times>
...
00059d6c <_write_r>:
struct _reent *ptr __attribute__((unused)),
int fd,
const void *buf,
size_t nbytes
)
{
59d6c: 4e56 0000 linkw %fp,#0
59d70: 222e 0010 movel %fp@(16),%d1
59d74: 202e 000c movel %fp@(12),%d0
return write( fd, buf, nbytes );
59d78: 2d6e 0014 0010 movel %fp@(20),%fp@(16)
59d7e: 2d41 000c movel %d1,%fp@(12)
59d82: 2d40 0008 movel %d0,%fp@(8)
}
59d86: 4e5e unlk %fp
int fd,
const void *buf,
size_t nbytes
)
{
return write( fd, buf, nbytes );
59d88: 4ef9 0005 9e74 jmp 59e74 <write>
...
00044008 <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
44008: 4e56 ffe8 linkw %fp,#-24
4400c: 2f03 movel %d3,%sp@-
4400e: 262e 0008 movel %fp@(8),%d3
44012: 2f02 movel %d2,%sp@-
int status;
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
44014: 240e movel %fp,%d2
44016: 0682 ffff ffec addil #-20,%d2
4401c: 2f03 movel %d3,%sp@-
4401e: 4eb9 0004 f8e4 jsr 4f8e4 <strlen>
44024: 7201 moveq #1,%d1
44026: 2e81 movel %d1,%sp@
44028: 2f02 movel %d2,%sp@-
4402a: 42a7 clrl %sp@-
4402c: 2f00 movel %d0,%sp@-
4402e: 2f03 movel %d3,%sp@-
44030: 4eb9 0004 44c0 jsr 444c0 <rtems_filesystem_evaluate_path>
if ( status != 0 )
44036: 4fef 0014 lea %sp@(20),%sp
4403a: 4a80 tstl %d0
4403c: 6626 bnes 44064 <chmod+0x5c> <== NEVER TAKEN
return -1;
result = (*loc.handlers->fchmod_h)( &loc, mode );
4403e: 2f2e 000c movel %fp@(12),%sp@-
44042: 206e fff4 moveal %fp@(-12),%a0
44046: 2f02 movel %d2,%sp@-
44048: 2068 001c moveal %a0@(28),%a0
4404c: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
4404e: 2f02 movel %d2,%sp@-
44050: 2d40 ffe8 movel %d0,%fp@(-24)
44054: 4eb9 0004 468c jsr 4468c <rtems_filesystem_freenode>
return result;
4405a: 202e ffe8 movel %fp@(-24),%d0
4405e: 4fef 000c lea %sp@(12),%sp
44062: 6002 bras 44066 <chmod+0x5e>
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
if ( status != 0 )
return -1;
44064: 70ff moveq #-1,%d0
result = (*loc.handlers->fchmod_h)( &loc, mode );
rtems_filesystem_freenode( &loc );
return result;
}
44066: 242e ffe0 movel %fp@(-32),%d2
4406a: 262e ffe4 movel %fp@(-28),%d3
4406e: 4e5e unlk %fp
...
00044640 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
44640: 4e56 ffe0 linkw %fp,#-32
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
44644: 203c 0006 0348 movel #394056,%d0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
4464a: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
4464e: b0b9 0005 ed50 cmpl 5ed50 <rtems_current_user_env>,%d0
44654: 6624 bnes 4467a <chroot+0x3a>
rtems_libio_set_private_env(); /* try to set a new private env*/
44656: 4eb9 0004 5c28 jsr 45c28 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
4465c: 41f9 0006 0348 lea 60348 <rtems_global_user_env>,%a0
44662: b1f9 0005 ed50 cmpal 5ed50 <rtems_current_user_env>,%a0
44668: 6610 bnes 4467a <chroot+0x3a>
rtems_set_errno_and_return_minus_one( ENOTSUP );
4466a: 4eb9 0004 e7e8 jsr 4e7e8 <__errno>
44670: 2040 moveal %d0,%a0
44672: 20bc 0000 0086 movel #134,%a0@
44678: 6020 bras 4469a <chroot+0x5a>
}
result = chdir(pathname);
4467a: 2f2e 0008 movel %fp@(8),%sp@-
4467e: 4eb9 0004 458c jsr 4458c <chdir>
if (result) {
44684: 588f addql #4,%sp
44686: 4a80 tstl %d0
44688: 6714 beqs 4469e <chroot+0x5e>
rtems_set_errno_and_return_minus_one( errno );
4468a: 45f9 0004 e7e8 lea 4e7e8 <__errno>,%a2
44690: 4e92 jsr %a2@
44692: 2640 moveal %d0,%a3
44694: 4e92 jsr %a2@
44696: 2040 moveal %d0,%a0
44698: 2690 movel %a0@,%a3@
4469a: 70ff moveq #-1,%d0
4469c: 6056 bras 446f4 <chroot+0xb4>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
4469e: 42a7 clrl %sp@-
446a0: 240e movel %fp,%d2
446a2: 0682 ffff ffec addil #-20,%d2
446a8: 2f02 movel %d2,%sp@-
446aa: 42a7 clrl %sp@-
446ac: 4878 0001 pea 1 <ADD>
446b0: 4879 0005 cd25 pea 5cd25 <_rodata_start+0x1b5>
446b6: 4eb9 0004 49f4 jsr 449f4 <rtems_filesystem_evaluate_path>
446bc: 4fef 0014 lea %sp@(20),%sp
446c0: 4a80 tstl %d0
446c2: 66c6 bnes 4468a <chroot+0x4a> <== NEVER TAKEN
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
}
rtems_filesystem_freenode(&rtems_filesystem_root);
446c4: 2079 0005 ed50 moveal 5ed50 <rtems_current_user_env>,%a0
446ca: 41e8 0018 lea %a0@(24),%a0
446ce: 2f08 movel %a0,%sp@-
446d0: 4eb9 0004 4bc0 jsr 44bc0 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
446d6: 4878 0014 pea 14 <OPER2>
446da: 2079 0005 ed50 moveal 5ed50 <rtems_current_user_env>,%a0
446e0: 41e8 0018 lea %a0@(24),%a0
446e4: 2f02 movel %d2,%sp@-
446e6: 2f08 movel %a0,%sp@-
446e8: 4eb9 0004 f008 jsr 4f008 <memcpy>
return 0;
446ee: 4fef 0010 lea %sp@(16),%sp
446f2: 4280 clrl %d0
}
446f4: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3
446fa: 4e5e unlk %fp
...
00042534 <create_disk>:
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
42534: 4e56 ffe0 linkw %fp,#-32
42538: 48d7 0cfc moveml %d2-%d7/%a2-%a3,%sp@
4253c: 242e 0008 movel %fp@(8),%d2
42540: 262e 000c movel %fp@(12),%d3
42544: 2e2e 0010 movel %fp@(16),%d7
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
42548: 2c02 movel %d2,%d6
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.minor;
4254a: 2a03 movel %d3,%d5
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
4254c: 2479 0006 025e moveal 6025e <disktab_size>,%a2
42552: b5c6 cmpal %d6,%a2
42554: 6252 bhis 425a8 <create_disk+0x74>
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
42556: 280a movel %a2,%d4
42558: d884 addl %d4,%d4
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
4255a: 2039 0006 0262 movel 60262 <disktab>,%d0
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
if (major >= new_size) {
42560: b886 cmpl %d6,%d4
42562: 6204 bhis 42568 <create_disk+0x34> <== NEVER TAKEN
new_size = major + 1;
42564: 2806 movel %d6,%d4
42566: 5284 addql #1,%d4
}
table = realloc(table, new_size * sizeof(*table));
42568: 2204 movel %d4,%d1
4256a: e789 lsll #3,%d1
4256c: 2f01 movel %d1,%sp@-
4256e: 2f00 movel %d0,%sp@-
42570: 4eb9 0004 4308 jsr 44308 <realloc>
if (table == NULL) {
42576: 508f addql #8,%sp
if (major >= new_size) {
new_size = major + 1;
}
table = realloc(table, new_size * sizeof(*table));
42578: 2640 moveal %d0,%a3
if (table == NULL) {
4257a: 4a80 tstl %d0
4257c: 6700 0104 beqw 42682 <create_disk+0x14e>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
42580: 2004 movel %d4,%d0 <== NOT EXECUTED
42582: 908a subl %a2,%d0 <== NOT EXECUTED
42584: 220a movel %a2,%d1 <== NOT EXECUTED
42586: e788 lsll #3,%d0 <== NOT EXECUTED
42588: e789 lsll #3,%d1 <== NOT EXECUTED
4258a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4258c: 42a7 clrl %sp@- <== NOT EXECUTED
4258e: 4873 1800 pea %a3@(00000000,%d1:l) <== NOT EXECUTED
42592: 4eb9 0004 fecc jsr 4fecc <memset> <== NOT EXECUTED
disktab = table;
disktab_size = new_size;
42598: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
if (table == NULL) {
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab = table;
4259c: 23cb 0006 0262 movel %a3,60262 <disktab> <== NOT EXECUTED
disktab_size = new_size;
425a2: 23c4 0006 025e movel %d4,6025e <disktab_size> <== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
425a8: 2479 0006 0262 moveal 60262 <disktab>,%a2
425ae: e78e lsll #3,%d6
425b0: d5c6 addal %d6,%a2
425b2: 2012 movel %a2@,%d0
425b4: 6706 beqs 425bc <create_disk+0x88>
425b6: baaa 0004 cmpl %a2@(4),%d5
425ba: 654c bcss 42608 <create_disk+0xd4> <== ALWAYS TAKEN
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
425bc: 2c2a 0004 movel %a2@(4),%d6
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
425c0: 6706 beqs 425c8 <create_disk+0x94> <== ALWAYS TAKEN
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
425c2: 2806 movel %d6,%d4 <== NOT EXECUTED
425c4: d884 addl %d4,%d4 <== NOT EXECUTED
425c6: 6002 bras 425ca <create_disk+0x96> <== NOT EXECUTED
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
new_size = DISKTAB_INITIAL_SIZE;
425c8: 7808 moveq #8,%d4
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
425ca: b885 cmpl %d5,%d4
425cc: 6204 bhis 425d2 <create_disk+0x9e>
new_size = minor + 1;
425ce: 2805 movel %d5,%d4
425d0: 5284 addql #1,%d4
}
table = realloc(table, new_size * sizeof(*table));
425d2: 2204 movel %d4,%d1
425d4: e589 lsll #2,%d1
425d6: 2f01 movel %d1,%sp@-
425d8: 2f00 movel %d0,%sp@-
425da: 4eb9 0004 4308 jsr 44308 <realloc>
if (table == NULL) {
425e0: 508f addql #8,%sp
}
if (minor >= new_size) {
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
425e2: 2640 moveal %d0,%a3
if (table == NULL) {
425e4: 4a80 tstl %d0
425e6: 6700 009a beqw 42682 <create_disk+0x14e>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
425ea: 2004 movel %d4,%d0
425ec: 9086 subl %d6,%d0
425ee: e588 lsll #2,%d0
425f0: 2f00 movel %d0,%sp@-
425f2: 42a7 clrl %sp@-
425f4: 4873 6c00 pea %a3@(00000000,%d6:l:4)
425f8: 4eb9 0004 fecc jsr 4fecc <memset>
disktab [major].minor = table;
disktab [major].size = new_size;
425fe: 4fef 000c lea %sp@(12),%sp
if (table == NULL) {
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab [major].minor = table;
42602: 248b movel %a3,%a2@
disktab [major].size = new_size;
42604: 2544 0004 movel %d4,%a2@(4)
}
return disktab [major].minor + minor;
42608: 2652 moveal %a2@,%a3
4260a: e58d lsll #2,%d5
4260c: d7c5 addal %d5,%a3
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
4260e: 4a8b tstl %a3
42610: 6770 beqs 42682 <create_disk+0x14e> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
42612: 4a93 tstl %a3@
42614: 6668 bnes 4267e <create_disk+0x14a>
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
42616: 4878 0032 pea 32 <OPER2+0x1e>
4261a: 4eb9 0004 391c jsr 4391c <malloc>
if (dd == NULL) {
42620: 588f addql #4,%sp
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
42622: 2440 moveal %d0,%a2
if (dd == NULL) {
42624: 4a80 tstl %d0
42626: 675a beqs 42682 <create_disk+0x14e> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
42628: 4a87 tstl %d7
4262a: 6730 beqs 4265c <create_disk+0x128>
alloc_name = strdup(name);
4262c: 2f07 movel %d7,%sp@-
4262e: 4eb9 0005 04bc jsr 504bc <strdup>
if (alloc_name == NULL) {
42634: 588f addql #4,%sp
if (dd == NULL) {
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
alloc_name = strdup(name);
42636: 2800 movel %d0,%d4
42638: 2a00 movel %d0,%d5
if (alloc_name == NULL) {
4263a: 6652 bnes 4268e <create_disk+0x15a> <== ALWAYS TAKEN
free(dd);
4263c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4263e: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
42644: 588f addql #4,%sp <== NOT EXECUTED
42646: 603a bras 42682 <create_disk+0x14e> <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
42648: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4264a: 47f9 0004 3630 lea 43630 <free>,%a3 <== NOT EXECUTED
42650: 4e93 jsr %a3@ <== NOT EXECUTED
free(dd);
42652: 2f0a movel %a2,%sp@- <== NOT EXECUTED
42654: 4e93 jsr %a3@ <== NOT EXECUTED
return RTEMS_UNSATISFIED;
42656: 508f addql #8,%sp <== NOT EXECUTED
42658: 700d moveq #13,%d0 <== NOT EXECUTED
4265a: 6028 bras 42684 <create_disk+0x150> <== NOT EXECUTED
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
4265c: 4285 clrl %d5
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
dd->name = alloc_name;
4265e: 2545 0010 movel %d5,%a2@(16)
dd->uses = 0;
dd->deleted = false;
*dd_entry = dd;
*dd_ptr = dd;
42662: 206e 0014 moveal %fp@(20),%a0
}
}
dd->dev = dev;
dd->name = alloc_name;
dd->uses = 0;
42666: 42aa 0014 clrl %a2@(20)
dd->deleted = false;
4266a: 4200 clrb %d0
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
4266c: 2482 movel %d2,%a2@
4266e: 2543 0004 movel %d3,%a2@(4)
dd->name = alloc_name;
dd->uses = 0;
dd->deleted = false;
42672: 1540 0030 moveb %d0,%a2@(48)
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
42676: 4280 clrl %d0
dd->dev = dev;
dd->name = alloc_name;
dd->uses = 0;
dd->deleted = false;
*dd_entry = dd;
42678: 268a movel %a2,%a3@
*dd_ptr = dd;
4267a: 208a movel %a2,%a0@
return RTEMS_SUCCESSFUL;
4267c: 6006 bras 42684 <create_disk+0x150>
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
4267e: 700c moveq #12,%d0
42680: 6002 bras 42684 <create_disk+0x150>
}
dd = malloc(sizeof(*dd));
if (dd == NULL) {
return RTEMS_NO_MEMORY;
42682: 701a moveq #26,%d0
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
}
42684: 4cee 0cfc ffe0 moveml %fp@(-32),%d2-%d7/%a2-%a3
4268a: 4e5e unlk %fp
4268c: 4e75 rts
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
4268e: 2f03 movel %d3,%sp@-
42690: 2f02 movel %d2,%sp@-
42692: 4878 61ff pea 61ff <D_MAX_EXP+0x5a00>
42696: 2f00 movel %d0,%sp@-
42698: 4eb9 0004 39e8 jsr 439e8 <mknod>
4269e: 4fef 0010 lea %sp@(16),%sp
426a2: 4a80 tstl %d0
426a4: 6cb8 bges 4265e <create_disk+0x12a> <== ALWAYS TAKEN
426a6: 60a0 bras 42648 <create_disk+0x114> <== NOT EXECUTED
0004a15c <devFS_evaluate_path>:
{
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
4a15c: 70f8 moveq #-8,%d0
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
4a15e: 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 ) )
4a162: c0ae 0010 andl %fp@(16),%d0
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
4a166: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
4a16a: 282e 0008 movel %fp@(8),%d4
4a16e: 262e 000c movel %fp@(12),%d3
4a172: 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 ) )
4a176: 4a80 tstl %d0
4a178: 670e beqs 4a188 <devFS_evaluate_path+0x2c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
4a17a: 4eb9 0004 bab4 jsr 4bab4 <__errno> <== NOT EXECUTED
4a180: 7401 moveq #1,%d2 <== NOT EXECUTED
4a182: 2040 moveal %d0,%a0 <== NOT EXECUTED
4a184: 2082 movel %d2,%a0@ <== NOT EXECUTED
4a186: 607a bras 4a202 <devFS_evaluate_path+0xa6> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
4a188: 2652 moveal %a2@,%a3
if (!device_name_table)
4a18a: 4a8b tstl %a3
4a18c: 670a beqs 4a198 <devFS_evaluate_path+0x3c>
4a18e: 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)
4a190: 4bf9 0004 d3d4 lea 4d3d4 <strncmp>,%a5
4a196: 6056 bras 4a1ee <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 );
4a198: 4eb9 0004 bab4 jsr 4bab4 <__errno>
4a19e: 720e moveq #14,%d1
4a1a0: 2040 moveal %d0,%a0
4a1a2: 2081 movel %d1,%a0@
4a1a4: 605c bras 4a202 <devFS_evaluate_path+0xa6>
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
4a1a6: 2853 moveal %a3@,%a4
4a1a8: 4a8c tstl %a4
4a1aa: 673c beqs 4a1e8 <devFS_evaluate_path+0x8c>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
4a1ac: 2f03 movel %d3,%sp@-
4a1ae: 2f0c movel %a4,%sp@-
4a1b0: 2f04 movel %d4,%sp@-
4a1b2: 4e95 jsr %a5@
4a1b4: 4fef 000c lea %sp@(12),%sp
4a1b8: 4a80 tstl %d0
4a1ba: 662c bnes 4a1e8 <devFS_evaluate_path+0x8c>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
4a1bc: 4a34 3800 tstb %a4@(00000000,%d3:l)
4a1c0: 6626 bnes 4a1e8 <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;
4a1c2: 41f9 0005 ad80 lea 5ad80 <devFS_ops>,%a0
4a1c8: 2548 000c movel %a0,%a2@(12)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
4a1cc: 2079 0005 aee4 moveal 5aee4 <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;
4a1d2: 203c 0005 ad48 movel #372040,%d0
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
4a1d8: 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;
4a1de: 2540 0008 movel %d0,%a2@(8)
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
4a1e2: 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];
4a1e4: 248b movel %a3,%a2@
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
4a1e6: 601c bras 4a204 <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++) {
4a1e8: 5282 addql #1,%d2
4a1ea: 47eb 0014 lea %a3@(20),%a3
4a1ee: b4b9 0005 ad06 cmpl 5ad06 <rtems_device_table_size>,%d2
4a1f4: 65b0 bcss 4a1a6 <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 );
4a1f6: 4eb9 0004 bab4 jsr 4bab4 <__errno>
4a1fc: 2040 moveal %d0,%a0
4a1fe: 7002 moveq #2,%d0
4a200: 2080 movel %d0,%a0@
4a202: 70ff moveq #-1,%d0
}
4a204: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
4a20a: 4e5e unlk %fp <== NOT EXECUTED
00043944 <devFS_mknod>:
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
43944: 7264 moveq #100,%d1
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
43946: 4e56 ffdc linkw %fp,#-36
4394a: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4394e: 246e 0008 moveal %fp@(8),%a2
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
43952: 1012 moveb %a2@,%d0
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
43954: 282e 000c movel %fp@(12),%d4
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
43958: 49c0 extbl %d0
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
4395a: 2c2e 0010 movel %fp@(16),%d6
4395e: 2a2e 0014 movel %fp@(20),%d5
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
43962: b280 cmpl %d0,%d1
43964: 6624 bnes 4398a <devFS_mknod+0x46>
43966: 123c 0065 moveb #101,%d1
4396a: 102a 0001 moveb %a2@(1),%d0
4396e: 49c0 extbl %d0
43970: b280 cmpl %d0,%d1
43972: 6616 bnes 4398a <devFS_mknod+0x46> <== NEVER TAKEN
43974: 123c 0076 moveb #118,%d1
43978: 102a 0002 moveb %a2@(2),%d0
4397c: 49c0 extbl %d0
4397e: b280 cmpl %d0,%d1
43980: 6608 bnes 4398a <devFS_mknod+0x46> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
43982: 4a2a 0003 tstb %a2@(3)
43986: 6700 00c8 beqw 43a50 <devFS_mknod+0x10c>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
4398a: 2004 movel %d4,%d0
4398c: 0280 0000 f000 andil #61440,%d0
43992: 0c80 0000 6000 cmpil #24576,%d0
43998: 6716 beqs 439b0 <devFS_mknod+0x6c>
4399a: 0c80 0000 2000 cmpil #8192,%d0
439a0: 670e beqs 439b0 <devFS_mknod+0x6c>
rtems_set_errno_and_return_minus_one( EINVAL );
439a2: 4eb9 0004 bab4 jsr 4bab4 <__errno>
439a8: 7616 moveq #22,%d3
439aa: 2040 moveal %d0,%a0
439ac: 2083 movel %d3,%a0@
439ae: 6066 bras 43a16 <devFS_mknod+0xd2>
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
439b0: 206e 0018 moveal %fp@(24),%a0
439b4: 2650 moveal %a0@,%a3
if (!device_name_table)
439b6: 4a8b tstl %a3
439b8: 670e beqs 439c8 <devFS_mknod+0x84>
439ba: 284b moveal %a3,%a4
439bc: 74ff moveq #-1,%d2
439be: 4283 clrl %d3
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
439c0: 4bf9 0004 ce80 lea 4ce80 <strcmp>,%a5
439c6: 6034 bras 439fc <devFS_mknod+0xb8>
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
439c8: 4eb9 0004 bab4 jsr 4bab4 <__errno>
439ce: 740e moveq #14,%d2
439d0: 2240 moveal %d0,%a1
439d2: 2282 movel %d2,%a1@
439d4: 6040 bras 43a16 <devFS_mknod+0xd2>
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
439d6: 2014 movel %a4@,%d0
439d8: 671a beqs 439f4 <devFS_mknod+0xb0>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
439da: 2f00 movel %d0,%sp@-
439dc: 2f0a movel %a2,%sp@-
439de: 4e95 jsr %a5@
439e0: 508f addql #8,%sp
439e2: 4a80 tstl %d0
439e4: 6610 bnes 439f6 <devFS_mknod+0xb2>
rtems_set_errno_and_return_minus_one( EEXIST );
439e6: 4eb9 0004 bab4 jsr 4bab4 <__errno>
439ec: 7211 moveq #17,%d1
439ee: 2040 moveal %d0,%a0
439f0: 2081 movel %d1,%a0@
439f2: 6022 bras 43a16 <devFS_mknod+0xd2>
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
439f4: 2403 movel %d3,%d2
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
439f6: 5283 addql #1,%d3
439f8: 49ec 0014 lea %a4@(20),%a4
439fc: b6b9 0005 ad06 cmpl 5ad06 <rtems_device_table_size>,%d3
43a02: 65d2 bcss 439d6 <devFS_mknod+0x92>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
43a04: 70ff moveq #-1,%d0
43a06: b082 cmpl %d2,%d0
43a08: 6610 bnes 43a1a <devFS_mknod+0xd6>
rtems_set_errno_and_return_minus_one( ENOMEM );
43a0a: 4eb9 0004 bab4 jsr 4bab4 <__errno>
43a10: 2040 moveal %d0,%a0
43a12: 700c moveq #12,%d0
43a14: 2080 movel %d0,%a0@
43a16: 70ff moveq #-1,%d0
43a18: 6038 bras 43a52 <devFS_mknod+0x10e>
_ISR_Disable(level);
43a1a: 203c 0000 0700 movel #1792,%d0
43a20: 40c3 movew %sr,%d3
43a22: 8083 orl %d3,%d0
43a24: 46c0 movew %d0,%sr
device_name_table[slot].device_name = (char *)path;
43a26: 2002 movel %d2,%d0
43a28: e988 lsll #4,%d0
43a2a: 2240 moveal %d0,%a1
43a2c: 41f1 2c00 lea %a1@(00000000,%d2:l:4),%a0
43a30: d7c8 addal %a0,%a3
43a32: 268a movel %a2,%a3@
device_name_table[slot].device_name_length = strlen(path);
43a34: 2f0a movel %a2,%sp@-
43a36: 4eb9 0004 d3b8 jsr 4d3b8 <strlen>
43a3c: 588f addql #4,%sp
43a3e: 2740 0004 movel %d0,%a3@(4)
device_name_table[slot].major = major;
43a42: 2746 0008 movel %d6,%a3@(8)
device_name_table[slot].minor = minor;
43a46: 2745 000c movel %d5,%a3@(12)
device_name_table[slot].mode = mode;
43a4a: 2744 0010 movel %d4,%a3@(16)
_ISR_Enable(level);
43a4e: 46c3 movew %d3,%sr
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
(path[2] == 'v') && (path[3] == '\0'))
return 0;
43a50: 4280 clrl %d0
device_name_table[slot].minor = minor;
device_name_table[slot].mode = mode;
_ISR_Enable(level);
return 0;
}
43a52: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
43a58: 4e5e unlk %fp <== NOT EXECUTED
000424d8 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
424d8: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
424dc: 42a7 clrl %sp@-
424de: 42a7 clrl %sp@-
424e0: 2f39 0006 025a movel 6025a <diskdevs_mutex>,%sp@-
424e6: 4eb9 0004 66c8 jsr 466c8 <rtems_semaphore_obtain>
if (sc == RTEMS_SUCCESSFUL) {
424ec: 4fef 000c lea %sp@(12),%sp
424f0: 4a80 tstl %d0
424f2: 660c bnes 42500 <disk_lock+0x28> <== NEVER TAKEN
diskdevs_protected = true;
424f4: 7001 moveq #1,%d0
424f6: 13c0 0006 0258 moveb %d0,60258 <diskdevs_protected>
return RTEMS_SUCCESSFUL;
424fc: 4280 clrl %d0
424fe: 6002 bras 42502 <disk_lock+0x2a>
} else {
return RTEMS_NOT_CONFIGURED;
42500: 7016 moveq #22,%d0 <== NOT EXECUTED
}
}
42502: 4e5e unlk %fp <== NOT EXECUTED
00042506 <disk_unlock>:
static void
disk_unlock(void)
{
42506: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
4250a: 4200 clrb %d0
sc = rtems_semaphore_release(diskdevs_mutex);
4250c: 2f39 0006 025a movel 6025a <diskdevs_mutex>,%sp@-
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
42512: 13c0 0006 0258 moveb %d0,60258 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
42518: 4eb9 0004 67d4 jsr 467d4 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
4251e: 588f addql #4,%sp
42520: 4a80 tstl %d0
42522: 670c beqs 42530 <disk_unlock+0x2a> <== ALWAYS TAKEN
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
42524: 2f3c dead beef movel #-559038737,%sp@- <== NOT EXECUTED
4252a: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
42530: 4e5e unlk %fp <== NOT EXECUTED
0004393c <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
4393c: 4e56 fff4 linkw %fp,#-12
43940: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
43944: 246e 0008 moveal %fp@(8),%a2
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
43948: 243c 0000 0700 movel #1792,%d2
4394e: 2202 movel %d2,%d1
43950: 40c0 movew %sr,%d0
43952: 8280 orl %d0,%d1
43954: 46c1 movew %d1,%sr
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
43956: 47f9 0004 59e0 lea 459e0 <rtems_semaphore_obtain>,%a3
4395c: 602a bras 43988 <drainOutput.part.0+0x4c>
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
4395e: 7202 moveq #2,%d1
43960: 2541 0094 movel %d1,%a2@(148)
rtems_interrupt_enable (level);
43964: 46c0 movew %d0,%sr
sc = rtems_semaphore_obtain(
43966: 42a7 clrl %sp@-
43968: 42a7 clrl %sp@-
4396a: 2f2a 008c movel %a2@(140),%sp@-
4396e: 4e93 jsr %a3@
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
43970: 4fef 000c lea %sp@(12),%sp
43974: 4a80 tstl %d0
43976: 6708 beqs 43980 <drainOutput.part.0+0x44> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
43978: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4397a: 4eb9 0004 60a0 jsr 460a0 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
43980: 2202 movel %d2,%d1
43982: 40c0 movew %sr,%d0
43984: 8280 orl %d0,%d1
43986: 46c1 movew %d1,%sr
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
43988: 206a 0084 moveal %a2@(132),%a0
4398c: 222a 0080 movel %a2@(128),%d1
43990: b288 cmpl %a0,%d1
43992: 66ca bnes 4395e <drainOutput.part.0+0x22>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
43994: 46c0 movew %d0,%sr
}
}
43996: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
4399c: 4e5e unlk %fp <== NOT EXECUTED
00044460 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
44460: 4e56 fff0 linkw %fp,#-16
44464: 48d7 040c moveml %d2-%d3/%a2,%sp@
44468: 246e 000c moveal %fp@(12),%a2
if ((tty->termios.c_lflag & ECHOCTL) &&
4446c: 202a 003c movel %a2@(60),%d0
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
44470: 242e 0008 movel %fp@(8),%d2
if ((tty->termios.c_lflag & ECHOCTL) &&
44474: 0280 0000 0200 andil #512,%d0
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
4447a: 1202 moveb %d2,%d1
if ((tty->termios.c_lflag & ECHOCTL) &&
4447c: 4a80 tstl %d0
4447e: 674e beqs 444ce <echo+0x6e> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
44480: 4280 clrl %d0
44482: 1002 moveb %d2,%d0
44484: 2079 0005 c1b0 moveal 5c1b0 <__ctype_ptr__>,%a0
4448a: 1630 0801 moveb %a0@(00000001,%d0:l),%d3
4448e: 49c3 extbl %d3
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
44490: 0803 0005 btst #5,%d3
44494: 6738 beqs 444ce <echo+0x6e>
iscntrl(c) && (c != '\t') && (c != '\n')) {
44496: 7609 moveq #9,%d3
44498: b680 cmpl %d0,%d3
4449a: 6732 beqs 444ce <echo+0x6e>
4449c: 163c 000a moveb #10,%d3
444a0: b680 cmpl %d0,%d3
444a2: 672a beqs 444ce <echo+0x6e>
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
444a4: 2f0a movel %a2,%sp@-
444a6: 4878 0002 pea 2 <DOUBLE_FLOAT>
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
444aa: 163c 0040 moveb #64,%d3
rtems_termios_puts (echobuf, 2, tty);
444ae: 486e fffe pea %fp@(-2)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
444b2: 705e moveq #94,%d0
echobuf[1] = c ^ 0x40;
444b4: b782 eorl %d3,%d2
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
444b6: 1d40 fffe moveb %d0,%fp@(-2)
echobuf[1] = c ^ 0x40;
444ba: 1d42 ffff moveb %d2,%fp@(-1)
rtems_termios_puts (echobuf, 2, tty);
444be: 4eb9 0004 4230 jsr 44230 <rtems_termios_puts>
tty->column += 2;
444c4: 4fef 000c lea %sp@(12),%sp
444c8: 54aa 0028 addql #2,%a2@(40)
444cc: 6010 bras 444de <echo+0x7e>
} else {
oproc (c, tty);
444ce: 2f0a movel %a2,%sp@-
444d0: 0281 0000 00ff andil #255,%d1
444d6: 2f01 movel %d1,%sp@-
444d8: 4eba fe44 jsr %pc@(4431e <oproc>)
444dc: 508f addql #8,%sp
}
}
444de: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
444e4: 4e5e unlk %fp <== NOT EXECUTED
000437d2 <endgrent>:
void endgrent(void)
{
437d2: 4e56 0000 linkw %fp,#0
if (group_fp != NULL)
437d6: 2039 0005 e7b4 movel 5e7b4 <group_fp>,%d0
437dc: 670a beqs 437e8 <endgrent+0x16> <== NEVER TAKEN
fclose(group_fp);
437de: 2f00 movel %d0,%sp@-
437e0: 4eb9 0004 cd24 jsr 4cd24 <fclose>
437e6: 588f addql #4,%sp
}
437e8: 4e5e unlk %fp <== NOT EXECUTED
0004368c <endpwent>:
void endpwent(void)
{
4368c: 4e56 0000 linkw %fp,#0
if (passwd_fp != NULL)
43690: 2039 0005 e6da movel 5e6da <passwd_fp>,%d0
43696: 670a beqs 436a2 <endpwent+0x16> <== NEVER TAKEN
fclose(passwd_fp);
43698: 2f00 movel %d0,%sp@-
4369a: 4eb9 0004 cd24 jsr 4cd24 <fclose>
436a0: 588f addql #4,%sp
}
436a2: 4e5e unlk %fp <== NOT EXECUTED
000444e8 <erase>:
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
444e8: 4e56 ffe4 linkw %fp,#-28
444ec: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@
444f0: 246e 0008 moveal %fp@(8),%a2
444f4: 262e 000c movel %fp@(12),%d3
if (tty->ccount == 0)
444f8: 4aaa 0020 tstl %a2@(32)
444fc: 6700 0172 beqw 44670 <erase+0x188>
return;
if (lineFlag) {
44500: 4a83 tstl %d3
44502: 6700 015c beqw 44660 <erase+0x178>
if (!(tty->termios.c_lflag & ECHO)) {
44506: 202a 003c movel %a2@(60),%d0
4450a: 44c0 movew %d0,%ccr
4450c: 6b08 bmis 44516 <erase+0x2e> <== ALWAYS TAKEN
tty->ccount = 0;
4450e: 42aa 0020 clrl %a2@(32) <== NOT EXECUTED
return;
44512: 6000 015c braw 44670 <erase+0x188> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
44516: 0800 0004 btst #4,%d0
4451a: 6600 0144 bnew 44660 <erase+0x178>
tty->ccount = 0;
4451e: 42aa 0020 clrl %a2@(32) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
44522: 4280 clrl %d0 <== NOT EXECUTED
44524: 2f0a movel %a2,%sp@- <== NOT EXECUTED
44526: 102a 0044 moveb %a2@(68),%d0 <== NOT EXECUTED
4452a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4452c: 4eba ff32 jsr %pc@(44460 <echo>) <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
44530: 508f addql #8,%sp <== NOT EXECUTED
44532: 7020 moveq #32,%d0 <== NOT EXECUTED
44534: c0aa 003c andl %a2@(60),%d0 <== NOT EXECUTED
44538: 6700 0136 beqw 44670 <erase+0x188> <== NOT EXECUTED
echo ('\n', tty);
4453c: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED
44540: 700a moveq #10,%d0 <== NOT EXECUTED
44542: 602c bras 44570 <erase+0x88> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
44544: 5388 subql #1,%a0
44546: 286a 001c moveal %a2@(28),%a4
if (tty->termios.c_lflag & ECHO) {
4454a: 202a 003c movel %a2@(60),%d0
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4454e: 2548 0020 movel %a0,%a2@(32)
44552: 1434 8800 moveb %a4@(00000000,%a0:l),%d2
if (tty->termios.c_lflag & ECHO) {
44556: 44c0 movew %d0,%ccr
44558: 6a00 0100 bplw 4465a <erase+0x172>
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
4455c: 4a83 tstl %d3
4455e: 6620 bnes 44580 <erase+0x98>
44560: 0800 0004 btst #4,%d0
44564: 661a bnes 44580 <erase+0x98> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
44566: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED
4456a: 4280 clrl %d0 <== NOT EXECUTED
4456c: 102a 0043 moveb %a2@(67),%d0 <== NOT EXECUTED
44570: 2d40 0008 movel %d0,%fp@(8) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
44574: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4 <== NOT EXECUTED
4457a: 4e5e unlk %fp <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
4457c: 6000 fee2 braw 44460 <echo> <== NOT EXECUTED
44580: 2279 0005 c1b0 moveal 5c1b0 <__ctype_ptr__>,%a1
} else if (c == '\t') {
44586: 7209 moveq #9,%d1
44588: 0282 0000 00ff andil #255,%d2
4458e: b282 cmpl %d2,%d1
44590: 665a bnes 445ec <erase+0x104>
int col = tty->read_start_column;
44592: 242a 002c movel %a2@(44),%d2
int i = 0;
44596: 4201 clrb %d1
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
44598: 0280 0000 0200 andil #512,%d0
4459e: 6028 bras 445c8 <erase+0xe0>
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
445a0: 4284 clrl %d4
445a2: 181c moveb %a4@+,%d4
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
445a4: 5281 addql #1,%d1
if (c == '\t') {
445a6: 7a09 moveq #9,%d5
445a8: ba84 cmpl %d4,%d5
445aa: 6606 bnes 445b2 <erase+0xca>
col = (col | 7) + 1;
445ac: 7807 moveq #7,%d4
445ae: 8484 orl %d4,%d2
445b0: 6014 bras 445c6 <erase+0xde>
} else if (iscntrl (c)) {
445b2: 1831 4801 moveb %a1@(00000001,%d4:l),%d4
445b6: 49c4 extbl %d4
445b8: 0804 0005 btst #5,%d4
445bc: 6708 beqs 445c6 <erase+0xde> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
445be: 4a80 tstl %d0 <== NOT EXECUTED
445c0: 6706 beqs 445c8 <erase+0xe0> <== NOT EXECUTED
col += 2;
445c2: 5482 addql #2,%d2 <== NOT EXECUTED
445c4: 6002 bras 445c8 <erase+0xe0> <== NOT EXECUTED
} else {
col++;
445c6: 5282 addql #1,%d2
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
445c8: b1c1 cmpal %d1,%a0
445ca: 66d4 bnes 445a0 <erase+0xb8>
445cc: 6016 bras 445e4 <erase+0xfc>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
445ce: 2f0a movel %a2,%sp@-
445d0: 4878 0001 pea 1 <ADD>
445d4: 4879 0005 b1ff pea 5b1ff <rtems_filesystem_default_pathconf+0xb3>
445da: 4e93 jsr %a3@
tty->column--;
445dc: 4fef 000c lea %sp@(12),%sp
445e0: 53aa 0028 subql #1,%a2@(40)
}
/*
* Back up over the tab
*/
while (tty->column > col) {
445e4: b4aa 0028 cmpl %a2@(40),%d2
445e8: 6de4 blts 445ce <erase+0xe6>
445ea: 606e bras 4465a <erase+0x172>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
445ec: 5282 addql #1,%d2
445ee: 1231 2800 moveb %a1@(00000000,%d2:l),%d1
445f2: 49c1 extbl %d1
445f4: 0801 0005 btst #5,%d1
445f8: 6724 beqs 4461e <erase+0x136> <== ALWAYS TAKEN
445fa: 0800 0009 btst #9,%d0 <== NOT EXECUTED
445fe: 671e beqs 4461e <erase+0x136> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
44600: 2f0a movel %a2,%sp@- <== NOT EXECUTED
44602: 4878 0003 pea 3 <DIVIDE> <== NOT EXECUTED
44606: 4879 0005 b1fd pea 5b1fd <rtems_filesystem_default_pathconf+0xb1><== NOT EXECUTED
4460c: 4e93 jsr %a3@ <== NOT EXECUTED
if (tty->column)
4460e: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED
44612: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44616: 6706 beqs 4461e <erase+0x136> <== NOT EXECUTED
tty->column--;
44618: 5380 subql #1,%d0 <== NOT EXECUTED
4461a: 2540 0028 movel %d0,%a2@(40) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
4461e: 2079 0005 c1b0 moveal 5c1b0 <__ctype_ptr__>,%a0
44624: 1030 2800 moveb %a0@(00000000,%d2:l),%d0
44628: 49c0 extbl %d0
4462a: 0800 0005 btst #5,%d0
4462e: 670c beqs 4463c <erase+0x154> <== ALWAYS TAKEN
44630: 202a 003c movel %a2@(60),%d0 <== NOT EXECUTED
44634: 0280 0000 0200 andil #512,%d0 <== NOT EXECUTED
4463a: 671e beqs 4465a <erase+0x172> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
4463c: 2f0a movel %a2,%sp@-
4463e: 4878 0003 pea 3 <DIVIDE>
44642: 4879 0005 b1fd pea 5b1fd <rtems_filesystem_default_pathconf+0xb1>
44648: 4e93 jsr %a3@
if (tty->column)
4464a: 202a 0028 movel %a2@(40),%d0
4464e: 4fef 000c lea %sp@(12),%sp
44652: 6706 beqs 4465a <erase+0x172> <== NEVER TAKEN
tty->column--;
44654: 5380 subql #1,%d0
44656: 2540 0028 movel %d0,%a2@(40)
}
}
}
if (!lineFlag)
4465a: 4a83 tstl %d3
4465c: 6608 bnes 44666 <erase+0x17e>
4465e: 6010 bras 44670 <erase+0x188>
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
44660: 47f9 0004 4230 lea 44230 <rtems_termios_puts>,%a3
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
44666: 206a 0020 moveal %a2@(32),%a0
4466a: 4a88 tstl %a0
4466c: 6600 fed6 bnew 44544 <erase+0x5c>
}
}
if (!lineFlag)
break;
}
}
44670: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
44676: 4e5e unlk %fp <== NOT EXECUTED
000504b0 <fat_buf_access>:
#include "fat_fat_operations.h"
int
fat_buf_access(fat_fs_info_t *fs_info, uint32_t blk, int op_type,
rtems_bdbuf_buffer **buf)
{
504b0: 4e56 ffdc linkw %fp,#-36
504b4: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
504b8: 246e 0008 moveal %fp@(8),%a2
504bc: 242e 000c movel %fp@(12),%d2
504c0: 282e 0010 movel %fp@(16),%d4
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
504c4: 4a2a 0077 tstb %a2@(119)
504c8: 664e bnes 50518 <fat_buf_access+0x68>
504ca: 200a movel %a2,%d0
504cc: 0680 0000 0078 addil #120,%d0
{
if (op_type == FAT_OP_TYPE_READ)
504d2: 7201 moveq #1,%d1
504d4: b284 cmpl %d4,%d1
504d6: 6614 bnes 504ec <fat_buf_access+0x3c>
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
504d8: 2f00 movel %d0,%sp@-
504da: 2f02 movel %d2,%sp@-
504dc: 2f2a 004e movel %a2@(78),%sp@-
504e0: 2f2a 004a movel %a2@(74),%sp@-
504e4: 4eb9 0004 eefc jsr 4eefc <rtems_bdbuf_read>
504ea: 6012 bras 504fe <fat_buf_access+0x4e>
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
504ec: 2f00 movel %d0,%sp@-
504ee: 2f02 movel %d2,%sp@-
504f0: 2f2a 004e movel %a2@(78),%sp@-
504f4: 2f2a 004a movel %a2@(74),%sp@-
504f8: 4eb9 0004 ee38 jsr 4ee38 <rtems_bdbuf_get>
504fe: 4fef 0010 lea %sp@(16),%sp
if (sc != RTEMS_SUCCESSFUL)
50502: 4a80 tstl %d0
50504: 6600 015c bnew 50662 <fat_buf_access+0x1b2>
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
50508: 2542 0072 movel %d2,%a2@(114)
fs_info->c.modified = 0;
5050c: 4200 clrb %d0
fs_info->c.state = FAT_CACHE_ACTUAL;
5050e: 7201 moveq #1,%d1
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
50510: 1540 0076 moveb %d0,%a2@(118)
fs_info->c.state = FAT_CACHE_ACTUAL;
50514: 1541 0077 moveb %d1,%a2@(119)
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
50518: 4281 clrl %d1
5051a: 322a 0014 movew %a2@(20),%d1
5051e: 202a 0072 movel %a2@(114),%d0
50522: b280 cmpl %d0,%d1
50524: 620c bhis 50532 <fat_buf_access+0x82> <== NEVER TAKEN
50526: b0aa 001a cmpl %a2@(26),%d0
5052a: 55c3 scs %d3
5052c: 49c3 extbl %d3
5052e: 4483 negl %d3
50530: 6002 bras 50534 <fat_buf_access+0x84>
50532: 4283 clrl %d3 <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.blk_num != blk)
50534: b480 cmpl %d0,%d2
50536: 6700 0144 beqw 5067c <fat_buf_access+0x1cc>
{
if (fs_info->c.modified)
5053a: 4a2a 0076 tstb %a2@(118)
5053e: 6700 00d0 beqw 50610 <fat_buf_access+0x160>
{
if (sec_of_fat && !fs_info->vol.mirror)
50542: 4a03 tstb %d3
50544: 6722 beqs 50568 <fat_buf_access+0xb8> <== ALWAYS TAKEN
50546: 4a2a 0042 tstb %a2@(66) <== NOT EXECUTED
5054a: 661c bnes 50568 <fat_buf_access+0xb8> <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
5054c: 4280 clrl %d0 <== NOT EXECUTED
5054e: 206a 0078 moveal %a2@(120),%a0 <== NOT EXECUTED
50552: 3012 movew %a2@,%d0 <== NOT EXECUTED
50554: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50556: 2f28 001e movel %a0@(30),%sp@- <== NOT EXECUTED
5055a: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
5055e: 4eb9 0005 87d8 jsr 587d8 <memcpy> <== NOT EXECUTED
50564: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
50568: 2f2a 0078 movel %a2@(120),%sp@-
5056c: 47f9 0004 f1c0 lea 4f1c0 <rtems_bdbuf_release_modified>,%a3
50572: 4e93 jsr %a3@
fs_info->c.state = FAT_CACHE_EMPTY;
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
50574: 588f addql #4,%sp
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
50576: 4201 clrb %d1
50578: 1541 0077 moveb %d1,%a2@(119)
fs_info->c.modified = 0;
5057c: 1541 0076 moveb %d1,%a2@(118)
if (sc != RTEMS_SUCCESSFUL)
50580: 4a80 tstl %d0
50582: 6600 00de bnew 50662 <fat_buf_access+0x1b2>
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
50586: 4a03 tstb %d3
50588: 6700 009c beqw 50626 <fat_buf_access+0x176>
5058c: 4a2a 0042 tstb %a2@(66) <== NOT EXECUTED
50590: 675c beqs 505ee <fat_buf_access+0x13e> <== NOT EXECUTED
50592: 6000 0092 braw 50626 <fat_buf_access+0x176> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
50596: 2f05 movel %d5,%sp@- <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
50598: 41ea 0016 lea %a2@(22),%a0 <== NOT EXECUTED
5059c: 4c10 0800 mulsl %a0@,%d0 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
505a0: d0aa 0072 addl %a2@(114),%d0 <== NOT EXECUTED
505a4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
505a6: 2f2a 004e movel %a2@(78),%sp@- <== NOT EXECUTED
505aa: 2f2a 004a movel %a2@(74),%sp@- <== NOT EXECUTED
505ae: 4e95 jsr %a5@ <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
505b0: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
505b4: 4a80 tstl %d0 <== NOT EXECUTED
505b6: 6622 bnes 505da <fat_buf_access+0x12a> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
505b8: 4280 clrl %d0 <== NOT EXECUTED
505ba: 3012 movew %a2@,%d0 <== NOT EXECUTED
505bc: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
505c0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
505c2: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
505c6: 2f28 001e movel %a0@(30),%sp@- <== NOT EXECUTED
505ca: 4e94 jsr %a4@ <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
505cc: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
505d0: 4e93 jsr %a3@ <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
505d2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
505d6: 4a80 tstl %d0 <== NOT EXECUTED
505d8: 6710 beqs 505ea <fat_buf_access+0x13a> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
505da: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
505e0: 720c moveq #12,%d1 <== NOT EXECUTED
505e2: 2040 moveal %d0,%a0 <== NOT EXECUTED
505e4: 2081 movel %d1,%a0@ <== NOT EXECUTED
505e6: 6000 0086 braw 5066e <fat_buf_access+0x1be> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
505ea: 5283 addql #1,%d3 <== NOT EXECUTED
505ec: 6012 bras 50600 <fat_buf_access+0x150> <== NOT EXECUTED
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
505ee: 2a0e movel %fp,%d5 <== NOT EXECUTED
505f0: 5985 subql #4,%d5 <== NOT EXECUTED
505f2: 4bf9 0004 ee38 lea 4ee38 <rtems_bdbuf_get>,%a5 <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
505f8: 49f9 0005 87d8 lea 587d8 <memcpy>,%a4 <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
505fe: 7601 moveq #1,%d3 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
50600: 4281 clrl %d1 <== NOT EXECUTED
50602: 122a 0009 moveb %a2@(9),%d1 <== NOT EXECUTED
50606: 4280 clrl %d0 <== NOT EXECUTED
50608: 1003 moveb %d3,%d0 <== NOT EXECUTED
5060a: b280 cmpl %d0,%d1 <== NOT EXECUTED
5060c: 6288 bhis 50596 <fat_buf_access+0xe6> <== NOT EXECUTED
5060e: 6016 bras 50626 <fat_buf_access+0x176> <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
50610: 2f2a 0078 movel %a2@(120),%sp@-
50614: 4eb9 0004 f116 jsr 4f116 <rtems_bdbuf_release>
fs_info->c.state = FAT_CACHE_EMPTY;
if (sc != RTEMS_SUCCESSFUL)
5061a: 588f addql #4,%sp
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
5061c: 4201 clrb %d1
5061e: 1541 0077 moveb %d1,%a2@(119)
if (sc != RTEMS_SUCCESSFUL)
50622: 4a80 tstl %d0
50624: 663c bnes 50662 <fat_buf_access+0x1b2> <== NEVER TAKEN
50626: 200a movel %a2,%d0
50628: 0680 0000 0078 addil #120,%d0
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
5062e: 7201 moveq #1,%d1
50630: b284 cmpl %d4,%d1
50632: 6614 bnes 50648 <fat_buf_access+0x198>
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
50634: 2f00 movel %d0,%sp@-
50636: 2f02 movel %d2,%sp@-
50638: 2f2a 004e movel %a2@(78),%sp@-
5063c: 2f2a 004a movel %a2@(74),%sp@-
50640: 4eb9 0004 eefc jsr 4eefc <rtems_bdbuf_read>
50646: 6012 bras 5065a <fat_buf_access+0x1aa>
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
50648: 2f00 movel %d0,%sp@-
5064a: 2f02 movel %d2,%sp@-
5064c: 2f2a 004e movel %a2@(78),%sp@-
50650: 2f2a 004a movel %a2@(74),%sp@-
50654: 4eb9 0004 ee38 jsr 4ee38 <rtems_bdbuf_get>
5065a: 4fef 0010 lea %sp@(16),%sp
if (sc != RTEMS_SUCCESSFUL)
5065e: 4a80 tstl %d0
50660: 6710 beqs 50672 <fat_buf_access+0x1c2> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
50662: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
50668: 2040 moveal %d0,%a0 <== NOT EXECUTED
5066a: 7005 moveq #5,%d0 <== NOT EXECUTED
5066c: 2080 movel %d0,%a0@ <== NOT EXECUTED
5066e: 70ff moveq #-1,%d0 <== NOT EXECUTED
50670: 6014 bras 50686 <fat_buf_access+0x1d6> <== NOT EXECUTED
fs_info->c.blk_num = blk;
50672: 2542 0072 movel %d2,%a2@(114)
fs_info->c.state = FAT_CACHE_ACTUAL;
50676: 7001 moveq #1,%d0
50678: 1540 0077 moveb %d0,%a2@(119)
}
*buf = fs_info->c.buf;
5067c: 206e 0014 moveal %fp@(20),%a0
return RC_OK;
50680: 4280 clrl %d0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
*buf = fs_info->c.buf;
50682: 20aa 0078 movel %a2@(120),%a0@
return RC_OK;
}
50686: 4cee 3c3c ffdc moveml %fp@(-36),%d2-%d5/%a2-%a5
5068c: 4e5e unlk %fp <== NOT EXECUTED
00050690 <fat_buf_release>:
int
fat_buf_release(fat_fs_info_t *fs_info)
{
50690: 4e56 ffe4 linkw %fp,#-28
50694: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
50698: 246e 0008 moveal %fp@(8),%a2
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
5069c: 4a2a 0077 tstb %a2@(119)
506a0: 6700 0114 beqw 507b6 <fat_buf_release+0x126>
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
506a4: 4281 clrl %d1
506a6: 322a 0014 movew %a2@(20),%d1
506aa: 202a 0072 movel %a2@(114),%d0
506ae: b280 cmpl %d0,%d1
506b0: 620c bhis 506be <fat_buf_release+0x2e> <== NEVER TAKEN
*buf = fs_info->c.buf;
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
506b2: b0aa 001a cmpl %a2@(26),%d0
506b6: 55c2 scs %d2
506b8: 49c2 extbl %d2
506ba: 4482 negl %d2
506bc: 6002 bras 506c0 <fat_buf_release+0x30>
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
506be: 4282 clrl %d2 <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
506c0: 4a2a 0076 tstb %a2@(118)
506c4: 6700 00ca beqw 50790 <fat_buf_release+0x100>
{
if (sec_of_fat && !fs_info->vol.mirror)
506c8: 4a02 tstb %d2
506ca: 6722 beqs 506ee <fat_buf_release+0x5e>
506cc: 4a2a 0042 tstb %a2@(66)
506d0: 661c bnes 506ee <fat_buf_release+0x5e> <== NEVER TAKEN
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
506d2: 4280 clrl %d0
506d4: 206a 0078 moveal %a2@(120),%a0
506d8: 3012 movew %a2@,%d0
506da: 2f00 movel %d0,%sp@-
506dc: 2f28 001e movel %a0@(30),%sp@-
506e0: 2f2a 007c movel %a2@(124),%sp@-
506e4: 4eb9 0005 87d8 jsr 587d8 <memcpy>
506ea: 4fef 000c lea %sp@(12),%sp
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
506ee: 2f2a 0078 movel %a2@(120),%sp@-
506f2: 47f9 0004 f1c0 lea 4f1c0 <rtems_bdbuf_release_modified>,%a3
506f8: 4e93 jsr %a3@
if (sc != RTEMS_SUCCESSFUL)
506fa: 588f addql #4,%sp
506fc: 4a80 tstl %d0
506fe: 6600 00a0 bnew 507a0 <fat_buf_release+0x110>
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
50702: 4200 clrb %d0
50704: 1540 0076 moveb %d0,%a2@(118)
if (sec_of_fat && !fs_info->vol.mirror)
50708: 4a02 tstb %d2
5070a: 6700 00a4 beqw 507b0 <fat_buf_release+0x120>
5070e: 4a2a 0042 tstb %a2@(66)
50712: 675a beqs 5076e <fat_buf_release+0xde> <== ALWAYS TAKEN
50714: 6000 009a braw 507b0 <fat_buf_release+0x120> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
50718: 2f03 movel %d3,%sp@-
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
5071a: 41ea 0016 lea %a2@(22),%a0
5071e: 4c10 0800 mulsl %a0@,%d0
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
50722: d0aa 0072 addl %a2@(114),%d0
50726: 2f00 movel %d0,%sp@-
50728: 2f2a 004e movel %a2@(78),%sp@-
5072c: 2f2a 004a movel %a2@(74),%sp@-
50730: 4e95 jsr %a5@
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
50732: 4fef 0010 lea %sp@(16),%sp
50736: 4a80 tstl %d0
50738: 6622 bnes 5075c <fat_buf_release+0xcc> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
5073a: 4280 clrl %d0
5073c: 3012 movew %a2@,%d0
5073e: 206e fffc moveal %fp@(-4),%a0
50742: 2f00 movel %d0,%sp@-
50744: 2f2a 007c movel %a2@(124),%sp@-
50748: 2f28 001e movel %a0@(30),%sp@-
5074c: 4e94 jsr %a4@
sc = rtems_bdbuf_release_modified(b);
5074e: 2f2e fffc movel %fp@(-4),%sp@-
50752: 4e93 jsr %a3@
if ( sc != RTEMS_SUCCESSFUL)
50754: 4fef 0010 lea %sp@(16),%sp
50758: 4a80 tstl %d0
5075a: 670e beqs 5076a <fat_buf_release+0xda> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
5075c: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
50762: 760c moveq #12,%d3 <== NOT EXECUTED
50764: 2040 moveal %d0,%a0 <== NOT EXECUTED
50766: 2083 movel %d3,%a0@ <== NOT EXECUTED
50768: 6042 bras 507ac <fat_buf_release+0x11c> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
5076a: 5282 addql #1,%d2
5076c: 6012 bras 50780 <fat_buf_release+0xf0>
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
5076e: 260e movel %fp,%d3
50770: 5983 subql #4,%d3
50772: 4bf9 0004 ee38 lea 4ee38 <rtems_bdbuf_get>,%a5
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
50778: 49f9 0005 87d8 lea 587d8 <memcpy>,%a4
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
5077e: 7401 moveq #1,%d2
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
50780: 4281 clrl %d1
50782: 122a 0009 moveb %a2@(9),%d1
50786: 4280 clrl %d0
50788: 1002 moveb %d2,%d0
5078a: b280 cmpl %d0,%d1
5078c: 628a bhis 50718 <fat_buf_release+0x88>
5078e: 6020 bras 507b0 <fat_buf_release+0x120>
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
50790: 2f2a 0078 movel %a2@(120),%sp@-
50794: 4eb9 0004 f116 jsr 4f116 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
5079a: 588f addql #4,%sp
5079c: 4a80 tstl %d0
5079e: 6710 beqs 507b0 <fat_buf_release+0x120> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
507a0: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
507a6: 7405 moveq #5,%d2 <== NOT EXECUTED
507a8: 2040 moveal %d0,%a0 <== NOT EXECUTED
507aa: 2082 movel %d2,%a0@ <== NOT EXECUTED
507ac: 70ff moveq #-1,%d0 <== NOT EXECUTED
507ae: 6008 bras 507b8 <fat_buf_release+0x128> <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
507b0: 4200 clrb %d0
507b2: 1540 0077 moveb %d0,%a2@(119)
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
return RC_OK;
507b6: 4280 clrl %d0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
return RC_OK;
}
507b8: 4cee 3c0c ffe4 moveml %fp@(-28),%d2-%d3/%a2-%a5
507be: 4e5e unlk %fp <== NOT EXECUTED
0004f93c <fat_cluster_num_to_sector_num.isra.0>:
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
}
static inline uint32_t
fat_cluster_num_to_sector_num(
4f93c: 4e56 0000 linkw %fp,#0
4f940: 206e 0008 moveal %fp@(8),%a0
4f944: 202e 000c movel %fp@(12),%d0
4f948: 2f02 movel %d2,%sp@-
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4f94a: 4a80 tstl %d0
4f94c: 6612 bnes 4f960 <fat_cluster_num_to_sector_num.isra.0+0x24>
4f94e: 4281 clrl %d1
4f950: 1228 000a moveb %a0@(10),%d1
4f954: 7403 moveq #3,%d2
4f956: c282 andl %d2,%d1
4f958: 6706 beqs 4f960 <fat_cluster_num_to_sector_num.isra.0+0x24><== NEVER TAKEN
return fs_info->vol.rdir_loc;
4f95a: 2028 001a movel %a0@(26),%d0
4f95e: 600e bras 4f96e <fat_cluster_num_to_sector_num.isra.0+0x32>
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4f960: 4281 clrl %d1
4f962: 1228 0005 moveb %a0@(5),%d1
4f966: 5580 subql #2,%d0
4f968: e3a8 lsll %d1,%d0
4f96a: d0a8 002c addl %a0@(44),%d0
fs_info->vol.data_fsec);
}
4f96e: 241f movel %sp@+,%d2
4f970: 4e5e unlk %fp <== NOT EXECUTED
000508fc <fat_cluster_read>:
fat_cluster_read(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
508fc: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
50900: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
50904: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
50908: 4282 clrl %d2 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
5090a: 246b 0034 moveal %a3@(52),%a2 <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
5090e: 2f2e 000c movel %fp@(12),%sp@- <== NOT EXECUTED
50912: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50914: 4eba fb62 jsr %pc@(50478 <fat_cluster_num_to_sector_num.isra.0>)<== NOT EXECUTED
return _fat_block_read(mt_entry, fsec, 0,
50918: 588f addql #4,%sp <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
5091a: 4281 clrl %d1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
5091c: 2eae 0010 movel %fp@(16),%sp@ <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
50920: 122a 0004 moveb %a2@(4),%d1 <== NOT EXECUTED
50924: 142a 0002 moveb %a2@(2),%d2 <== NOT EXECUTED
50928: e5a9 lsll %d2,%d1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
5092a: 2f01 movel %d1,%sp@- <== NOT EXECUTED
5092c: 42a7 clrl %sp@- <== NOT EXECUTED
5092e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50930: 2f0b movel %a3,%sp@- <== NOT EXECUTED
50932: 4eb9 0005 07c2 jsr 507c2 <_fat_block_read> <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
50938: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
5093e: 4e5e unlk %fp <== NOT EXECUTED
00050b26 <fat_fat32_update_fsinfo_sector>:
fat_fat32_update_fsinfo_sector(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t free_count,
uint32_t next_free
)
{
50b26: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED
50b2a: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED
50b2e: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
50b32: 47fa f90c lea %pc@(50440 <m68k_swap_u32>),%a3 <== NOT EXECUTED
uint32_t free_count,
uint32_t next_free
)
{
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
50b36: 286a 0034 moveal %a2@(52),%a4 <== NOT EXECUTED
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
50b3a: 2f2e 000c movel %fp@(12),%sp@- <== NOT EXECUTED
50b3e: 4e93 jsr %a3@ <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
50b40: 2eae 0010 movel %fp@(16),%sp@ <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
50b44: 2d40 fff8 movel %d0,%fp@(-8) <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
50b48: 4e93 jsr %a3@ <== NOT EXECUTED
50b4a: 588f addql #4,%sp <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
50b4c: 47f9 0005 084a lea 5084a <_fat_block_write>,%a3 <== NOT EXECUTED
50b52: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
50b56: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
50b5a: 4878 01e8 pea 1e8 <DBL_MANT_DIG+0x1b3> <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
50b5e: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
50b62: 4280 clrl %d0 <== NOT EXECUTED
50b64: 302c 0038 movew %a4@(56),%d0 <== NOT EXECUTED
50b68: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50b6a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50b6c: 4e93 jsr %a3@ <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
50b6e: 486e fffc pea %fp@(-4) <== NOT EXECUTED
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
ret1 = _fat_block_write(mt_entry,
50b72: 2400 movel %d0,%d2 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
50b74: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
50b78: 4280 clrl %d0 <== NOT EXECUTED
50b7a: 4878 01ec pea 1ec <DBL_MANT_DIG+0x1b7> <== NOT EXECUTED
50b7e: 302c 0038 movew %a4@(56),%d0 <== NOT EXECUTED
50b82: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50b84: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50b86: 4e93 jsr %a3@ <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,
4,
(char *)(&le_next_free));
if ( (ret1 < 0) || (ret2 < 0) )
50b88: 4fef 0028 lea %sp@(40),%sp <== NOT EXECUTED
50b8c: 4a82 tstl %d2 <== NOT EXECUTED
50b8e: 6d08 blts 50b98 <fat_fat32_update_fsinfo_sector+0x72><== NOT EXECUTED
return -1;
50b90: 4a80 tstl %d0 <== NOT EXECUTED
50b92: 5dc0 slt %d0 <== NOT EXECUTED
50b94: 49c0 extbl %d0 <== NOT EXECUTED
50b96: 6002 bras 50b9a <fat_fat32_update_fsinfo_sector+0x74><== NOT EXECUTED
50b98: 70ff moveq #-1,%d0 <== NOT EXECUTED
return RC_OK;
}
50b9a: 4cee 1c04 ffe8 moveml %fp@(-24),%d2/%a2-%a4 <== NOT EXECUTED
50ba0: 4e5e unlk %fp <== NOT EXECUTED
0004fdc6 <fat_file_close>:
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
4fdc6: 7201 moveq #1,%d1
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
4fdc8: 4e56 fff4 linkw %fp,#-12
4fdcc: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4fdd0: 266e 0008 moveal %fp@(8),%a3
4fdd4: 246e 000c moveal %fp@(12),%a2
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fdd8: 242b 0034 movel %a3@(52),%d2
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
4fddc: 202a 0008 movel %a2@(8),%d0
4fde0: b280 cmpl %d0,%d1
4fde2: 640c bccs 4fdf0 <fat_file_close+0x2a>
{
fat_fd->links_num--;
4fde4: 5380 subql #1,%d0
4fde6: 2540 0008 movel %d0,%a2@(8)
return rc;
4fdea: 4280 clrl %d0
4fdec: 6000 0094 braw 4fe82 <fat_file_close+0xbc>
}
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
4fdf0: 4280 clrl %d0
4fdf2: 102a 0030 moveb %a2@(48),%d0
4fdf6: 0800 0000 btst #0,%d0
4fdfa: 674a beqs 4fe46 <fat_file_close+0x80> <== ALWAYS TAKEN
{
rc = fat_file_truncate(mt_entry, fat_fd, 0);
4fdfc: 42a7 clrl %sp@- <== NOT EXECUTED
4fdfe: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4fe00: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fe02: 4eb9 0004 fcdc jsr 4fcdc <fat_file_truncate> <== NOT EXECUTED
if ( rc != RC_OK )
4fe08: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4fe0c: 4a80 tstl %d0 <== NOT EXECUTED
4fe0e: 6672 bnes 4fe82 <fat_file_close+0xbc> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4fe10: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4fe12: 4eb9 0004 99e4 jsr 499e4 <_Chain_Extract> <== NOT EXECUTED
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )
4fe18: 2f2a 000c movel %a2@(12),%sp@- <== NOT EXECUTED
4fe1c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fe1e: 4eb9 0005 0b0a jsr 50b0a <fat_ino_is_unique> <== NOT EXECUTED
4fe24: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4fe28: 4a00 tstb %d0 <== NOT EXECUTED
4fe2a: 670e beqs 4fe3a <fat_file_close+0x74> <== NOT EXECUTED
fat_free_unique_ino(mt_entry, fat_fd->ino);
4fe2c: 2f2a 000c movel %a2@(12),%sp@- <== NOT EXECUTED
4fe30: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fe32: 4eb9 0005 0ad8 jsr 50ad8 <fat_free_unique_ino> <== NOT EXECUTED
4fe38: 508f addql #8,%sp <== NOT EXECUTED
free(fat_fd);
4fe3a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4fe3c: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
4fe42: 588f addql #4,%sp <== NOT EXECUTED
4fe44: 602a bras 4fe70 <fat_file_close+0xaa> <== NOT EXECUTED
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
4fe46: 2f2a 000c movel %a2@(12),%sp@-
4fe4a: 2f0b movel %a3,%sp@-
4fe4c: 4eb9 0005 0b0a jsr 50b0a <fat_ino_is_unique>
4fe52: 508f addql #8,%sp
4fe54: 4a00 tstb %d0
4fe56: 6706 beqs 4fe5e <fat_file_close+0x98> <== ALWAYS TAKEN
{
fat_fd->links_num = 0;
4fe58: 42aa 0008 clrl %a2@(8) <== NOT EXECUTED
4fe5c: 6012 bras 4fe70 <fat_file_close+0xaa> <== NOT EXECUTED
4fe5e: 2f0a movel %a2,%sp@-
4fe60: 4eb9 0004 99e4 jsr 499e4 <_Chain_Extract>
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
4fe66: 2f0a movel %a2,%sp@-
4fe68: 4eb9 0004 54d0 jsr 454d0 <free>
4fe6e: 508f addql #8,%sp
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
4fe70: 2d42 0008 movel %d2,%fp@(8)
return rc;
}
4fe74: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
4fe7a: 4e5e unlk %fp
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
4fe7c: 4ef9 0005 0690 jmp 50690 <fat_buf_release>
return rc;
}
4fe82: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
4fe88: 4e5e unlk %fp <== NOT EXECUTED
000502c8 <fat_file_datasync>:
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
502c8: 4e56 ffcc linkw %fp,#-52 <== NOT EXECUTED
502cc: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
502d0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
502d4: 286e 0008 moveal %fp@(8),%a4 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
502d8: 2d68 001c fff8 movel %a0@(28),%fp@(-8) <== NOT EXECUTED
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
502de: 246c 0034 moveal %a4@(52),%a2 <== NOT EXECUTED
uint32_t cur_cln = fat_fd->cln;
rtems_bdbuf_buffer *block = NULL;
502e2: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
502e6: 4aa8 0018 tstl %a0@(24) <== NOT EXECUTED
502ea: 6700 00b8 beqw 503a4 <fat_file_datasync+0xdc> <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
502ee: 2f0a movel %a2,%sp@- <== NOT EXECUTED
502f0: 4eb9 0005 0690 jsr 50690 <fat_buf_release> <== NOT EXECUTED
if (rc != RC_OK)
502f6: 588f addql #4,%sp <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
502f8: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
502fa: 6774 beqs 50370 <fat_file_datasync+0xa8> <== NOT EXECUTED
502fc: 6000 00ac braw 503aa <fat_file_datasync+0xe2> <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
50300: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50302: 2f2c 0034 movel %a4@(52),%sp@- <== NOT EXECUTED
50306: 2047 moveal %d7,%a0 <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
50308: 97cb subal %a3,%a3 <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
5030a: 4e90 jsr %a0@ <== NOT EXECUTED
5030c: 508f addql #8,%sp <== NOT EXECUTED
5030e: 2d40 fff4 movel %d0,%fp@(-12) <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
50312: 603e bras 50352 <fat_file_datasync+0x8a> <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
50314: 206e fff4 moveal %fp@(-12),%a0 <== NOT EXECUTED
50318: 2f06 movel %d6,%sp@- <== NOT EXECUTED
5031a: 4873 8800 pea %a3@(00000000,%a0:l) <== NOT EXECUTED
5031e: 2045 moveal %d5,%a0 <== NOT EXECUTED
50320: 2f2a 004e movel %a2@(78),%sp@- <== NOT EXECUTED
50324: 2f2a 004a movel %a2@(74),%sp@- <== NOT EXECUTED
50328: 4e90 jsr %a0@ <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
5032a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5032e: 4a80 tstl %d0 <== NOT EXECUTED
50330: 660e bnes 50340 <fat_file_datasync+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
50332: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
50336: 2044 moveal %d4,%a0 <== NOT EXECUTED
50338: 4e90 jsr %a0@ <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
5033a: 588f addql #4,%sp <== NOT EXECUTED
5033c: 4a80 tstl %d0 <== NOT EXECUTED
5033e: 6710 beqs 50350 <fat_file_datasync+0x88> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
50340: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
50346: 7605 moveq #5,%d3 <== NOT EXECUTED
50348: 74ff moveq #-1,%d2 <== NOT EXECUTED
5034a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5034c: 2083 movel %d3,%a0@ <== NOT EXECUTED
5034e: 605a bras 503aa <fat_file_datasync+0xe2> <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
50350: 528b addql #1,%a3 <== NOT EXECUTED
50352: 4280 clrl %d0 <== NOT EXECUTED
50354: 102a 0004 moveb %a2@(4),%d0 <== NOT EXECUTED
50358: b08b cmpl %a3,%d0 <== NOT EXECUTED
5035a: 62b8 bhis 50314 <fat_file_datasync+0x4c> <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
5035c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5035e: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
50362: 2f0c movel %a4,%sp@- <== NOT EXECUTED
50364: 4e95 jsr %a5@ <== NOT EXECUTED
if ( rc != RC_OK )
50366: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5036a: 4a80 tstl %d0 <== NOT EXECUTED
5036c: 6722 beqs 50390 <fat_file_datasync+0xc8> <== NOT EXECUTED
5036e: 6038 bras 503a8 <fat_file_datasync+0xe0> <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
50370: 2c0e movel %fp,%d6 <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50372: 260e movel %fp,%d3 <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
50374: 2e3c 0004 f93c movel #325948,%d7 <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
5037a: 5986 subql #4,%d6 <== NOT EXECUTED
5037c: 2a3c 0004 eefc movel #323324,%d5 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
50382: 283c 0004 f22e movel #324142,%d4 <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50388: 5183 subql #8,%d3 <== NOT EXECUTED
5038a: 4bf9 0005 67b8 lea 567b8 <fat_get_fat_cluster>,%a5 <== NOT EXECUTED
rc = fat_buf_release(fs_info);
if (rc != RC_OK)
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
50390: 202e fff8 movel %fp@(-8),%d0 <== NOT EXECUTED
50394: 2200 movel %d0,%d1 <== NOT EXECUTED
50396: c2aa 000c andl %a2@(12),%d1 <== NOT EXECUTED
5039a: b2aa 0010 cmpl %a2@(16),%d1 <== NOT EXECUTED
5039e: 6500 ff60 bcsw 50300 <fat_file_datasync+0x38> <== NOT EXECUTED
503a2: 6006 bras 503aa <fat_file_datasync+0xe2> <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
return RC_OK;
503a4: 4282 clrl %d2 <== NOT EXECUTED
503a6: 6002 bras 503aa <fat_file_datasync+0xe2> <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
503a8: 2400 movel %d0,%d2 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
return rc;
}
503aa: 2002 movel %d2,%d0 <== NOT EXECUTED
503ac: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5 <== NOT EXECUTED
503b2: 4e5e unlk %fp <== NOT EXECUTED
0004ff24 <fat_file_extend>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
4ff24: 4e56 ffcc linkw %fp,#-52
4ff28: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4ff2c: 266e 0008 moveal %fp@(8),%a3
4ff30: 262e 0010 movel %fp@(16),%d3
4ff34: 2a6e 0014 moveal %fp@(20),%a5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4ff38: 286b 0034 moveal %a3@(52),%a4
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
4ff3c: 246e 000c moveal %fp@(12),%a2
uint32_t old_last_cl;
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
4ff40: 2a83 movel %d3,%a5@
if (new_length <= fat_fd->fat_file_size)
4ff42: 202a 0018 movel %a2@(24),%d0
uint32_t *a_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
4ff46: 42ae fff0 clrl %fp@(-16)
uint32_t bytes2add = 0;
uint32_t cls2add = 0;
uint32_t old_last_cl;
uint32_t last_cl = 0;
4ff4a: 42ae fff8 clrl %fp@(-8)
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
4ff4e: b083 cmpl %d3,%d0
4ff50: 6400 0152 bccw 500a4 <fat_file_extend+0x180>
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4ff54: 7201 moveq #1,%d1
4ff56: b2aa 0020 cmpl %a2@(32),%d1
4ff5a: 6612 bnes 4ff6e <fat_file_extend+0x4a> <== ALWAYS TAKEN
4ff5c: 4aaa 0024 tstl %a2@(36) <== NOT EXECUTED
4ff60: 660c bnes 4ff6e <fat_file_extend+0x4a> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
4ff62: 4281 clrl %d1 <== NOT EXECUTED
4ff64: 122c 000a moveb %a4@(10),%d1 <== NOT EXECUTED
4ff68: 7403 moveq #3,%d2 <== NOT EXECUTED
4ff6a: c282 andl %d2,%d1 <== NOT EXECUTED
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4ff6c: 665a bnes 4ffc8 <fat_file_extend+0xa4> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
4ff6e: 4284 clrl %d4
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
4ff70: 2a03 movel %d3,%d5
4ff72: 9a80 subl %d0,%d5
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
4ff74: 382c 0006 movew %a4@(6),%d4
4ff78: 2204 movel %d4,%d1
4ff7a: 5381 subql #1,%d1
4ff7c: 2401 movel %d1,%d2
4ff7e: c480 andl %d0,%d2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
4ff80: 9882 subl %d2,%d4
4ff82: c881 andl %d1,%d4
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
if (bytes2add > bytes_remain)
4ff84: b885 cmpl %d5,%d4
4ff86: 6400 011c bccw 500a4 <fat_file_extend+0x180>
bytes2add -= bytes_remain;
4ff8a: 9a84 subl %d4,%d5
/*
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
4ff8c: 6700 0116 beqw 500a4 <fat_file_extend+0x180>
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
4ff90: 4280 clrl %d0
4ff92: 102c 0008 moveb %a4@(8),%d0
4ff96: 2c05 movel %d5,%d6
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
4ff98: 486e fff8 pea %fp@(-8)
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
4ff9c: 5386 subql #1,%d6
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
4ff9e: 486e fffc pea %fp@(-4)
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
4ffa2: e0ae lsrl %d0,%d6
4ffa4: 5286 addql #1,%d6
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
4ffa6: 2f06 movel %d6,%sp@-
4ffa8: 486e fff0 pea %fp@(-16)
4ffac: 2f0b movel %a3,%sp@-
4ffae: 4eb9 0005 6c38 jsr 56c38 <fat_scan_fat_for_free_clusters>
&cls_added, &last_cl);
/* this means that low level I/O error occured */
if (rc != RC_OK)
4ffb4: 4fef 0014 lea %sp@(20),%sp
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
4ffb8: 2400 movel %d0,%d2
&cls_added, &last_cl);
/* this means that low level I/O error occured */
if (rc != RC_OK)
4ffba: 6600 00ea bnew 500a6 <fat_file_extend+0x182>
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
4ffbe: 202e fffc movel %fp@(-4),%d0
4ffc2: 6616 bnes 4ffda <fat_file_extend+0xb6> <== ALWAYS TAKEN
4ffc4: 4a84 tstl %d4 <== NOT EXECUTED
4ffc6: 6612 bnes 4ffda <fat_file_extend+0xb6> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
4ffc8: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4ffce: 74ff moveq #-1,%d2 <== NOT EXECUTED
4ffd0: 721c moveq #28,%d1 <== NOT EXECUTED
4ffd2: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ffd4: 2081 movel %d1,%a0@ <== NOT EXECUTED
4ffd6: 6000 00ce braw 500a6 <fat_file_extend+0x182> <== NOT EXECUTED
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
4ffda: b086 cmpl %d6,%d0
4ffdc: 671e beqs 4fffc <fat_file_extend+0xd8> <== ALWAYS TAKEN
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
4ffde: 4680 notl %d0 <== NOT EXECUTED
4ffe0: dc80 addl %d0,%d6 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
4ffe2: 4281 clrl %d1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
4ffe4: 4280 clrl %d0 <== NOT EXECUTED
4ffe6: 102c 0008 moveb %a4@(8),%d0 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
4ffea: 322c 0006 movew %a4@(6),%d1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
4ffee: e1ae lsll %d0,%d6 <== NOT EXECUTED
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
4fff0: 2003 movel %d3,%d0 <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
4fff2: 5381 subql #1,%d1 <== NOT EXECUTED
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
4fff4: 9086 subl %d6,%d0 <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
4fff6: ca81 andl %d1,%d5 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
4fff8: 9085 subl %d5,%d0 <== NOT EXECUTED
4fffa: 2a80 movel %d0,%a5@ <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
4fffc: 206a 0018 moveal %a2@(24),%a0
50000: 4a88 tstl %a0
50002: 6612 bnes 50016 <fat_file_extend+0xf2>
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
50004: 202e fff0 movel %fp@(-16),%d0
fat_fd->map.file_cln = 0;
50008: 42aa 0032 clrl %a2@(50)
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
5000c: 2540 001c movel %d0,%a2@(28)
50010: 2540 0036 movel %d0,%a2@(54)
50014: 6050 bras 50066 <fat_file_extend+0x142>
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
50016: 202a 003a movel %a2@(58),%d0
5001a: 72ff moveq #-1,%d1
5001c: b280 cmpl %d0,%d1
5001e: 6706 beqs 50026 <fat_file_extend+0x102> <== NEVER TAKEN
{
old_last_cl = fat_fd->map.last_cln;
50020: 2d40 fff4 movel %d0,%fp@(-12)
50024: 601e bras 50044 <fat_file_extend+0x120>
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
50026: 486e fff4 pea %fp@(-12) <== NOT EXECUTED
5002a: 4868 ffff pea %a0@(-1) <== NOT EXECUTED
5002e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
50032: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50034: 2f0b movel %a3,%sp@- <== NOT EXECUTED
50036: 4eb9 0004 fe8c jsr 4fe8c <fat_file_ioctl> <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
5003c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
50040: 2800 movel %d0,%d4 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
50042: 6648 bnes 5008c <fat_file_extend+0x168> <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
50044: 2f2e fff0 movel %fp@(-16),%sp@-
50048: 2f2e fff4 movel %fp@(-12),%sp@-
5004c: 2f0b movel %a3,%sp@-
5004e: 4eb9 0005 6930 jsr 56930 <fat_set_fat_cluster>
if ( rc != RC_OK )
50054: 4fef 000c lea %sp@(12),%sp
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
50058: 2800 movel %d0,%d4
if ( rc != RC_OK )
5005a: 6630 bnes 5008c <fat_file_extend+0x168> <== NEVER TAKEN
{
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
fat_buf_release(fs_info);
5005c: 2f0c movel %a4,%sp@-
5005e: 4eb9 0005 0690 jsr 50690 <fat_buf_release>
50064: 588f addql #4,%sp
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
50066: 4aae fffc tstl %fp@(-4)
5006a: 6732 beqs 5009e <fat_file_extend+0x17a> <== NEVER TAKEN
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
5006c: 7001 moveq #1,%d0
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
5006e: 256e fff8 003a movel %fp@(-8),%a2@(58)
if (fat_fd->fat_file_type == FAT_DIRECTORY)
50074: b0aa 0010 cmpl %a2@(16),%d0
50078: 6624 bnes 5009e <fat_file_extend+0x17a>
{
rc = fat_init_clusters_chain(mt_entry, chain);
5007a: 2f2e fff0 movel %fp@(-16),%sp@-
5007e: 2f0b movel %a3,%sp@-
50080: 4eb9 0005 0988 jsr 50988 <fat_init_clusters_chain>
if ( rc != RC_OK )
50086: 508f addql #8,%sp
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(mt_entry, chain);
50088: 2800 movel %d0,%d4
if ( rc != RC_OK )
5008a: 6712 beqs 5009e <fat_file_extend+0x17a> <== ALWAYS TAKEN
{
fat_free_fat_clusters_chain(mt_entry, chain);
5008c: 2f2e fff0 movel %fp@(-16),%sp@- <== NOT EXECUTED
return rc;
50090: 2404 movel %d4,%d2 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(mt_entry, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(mt_entry, chain);
50092: 2f0b movel %a3,%sp@- <== NOT EXECUTED
50094: 4eb9 0005 6b8e jsr 56b8e <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
5009a: 508f addql #8,%sp <== NOT EXECUTED
5009c: 6008 bras 500a6 <fat_file_extend+0x182> <== NOT EXECUTED
}
}
}
fat_fd->fat_file_size = new_length;
5009e: 2543 0018 movel %d3,%a2@(24)
return RC_OK;
500a2: 6002 bras 500a6 <fat_file_extend+0x182>
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
500a4: 4282 clrl %d2
}
fat_fd->fat_file_size = new_length;
return RC_OK;
}
500a6: 2002 movel %d2,%d0
500a8: 4cee 3c7c ffcc moveml %fp@(-52),%d2-%d6/%a2-%a5
500ae: 4e5e unlk %fp <== NOT EXECUTED
0004fe8c <fat_file_ioctl>:
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
4fe8c: 7001 moveq #1,%d0
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
4fe8e: 4e56 fff0 linkw %fp,#-16
4fe92: 226e 0008 moveal %fp@(8),%a1
4fe96: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4fe9a: 206e 000c moveal %fp@(12),%a0
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fe9e: 2669 0034 moveal %a1@(52),%a3
uint32_t cur_cln = 0;
4fea2: 42ae fffc clrl %fp@(-4)
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
4fea6: b0ae 0010 cmpl %fp@(16),%d0
4feaa: 6660 bnes 4ff0c <fat_file_ioctl+0x80> <== NEVER TAKEN
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
4feac: 222e 0014 movel %fp@(20),%d1
ret = va_arg(ap, uint32_t *);
4feb0: 246e 0018 moveal %fp@(24),%a2
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
4feb4: b2a8 0018 cmpl %a0@(24),%d1
4feb8: 650e bcss 4fec8 <fat_file_ioctl+0x3c> <== ALWAYS TAKEN
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
4feba: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4fec0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4fec2: 7005 moveq #5,%d0 <== NOT EXECUTED
4fec4: 2080 movel %d0,%a0@ <== NOT EXECUTED
4fec6: 6050 bras 4ff18 <fat_file_ioctl+0x8c> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4fec8: 7001 moveq #1,%d0
4feca: b0a8 0020 cmpl %a0@(32),%d0
4fece: 6618 bnes 4fee8 <fat_file_ioctl+0x5c>
4fed0: 4aa8 0024 tstl %a0@(36)
4fed4: 6612 bnes 4fee8 <fat_file_ioctl+0x5c> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
4fed6: 4280 clrl %d0
4fed8: 102b 000a moveb %a3@(10),%d0
4fedc: 7403 moveq #3,%d2
4fede: c082 andl %d2,%d0
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4fee0: 6706 beqs 4fee8 <fat_file_ioctl+0x5c> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
4fee2: 4292 clrl %a2@
rc = RC_OK;
4fee4: 4280 clrl %d0
break;
4fee6: 6032 bras 4ff1a <fat_file_ioctl+0x8e>
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fee8: 486e fffc pea %fp@(-4)
*ret = 0;
rc = RC_OK;
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
4feec: 4280 clrl %d0
4feee: 102b 0008 moveb %a3@(8),%d0
4fef2: e0a9 lsrl %d0,%d1
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fef4: 2f01 movel %d1,%sp@-
4fef6: 2f08 movel %a0,%sp@-
4fef8: 2f09 movel %a1,%sp@-
4fefa: 4eba f9b8 jsr %pc@(4f8b4 <fat_file_lseek>)
if ( rc != RC_OK )
4fefe: 4fef 0010 lea %sp@(16),%sp
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4ff02: 2001 movel %d1,%d0
if ( rc != RC_OK )
4ff04: 6614 bnes 4ff1a <fat_file_ioctl+0x8e> <== NEVER TAKEN
break;
*ret = cur_cln;
4ff06: 24ae fffc movel %fp@(-4),%a2@
break;
4ff0a: 600e bras 4ff1a <fat_file_ioctl+0x8e>
default:
errno = EINVAL;
4ff0c: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4ff12: 7416 moveq #22,%d2 <== NOT EXECUTED
4ff14: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ff16: 2082 movel %d2,%a0@ <== NOT EXECUTED
rc = -1;
4ff18: 70ff moveq #-1,%d0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
4ff1a: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4ff20: 4e5e unlk %fp <== NOT EXECUTED
0004f8b4 <fat_file_lseek>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
4f8b4: 4e56 ffdc linkw %fp,#-36
4f8b8: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@
4f8bc: 246e 000c moveal %fp@(12),%a2
4f8c0: 2c2e 0008 movel %fp@(8),%d6
4f8c4: 242e 0010 movel %fp@(16),%d2
4f8c8: 266e 0014 moveal %fp@(20),%a3
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
4f8cc: 202a 0032 movel %a2@(50),%d0
4f8d0: b082 cmpl %d2,%d0
4f8d2: 6606 bnes 4f8da <fat_file_lseek+0x26> <== NEVER TAKEN
*disk_cln = fat_fd->map.disk_cln;
4f8d4: 26aa 0036 movel %a2@(54),%a3@
4f8d8: 6054 bras 4f92e <fat_file_lseek+0x7a>
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
4f8da: b082 cmpl %d2,%d0 <== NOT EXECUTED
4f8dc: 640c bccs 4f8ea <fat_file_lseek+0x36> <== NOT EXECUTED
{
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
4f8de: 2802 movel %d2,%d4 <== NOT EXECUTED
4f8e0: 9880 subl %d0,%d4 <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
4f8e2: 2d6a 0036 fffc movel %a2@(54),%fp@(-4) <== NOT EXECUTED
4f8e8: 6008 bras 4f8f2 <fat_file_lseek+0x3e> <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
4f8ea: 2802 movel %d2,%d4 <== NOT EXECUTED
4f8ec: 2d6a 001c fffc movel %a2@(28),%fp@(-4) <== NOT EXECUTED
}
/* skip over the clusters */
for (i = 0; i < count; i++)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4f8f2: 2a0e movel %fp,%d5 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
4f8f4: 4283 clrl %d3 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4f8f6: 5985 subql #4,%d5 <== NOT EXECUTED
4f8f8: 49f9 0005 67b8 lea 567b8 <fat_get_fat_cluster>,%a4 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
4f8fe: 601c bras 4f91c <fat_file_lseek+0x68> <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4f900: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4f902: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4f906: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4f908: 4e94 jsr %a4@ <== NOT EXECUTED
if ( rc != RC_OK )
4f90a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4f90e: 4a80 tstl %d0 <== NOT EXECUTED
4f910: 6708 beqs 4f91a <fat_file_lseek+0x66> <== NOT EXECUTED
return rc;
4f912: 2200 movel %d0,%d1 <== NOT EXECUTED
4f914: 5bc0 smi %d0 <== NOT EXECUTED
4f916: 49c0 extbl %d0 <== NOT EXECUTED
4f918: 6018 bras 4f932 <fat_file_lseek+0x7e> <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
4f91a: 5283 addql #1,%d3 <== NOT EXECUTED
4f91c: b883 cmpl %d3,%d4 <== NOT EXECUTED
4f91e: 66e0 bnes 4f900 <fat_file_lseek+0x4c> <== NOT EXECUTED
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
4f920: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
4f924: 2542 0032 movel %d2,%a2@(50) <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
4f928: 2540 0036 movel %d0,%a2@(54) <== NOT EXECUTED
*disk_cln = cur_cln;
4f92c: 2680 movel %d0,%a3@ <== NOT EXECUTED
}
return RC_OK;
4f92e: 4280 clrl %d0
4f930: 4281 clrl %d1
}
4f932: 4cee 1c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a4
4f938: 4e5e unlk %fp <== NOT EXECUTED
0005026a <fat_file_mark_removed>:
void
fat_file_mark_removed(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
5026a: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
5026e: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
50272: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
50276: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
5027a: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
uint32_t key = 0;
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
5027e: 486a 0020 pea %a2@(32) <== NOT EXECUTED
50282: 2f08 movel %a0,%sp@- <== NOT EXECUTED
50284: 4eba f6ee jsr %pc@(4f974 <fat_construct_key>) <== NOT EXECUTED
50288: 508f addql #8,%sp <== NOT EXECUTED
5028a: 2400 movel %d0,%d2 <== NOT EXECUTED
5028c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5028e: 4eb9 0004 99e4 jsr 499e4 <_Chain_Extract> <== NOT EXECUTED
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
50294: 7001 moveq #1,%d0 <== NOT EXECUTED
50296: c082 andl %d2,%d0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
50298: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5029a: 2200 movel %d0,%d1 <== NOT EXECUTED
5029c: e988 lsll #4,%d0 <== NOT EXECUTED
5029e: e589 lsll #2,%d1 <== NOT EXECUTED
502a0: 9081 subl %d1,%d0 <== NOT EXECUTED
502a2: d0ab 005e addl %a3@(94),%d0 <== NOT EXECUTED
502a6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
502a8: 4eb9 0004 99ac jsr 499ac <_Chain_Append> <== NOT EXECUTED
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
_hash_insert(fs_info->rhash, key, fat_fd->ino, fat_fd);
fat_fd->flags |= FAT_FILE_REMOVED;
502ae: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
502b2: 7201 moveq #1,%d1 <== NOT EXECUTED
502b4: 102a 0030 moveb %a2@(48),%d0 <== NOT EXECUTED
502b8: 8081 orl %d1,%d0 <== NOT EXECUTED
502ba: 1540 0030 moveb %d0,%a2@(48) <== NOT EXECUTED
}
502be: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
502c4: 4e5e unlk %fp <== NOT EXECUTED
0004fa28 <fat_file_open>:
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
4fa28: 4e56 ffe0 linkw %fp,#-32
4fa2c: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
4fa30: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
4fa34: 244e moveal %fp,%a2
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
4fa36: 283c 0004 f9c6 movel #326086,%d4
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fa3c: 286b 0034 moveal %a3@(52),%a4
fat_file_fd_t *lfat_fd = NULL;
4fa40: 42a2 clrl %a2@-
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
4fa42: 262e 000c movel %fp@(12),%d3
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
4fa46: 2f03 movel %d3,%sp@-
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
4fa48: 2a6e 0010 moveal %fp@(16),%a5
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
4fa4c: 2f0b movel %a3,%sp@-
4fa4e: 4eba ff24 jsr %pc@(4f974 <fat_construct_key>)
4fa52: 508f addql #8,%sp
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
4fa54: 2044 moveal %d4,%a0
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
4fa56: 2400 movel %d0,%d2
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
4fa58: 2f0a movel %a2,%sp@-
4fa5a: 42a7 clrl %sp@-
4fa5c: 2f00 movel %d0,%sp@-
4fa5e: 2f2c 005a movel %a4@(90),%sp@-
4fa62: 2f0b movel %a3,%sp@-
4fa64: 4e90 jsr %a0@
if ( rc == RC_OK )
4fa66: 4fef 0014 lea %sp@(20),%sp
4fa6a: 4a80 tstl %d0
4fa6c: 660e bnes 4fa7c <fat_file_open+0x54>
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
4fa6e: 206e fffc moveal %fp@(-4),%a0
4fa72: 2a88 movel %a0,%a5@
lfat_fd->links_num++;
4fa74: 52a8 0008 addql #1,%a0@(8)
return rc;
4fa78: 6000 00d0 braw 4fb4a <fat_file_open+0x122>
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
4fa7c: 2f0a movel %a2,%sp@-
4fa7e: 2044 moveal %d4,%a0
4fa80: 2f02 movel %d2,%sp@-
4fa82: 2f02 movel %d2,%sp@-
4fa84: 2f2c 005e movel %a4@(94),%sp@-
4fa88: 2f0b movel %a3,%sp@-
4fa8a: 4e90 jsr %a0@
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
4fa8c: 4878 0042 pea 42 <DBL_MANT_DIG+0xd>
lfat_fd->links_num++;
return rc;
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
4fa90: 2800 movel %d0,%d4
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
4fa92: 4eb9 0004 5af0 jsr 45af0 <malloc>
if ( lfat_fd == NULL )
4fa98: 4fef 0018 lea %sp@(24),%sp
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
4fa9c: 2440 moveal %d0,%a2
4fa9e: 2a80 movel %d0,%a5@
4faa0: 2d40 fffc movel %d0,%fp@(-4)
if ( lfat_fd == NULL )
4faa4: 660e bnes 4fab4 <fat_file_open+0x8c>
rtems_set_errno_and_return_minus_one( ENOMEM );
4faa6: 4eb9 0005 7e64 jsr 57e64 <__errno>
4faac: 720c moveq #12,%d1
4faae: 2040 moveal %d0,%a0
4fab0: 2081 movel %d1,%a0@
4fab2: 6072 bras 4fb26 <fat_file_open+0xfe>
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
4fab4: 4878 0042 pea 42 <DBL_MANT_DIG+0xd>
4fab8: 42a7 clrl %sp@-
4faba: 2f00 movel %d0,%sp@-
4fabc: 4eb9 0005 8848 jsr 58848 <memset>
lfat_fd->links_num = 1;
4fac2: 7001 moveq #1,%d0
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4fac4: 72fe moveq #-2,%d1
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
4fac6: 2540 0008 movel %d0,%a2@(8)
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4faca: 102a 0030 moveb %a2@(48),%d0
4face: c081 andl %d1,%d0
4fad0: 1540 0030 moveb %d0,%a2@(48)
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4fad4: 70ff moveq #-1,%d0
4fad6: 2540 003a movel %d0,%a2@(58)
lfat_fd->dir_pos = *dir_pos;
4fada: 4878 0010 pea 10 <INVALID_OPERATION>
4fade: 2f03 movel %d3,%sp@-
4fae0: 486a 0020 pea %a2@(32)
4fae4: 4eb9 0005 87d8 jsr 587d8 <memcpy>
if ( rc != RC_OK )
4faea: 4fef 0018 lea %sp@(24),%sp
4faee: 4a84 tstl %d4
4faf0: 6706 beqs 4faf8 <fat_file_open+0xd0> <== NEVER TAKEN
lfat_fd->ino = key;
4faf2: 2542 000c movel %d2,%a2@(12)
4faf6: 6032 bras 4fb2a <fat_file_open+0x102>
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
4faf8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fafa: 4eb9 0005 0a40 jsr 50a40 <fat_get_unique_ino> <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
4fb00: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
4fb04: 588f addql #4,%sp <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
4fb06: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
4fb0a: 4aa8 000c tstl %a0@(12) <== NOT EXECUTED
4fb0e: 661a bnes 4fb2a <fat_file_open+0x102> <== NOT EXECUTED
{
free((*fat_fd));
4fb10: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
4fb12: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
/*
* XXX: kernel resource is unsufficient, but not the memory,
* but there is no suitable errno :(
*/
rtems_set_errno_and_return_minus_one( ENOMEM );
4fb18: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4fb1e: 588f addql #4,%sp <== NOT EXECUTED
4fb20: 2040 moveal %d0,%a0 <== NOT EXECUTED
4fb22: 700c moveq #12,%d0 <== NOT EXECUTED
4fb24: 2080 movel %d0,%a0@ <== NOT EXECUTED
4fb26: 70ff moveq #-1,%d0
4fb28: 6020 bras 4fb4a <fat_file_open+0x122>
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
4fb2a: 7001 moveq #1,%d0
4fb2c: c480 andl %d0,%d2
4fb2e: 2f2e fffc movel %fp@(-4),%sp@-
4fb32: 2002 movel %d2,%d0
4fb34: e98a lsll #4,%d2
4fb36: e588 lsll #2,%d0
4fb38: 9480 subl %d0,%d2
4fb3a: d4ac 005a addl %a4@(90),%d2
4fb3e: 2f02 movel %d2,%sp@-
4fb40: 4eb9 0004 99ac jsr 499ac <_Chain_Append>
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
4fb46: 508f addql #8,%sp
4fb48: 4280 clrl %d0
}
4fb4a: 4cee 3c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a5
4fb50: 4e5e unlk %fp <== NOT EXECUTED
0004fb66 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
4fb66: 4e56 ffd4 linkw %fp,#-44
4fb6a: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4fb6e: 286e 0008 moveal %fp@(8),%a4
4fb72: 266e 000c moveal %fp@(12),%a3
4fb76: 2e2e 0010 movel %fp@(16),%d7
4fb7a: 242e 0014 movel %fp@(20),%d2
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fb7e: 246c 0034 moveal %a4@(52),%a2
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
4fb82: 42ae fffc clrl %fp@(-4)
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
4fb86: 4a82 tstl %d2
4fb88: 6700 013e beqw 4fcc8 <fat_file_read+0x162>
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
4fb8c: 202b 0018 movel %a3@(24),%d0
4fb90: b087 cmpl %d7,%d0
4fb92: 6300 0134 blsw 4fcc8 <fat_file_read+0x162>
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
4fb96: b082 cmpl %d2,%d0
4fb98: 6508 bcss 4fba2 <fat_file_read+0x3c> <== NEVER TAKEN
(start > fat_fd->fat_file_size - count))
4fb9a: 2200 movel %d0,%d1
4fb9c: 9282 subl %d2,%d1
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
4fb9e: b287 cmpl %d7,%d1
4fba0: 6404 bccs 4fba6 <fat_file_read+0x40> <== ALWAYS TAKEN
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
4fba2: 2400 movel %d0,%d2 <== NOT EXECUTED
4fba4: 9487 subl %d7,%d2 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4fba6: 7001 moveq #1,%d0
4fba8: b0ab 0020 cmpl %a3@(32),%d0
4fbac: 6652 bnes 4fc00 <fat_file_read+0x9a>
4fbae: 4aab 0024 tstl %a3@(36)
4fbb2: 664c bnes 4fc00 <fat_file_read+0x9a> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
4fbb4: 4280 clrl %d0
4fbb6: 102a 000a moveb %a2@(10),%d0
4fbba: 7203 moveq #3,%d1
4fbbc: c081 andl %d1,%d0
if ((count > fat_fd->fat_file_size) ||
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4fbbe: 6740 beqs 4fc00 <fat_file_read+0x9a> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
4fbc0: 2f2b 001c movel %a3@(28),%sp@-
4fbc4: 2f0a movel %a2,%sp@-
4fbc6: 4eba fd74 jsr %pc@(4f93c <fat_cluster_num_to_sector_num.isra.0>)
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
4fbca: 588f addql #4,%sp
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
4fbcc: 4281 clrl %d1
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
4fbce: 2040 moveal %d0,%a0
4fbd0: 2eae 0018 movel %fp@(24),%sp@
4fbd4: 2f02 movel %d2,%sp@-
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
4fbd6: 3212 movew %a2@,%d1
4fbd8: 5381 subql #1,%d1
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
4fbda: c287 andl %d7,%d1
4fbdc: 2f01 movel %d1,%sp@-
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
4fbde: 4281 clrl %d1
4fbe0: 122a 0002 moveb %a2@(2),%d1
4fbe4: e2af lsrl %d1,%d7
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
4fbe6: 4870 7800 pea %a0@(00000000,%d7:l)
4fbea: 2f0c movel %a4,%sp@-
4fbec: 4eb9 0005 07c2 jsr 507c2 <_fat_block_read>
if ( ret < 0 )
4fbf2: 4fef 0014 lea %sp@(20),%sp
4fbf6: 4a80 tstl %d0
4fbf8: 6c00 00d8 bgew 4fcd2 <fat_file_read+0x16c>
4fbfc: 6000 00d2 braw 4fcd0 <fat_file_read+0x16a> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
4fc00: 4280 clrl %d0
4fc02: 102a 0008 moveb %a2@(8),%d0
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fc06: 280e movel %fp,%d4
4fc08: 5984 subql #4,%d4
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
4fc0a: 2607 movel %d7,%d3
4fc0c: e0ab lsrl %d0,%d3
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4fc0e: 3a2a 0006 movew %a2@(6),%d5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fc12: 2f04 movel %d4,%sp@-
4fc14: 2f03 movel %d3,%sp@-
4fc16: 2f0b movel %a3,%sp@-
4fc18: 2f0c movel %a4,%sp@-
4fc1a: 4eba fc98 jsr %pc@(4f8b4 <fat_file_lseek>)
if (rc != RC_OK)
4fc1e: 4fef 0010 lea %sp@(16),%sp
4fc22: 4a81 tstl %d1
4fc24: 6600 00a6 bnew 4fccc <fat_file_read+0x166>
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4fc28: 4286 clrl %d6
4fc2a: 9bcd subal %a5,%a5
4fc2c: 0285 0000 ffff andil #65535,%d5
4fc32: 5385 subql #1,%d5
4fc34: ce85 andl %d5,%d7
4fc36: 2a07 movel %d7,%d5
4fc38: 606e bras 4fca8 <fat_file_read+0x142>
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
4fc3a: 4284 clrl %d4
4fc3c: 382a 0006 movew %a2@(6),%d4
4fc40: 9885 subl %d5,%d4
4fc42: b484 cmpl %d4,%d2
4fc44: 6402 bccs 4fc48 <fat_file_read+0xe2>
4fc46: 2802 movel %d2,%d4
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
4fc48: 2f2e fffc movel %fp@(-4),%sp@-
4fc4c: 2f2c 0034 movel %a4@(52),%sp@-
4fc50: 4eba fcea jsr %pc@(4f93c <fat_cluster_num_to_sector_num.isra.0>)
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fc54: 206e 0018 moveal %fp@(24),%a0
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
4fc58: 508f addql #8,%sp
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fc5a: 4870 d800 pea %a0@(00000000,%a5:l)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
4fc5e: 4281 clrl %d1
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fc60: 2040 moveal %d0,%a0
4fc62: 2f04 movel %d4,%sp@-
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
4fc64: 3212 movew %a2@,%d1
4fc66: 5381 subql #1,%d1
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fc68: c285 andl %d5,%d1
4fc6a: 2f01 movel %d1,%sp@-
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
4fc6c: 4281 clrl %d1
4fc6e: 122a 0002 moveb %a2@(2),%d1
4fc72: e2ad lsrl %d1,%d5
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
4fc74: 4870 5800 pea %a0@(00000000,%d5:l)
4fc78: 2f0c movel %a4,%sp@-
4fc7a: 4eb9 0005 07c2 jsr 507c2 <_fat_block_read>
if ( ret < 0 )
4fc80: 4fef 0014 lea %sp@(20),%sp
4fc84: 4a80 tstl %d0
4fc86: 6d48 blts 4fcd0 <fat_file_read+0x16a> <== NEVER TAKEN
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4fc88: 486e fffc pea %fp@(-4)
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
4fc8c: 9484 subl %d4,%d2
cmpltd += c;
4fc8e: dbc4 addal %d4,%a5
save_cln = cur_cln;
4fc90: 2c2e fffc movel %fp@(-4),%d6
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
4fc94: 2f06 movel %d6,%sp@-
4fc96: 2f0c movel %a4,%sp@-
4fc98: 4eb9 0005 67b8 jsr 567b8 <fat_get_fat_cluster>
if ( rc != RC_OK )
4fc9e: 4fef 000c lea %sp@(12),%sp
4fca2: 4a80 tstl %d0
4fca4: 662c bnes 4fcd2 <fat_file_read+0x16c> <== NEVER TAKEN
return rc;
ofs = 0;
4fca6: 4285 clrl %d5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
4fca8: 4a82 tstl %d2
4fcaa: 668e bnes 4fc3a <fat_file_read+0xd4>
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4fcac: 4281 clrl %d1
4fcae: 122a 0008 moveb %a2@(8),%d1
4fcb2: 41f5 78ff lea %a5@(ffffffff,%d7:l),%a0
fat_fd->map.disk_cln = save_cln;
4fcb6: 2746 0036 movel %d6,%a3@(54)
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4fcba: 2008 movel %a0,%d0
4fcbc: e2a8 lsrl %d1,%d0
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
4fcbe: d083 addl %d3,%d0
4fcc0: 2740 0032 movel %d0,%a3@(50)
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
4fcc4: 200d movel %a5,%d0
4fcc6: 600a bras 4fcd2 <fat_file_read+0x16c>
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
4fcc8: 4280 clrl %d0 <== NOT EXECUTED
4fcca: 6006 bras 4fcd2 <fat_file_read+0x16c> <== NOT EXECUTED
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
4fccc: 2001 movel %d1,%d0 <== NOT EXECUTED
4fcce: 6002 bras 4fcd2 <fat_file_read+0x16c> <== NOT EXECUTED
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
4fcd0: 70ff moveq #-1,%d0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
4fcd2: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4fcd8: 4e5e unlk %fp <== NOT EXECUTED
000503b6 <fat_file_size>:
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
503b6: 7001 moveq #1,%d0
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
503b8: 4e56 ffe4 linkw %fp,#-28
503bc: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
503c0: 286e 0008 moveal %fp@(8),%a4
503c4: 246e 000c moveal %fp@(12),%a2
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
503c8: 266c 0034 moveal %a4@(52),%a3
uint32_t cur_cln = fat_fd->cln;
503cc: 2d6a 001c fffc movel %a2@(28),%fp@(-4)
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
503d2: b0aa 0020 cmpl %a2@(32),%d0
503d6: 661a bnes 503f2 <fat_file_size+0x3c> <== ALWAYS TAKEN
503d8: 4aaa 0024 tstl %a2@(36) <== NOT EXECUTED
503dc: 6614 bnes 503f2 <fat_file_size+0x3c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
503de: 4280 clrl %d0 <== NOT EXECUTED
503e0: 102b 000a moveb %a3@(10),%d0 <== NOT EXECUTED
503e4: 7203 moveq #3,%d1 <== NOT EXECUTED
503e6: c081 andl %d1,%d0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
503e8: 6708 beqs 503f2 <fat_file_size+0x3c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
503ea: 256b 0024 0018 movel %a3@(36),%a2@(24) <== NOT EXECUTED
503f0: 6042 bras 50434 <fat_file_size+0x7e> <== NOT EXECUTED
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
503f2: 260e movel %fp,%d3
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
503f4: 4280 clrl %d0
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
503f6: 5983 subql #4,%d3
503f8: 4bf9 0005 67b8 lea 567b8 <fat_get_fat_cluster>,%a5
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
return rc;
}
fat_fd->fat_file_size = 0;
503fe: 42aa 0018 clrl %a2@(24)
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
50402: 601c bras 50420 <fat_file_size+0x6a>
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50404: 2f03 movel %d3,%sp@-
50406: 2f02 movel %d2,%sp@-
50408: 2f0c movel %a4,%sp@-
5040a: 4e95 jsr %a5@
if ( rc != RC_OK )
5040c: 4fef 000c lea %sp@(12),%sp
50410: 4a80 tstl %d0
50412: 6622 bnes 50436 <fat_file_size+0x80> <== NEVER TAKEN
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
50414: 4280 clrl %d0
50416: 302b 0006 movew %a3@(6),%d0
5041a: d1aa 0018 addl %d0,%a2@(24)
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
5041e: 2002 movel %d2,%d0
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
50420: 242e fffc movel %fp@(-4),%d2
50424: 2202 movel %d2,%d1
50426: c2ab 000c andl %a3@(12),%d1
5042a: b2ab 0010 cmpl %a3@(16),%d1
5042e: 65d4 bcss 50404 <fat_file_size+0x4e>
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
50430: 2540 003a movel %d0,%a2@(58)
return rc;
50434: 4280 clrl %d0
}
50436: 4cee 3c0c ffe4 moveml %fp@(-28),%d2-%d3/%a2-%a5
5043c: 4e5e unlk %fp <== NOT EXECUTED
0004fcdc <fat_file_truncate>:
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
4fcdc: 70ff moveq #-1,%d0
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
4fcde: 4e56 ffe8 linkw %fp,#-24
4fce2: 206e 0010 moveal %fp@(16),%a0
4fce6: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4fcea: 266e 0008 moveal %fp@(8),%a3
4fcee: 246e 000c moveal %fp@(12),%a2
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
4fcf2: 2d40 fffc movel %d0,%fp@(-4)
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
4fcf6: 226b 0034 moveal %a3@(52),%a1
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
4fcfa: 202a 0018 movel %a2@(24),%d0
uint32_t new_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
4fcfe: 42ae fff8 clrl %fp@(-8)
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
4fd02: b088 cmpl %a0,%d0
4fd04: 6300 00b4 blsw 4fdba <fat_file_truncate+0xde>
return rc;
assert(fat_fd->fat_file_size);
4fd08: 4a80 tstl %d0
4fd0a: 661c bnes 4fd28 <fat_file_truncate+0x4c> <== ALWAYS TAKEN
4fd0c: 4879 0006 792e pea 6792e <rtems_filesystem_handlers_default+0x38><== NOT EXECUTED
4fd12: 4879 0006 798c pea 6798c <__FUNCTION__.6120> <== NOT EXECUTED
4fd18: 4878 026d pea 26d <DBL_MANT_DIG+0x238> <== NOT EXECUTED
4fd1c: 4879 0006 7944 pea 67944 <rtems_filesystem_handlers_default+0x4e><== NOT EXECUTED
4fd22: 4eb9 0005 20dc jsr 520dc <__assert_func> <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
4fd28: 4282 clrl %d2
4fd2a: 4281 clrl %d1
4fd2c: 1229 0008 moveb %a1@(8),%d1
4fd30: 3429 0006 movew %a1@(6),%d2
4fd34: 41f0 28ff lea %a0@(ffffffff,%d2:l),%a0
4fd38: 2408 movel %a0,%d2
4fd3a: e2aa lsrl %d1,%d2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
4fd3c: 2602 movel %d2,%d3
4fd3e: e3ab lsll %d1,%d3
4fd40: b083 cmpl %d3,%d0
4fd42: 6376 blss 4fdba <fat_file_truncate+0xde> <== NEVER TAKEN
return RC_OK;
if (cl_start != 0)
4fd44: 4a82 tstl %d2
4fd46: 671a beqs 4fd62 <fat_file_truncate+0x86> <== ALWAYS TAKEN
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
4fd48: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4fd4c: 2042 moveal %d2,%a0 <== NOT EXECUTED
4fd4e: 4868 ffff pea %a0@(-1) <== NOT EXECUTED
4fd52: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4fd54: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fd56: 4eba fb5c jsr %pc@(4f8b4 <fat_file_lseek>) <== NOT EXECUTED
if (rc != RC_OK)
4fd5a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
return RC_OK;
if (cl_start != 0)
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
4fd5e: 2001 movel %d1,%d0 <== NOT EXECUTED
if (rc != RC_OK)
4fd60: 665a bnes 4fdbc <fat_file_truncate+0xe0> <== NOT EXECUTED
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fd62: 486e fff8 pea %fp@(-8)
4fd66: 2f02 movel %d2,%sp@-
4fd68: 2f0a movel %a2,%sp@-
4fd6a: 2f0b movel %a3,%sp@-
4fd6c: 4eba fb46 jsr %pc@(4f8b4 <fat_file_lseek>)
if (rc != RC_OK)
4fd70: 4fef 0010 lea %sp@(16),%sp
if (rc != RC_OK)
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
4fd74: 2001 movel %d1,%d0
if (rc != RC_OK)
4fd76: 6644 bnes 4fdbc <fat_file_truncate+0xe0> <== NEVER TAKEN
return rc;
rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
4fd78: 2f2e fff8 movel %fp@(-8),%sp@-
4fd7c: 2f0b movel %a3,%sp@-
4fd7e: 4eb9 0005 6b8e jsr 56b8e <fat_free_fat_clusters_chain>
if (rc != RC_OK)
4fd84: 508f addql #8,%sp
4fd86: 4a80 tstl %d0
4fd88: 6632 bnes 4fdbc <fat_file_truncate+0xe0> <== NEVER TAKEN
return rc;
if (cl_start != 0)
4fd8a: 4a82 tstl %d2
4fd8c: 672e beqs 4fdbc <fat_file_truncate+0xe0> <== ALWAYS TAKEN
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
4fd8e: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
4fd92: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4fd96: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4fd98: 4eb9 0005 6930 jsr 56930 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
4fd9e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4fda2: 4a80 tstl %d0 <== NOT EXECUTED
4fda4: 6616 bnes 4fdbc <fat_file_truncate+0xe0> <== NOT EXECUTED
return rc;
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
4fda6: 222e fffc movel %fp@(-4),%d1 <== NOT EXECUTED
if (cl_start != 0)
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
4fdaa: 5382 subql #1,%d2 <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
4fdac: 2541 0036 movel %d1,%a2@(54) <== NOT EXECUTED
if (cl_start != 0)
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
4fdb0: 2542 0032 movel %d2,%a2@(50) <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
4fdb4: 2541 003a movel %d1,%a2@(58) <== NOT EXECUTED
4fdb8: 6002 bras 4fdbc <fat_file_truncate+0xe0> <== NOT EXECUTED
assert(fat_fd->fat_file_size);
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
return RC_OK;
4fdba: 4280 clrl %d0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
}
return RC_OK;
}
4fdbc: 4cee 0c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a3
4fdc2: 4e5e unlk %fp <== NOT EXECUTED
000500b2 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
500b2: 4e56 ffd0 linkw %fp,#-48
500b6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
500ba: 286e 0008 moveal %fp@(8),%a4
500be: 246e 000c moveal %fp@(12),%a2
500c2: 2e2e 0010 movel %fp@(16),%d7
500c6: 242e 0014 movel %fp@(20),%d2
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
500ca: 266c 0034 moveal %a4@(52),%a3
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
500ce: 42ae fff8 clrl %fp@(-8)
uint32_t cl_start = 0;
uint32_t ofs = 0;
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
500d2: 42ae fffc clrl %fp@(-4)
if ( count == 0 )
500d6: 4a82 tstl %d2
500d8: 6700 0180 beqw 5025a <fat_file_write+0x1a8>
return cmpltd;
if ( start > fat_fd->fat_file_size )
500dc: beaa 0018 cmpl %a2@(24),%d7
500e0: 620e bhis 500f0 <fat_file_write+0x3e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
500e2: 202a 0014 movel %a2@(20),%d0
500e6: b082 cmpl %d2,%d0
500e8: 6506 bcss 500f0 <fat_file_write+0x3e> <== NEVER TAKEN
(start > fat_fd->size_limit - count))
500ea: 9082 subl %d2,%d0
return cmpltd;
if ( start > fat_fd->fat_file_size )
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
500ec: b087 cmpl %d7,%d0
500ee: 6410 bccs 50100 <fat_file_write+0x4e> <== ALWAYS TAKEN
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
500f0: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
500f6: 7405 moveq #5,%d2 <== NOT EXECUTED
500f8: 2040 moveal %d0,%a0 <== NOT EXECUTED
500fa: 2082 movel %d2,%a0@ <== NOT EXECUTED
500fc: 6000 0160 braw 5025e <fat_file_write+0x1ac> <== NOT EXECUTED
rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);
50100: 486e fffc pea %fp@(-4)
50104: 2602 movel %d2,%d3
50106: d687 addl %d7,%d3
50108: 2f03 movel %d3,%sp@-
5010a: 2f0a movel %a2,%sp@-
5010c: 2f0c movel %a4,%sp@-
5010e: 4eb9 0004 ff24 jsr 4ff24 <fat_file_extend>
if (rc != RC_OK)
50114: 4fef 0010 lea %sp@(16),%sp
50118: 4a80 tstl %d0
5011a: 6600 0144 bnew 50260 <fat_file_write+0x1ae>
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
5011e: 202e fffc movel %fp@(-4),%d0
50122: b680 cmpl %d0,%d3
50124: 6704 beqs 5012a <fat_file_write+0x78> <== ALWAYS TAKEN
count = c - start;
50126: 2400 movel %d0,%d2 <== NOT EXECUTED
50128: 9487 subl %d7,%d2 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
5012a: 7001 moveq #1,%d0
5012c: b0aa 0020 cmpl %a2@(32),%d0
50130: 6654 bnes 50186 <fat_file_write+0xd4>
50132: 4aaa 0024 tstl %a2@(36)
50136: 664e bnes 50186 <fat_file_write+0xd4> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
50138: 4280 clrl %d0
5013a: 102b 000a moveb %a3@(10),%d0
5013e: 7203 moveq #3,%d1
50140: c081 andl %d1,%d0
* file of 'start + count' bytes
*/
if (c != (start + count))
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
50142: 6742 beqs 50186 <fat_file_write+0xd4> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
50144: 2f2a 001c movel %a2@(28),%sp@-
50148: 2f2c 0034 movel %a4@(52),%sp@-
5014c: 4eba f7ee jsr %pc@(4f93c <fat_cluster_num_to_sector_num.isra.0>)
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
50150: 588f addql #4,%sp
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
50152: 4281 clrl %d1
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
50154: 2040 moveal %d0,%a0
50156: 2eae 0018 movel %fp@(24),%sp@
5015a: 2f02 movel %d2,%sp@-
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
5015c: 3213 movew %a3@,%d1
5015e: 5381 subql #1,%d1
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
50160: c287 andl %d7,%d1
50162: 2f01 movel %d1,%sp@-
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
50164: 4281 clrl %d1
50166: 122b 0002 moveb %a3@(2),%d1
5016a: e2af lsrl %d1,%d7
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
5016c: 4870 7800 pea %a0@(00000000,%d7:l)
50170: 2f0c movel %a4,%sp@-
50172: 4eb9 0005 084a jsr 5084a <_fat_block_write>
if ( ret < 0 )
50178: 4fef 0014 lea %sp@(20),%sp
5017c: 4a80 tstl %d0
5017e: 6c00 00e0 bgew 50260 <fat_file_write+0x1ae>
50182: 6000 00da braw 5025e <fat_file_write+0x1ac> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
50186: 4280 clrl %d0
50188: 102b 0008 moveb %a3@(8),%d0
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
5018c: 280e movel %fp,%d4
5018e: 5184 subql #8,%d4
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
50190: 2607 movel %d7,%d3
50192: e0ab lsrl %d0,%d3
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
50194: 3a2b 0006 movew %a3@(6),%d5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
50198: 2f04 movel %d4,%sp@-
5019a: 2f03 movel %d3,%sp@-
5019c: 2f0a movel %a2,%sp@-
5019e: 2f0c movel %a4,%sp@-
501a0: 4eba f712 jsr %pc@(4f8b4 <fat_file_lseek>)
if (rc != RC_OK)
501a4: 4fef 0010 lea %sp@(16),%sp
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
501a8: 2001 movel %d1,%d0
if (rc != RC_OK)
501aa: 6600 00b4 bnew 50260 <fat_file_write+0x1ae>
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
501ae: 4286 clrl %d6
501b0: 9bcd subal %a5,%a5
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
501b2: 283c 0005 67b8 movel #354232,%d4
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
501b8: 0285 0000 ffff andil #65535,%d5
501be: 5385 subql #1,%d5
501c0: ce85 andl %d5,%d7
501c2: 2a07 movel %d7,%d5
501c4: 6074 bras 5023a <fat_file_write+0x188>
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
501c6: 4286 clrl %d6
501c8: 3c2b 0006 movew %a3@(6),%d6
501cc: 9c85 subl %d5,%d6
501ce: b486 cmpl %d6,%d2
501d0: 6402 bccs 501d4 <fat_file_write+0x122>
501d2: 2c02 movel %d2,%d6
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
501d4: 2f2e fff8 movel %fp@(-8),%sp@-
501d8: 2f2c 0034 movel %a4@(52),%sp@-
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
501dc: 2d46 fffc movel %d6,%fp@(-4)
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
501e0: 4eba f75a jsr %pc@(4f93c <fat_cluster_num_to_sector_num.isra.0>)
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
501e4: 206e 0018 moveal %fp@(24),%a0
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
501e8: 508f addql #8,%sp
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
501ea: 4870 d800 pea %a0@(00000000,%a5:l)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
501ee: 4281 clrl %d1
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
501f0: 2040 moveal %d0,%a0
501f2: 2f06 movel %d6,%sp@-
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
501f4: 3213 movew %a3@,%d1
501f6: 5381 subql #1,%d1
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
501f8: c285 andl %d5,%d1
501fa: 2f01 movel %d1,%sp@-
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
501fc: 4281 clrl %d1
501fe: 122b 0002 moveb %a3@(2),%d1
50202: e2ad lsrl %d1,%d5
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
50204: 4870 5800 pea %a0@(00000000,%d5:l)
50208: 2f0c movel %a4,%sp@-
5020a: 4eb9 0005 084a jsr 5084a <_fat_block_write>
if ( ret < 0 )
50210: 4fef 0014 lea %sp@(20),%sp
50214: 4a80 tstl %d0
50216: 6d46 blts 5025e <fat_file_write+0x1ac> <== NEVER TAKEN
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50218: 486e fff8 pea %fp@(-8)
5021c: 2044 moveal %d4,%a0
if ( ret < 0 )
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
5021e: 2c2e fff8 movel %fp@(-8),%d6
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50222: 2f06 movel %d6,%sp@-
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
50224: 202e fffc movel %fp@(-4),%d0
50228: 9480 subl %d0,%d2
cmpltd += c;
5022a: dbc0 addal %d0,%a5
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
5022c: 2f0c movel %a4,%sp@-
5022e: 4e90 jsr %a0@
if ( rc != RC_OK )
50230: 4fef 000c lea %sp@(12),%sp
50234: 4a80 tstl %d0
50236: 6628 bnes 50260 <fat_file_write+0x1ae> <== NEVER TAKEN
return rc;
ofs = 0;
50238: 4285 clrl %d5
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
5023a: 4a82 tstl %d2
5023c: 6688 bnes 501c6 <fat_file_write+0x114>
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
5023e: 4281 clrl %d1
50240: 122b 0008 moveb %a3@(8),%d1
50244: 41f5 78ff lea %a5@(ffffffff,%d7:l),%a0
fat_fd->map.disk_cln = save_cln;
50248: 2546 0036 movel %d6,%a2@(54)
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
5024c: 2008 movel %a0,%d0
5024e: e2a8 lsrl %d1,%d0
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
50250: d083 addl %d3,%d0
50252: 2540 0032 movel %d0,%a2@(50)
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
50256: 200d movel %a5,%d0
50258: 6006 bras 50260 <fat_file_write+0x1ae>
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
return cmpltd;
5025a: 4280 clrl %d0 <== NOT EXECUTED
5025c: 6002 bras 50260 <fat_file_write+0x1ae> <== NOT EXECUTED
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
5025e: 70ff moveq #-1,%d0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
50260: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
50266: 4e5e unlk %fp <== NOT EXECUTED
00056b8e <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
56b8e: 4e56 ffd4 linkw %fp,#-44
56b92: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
56b96: 286e 0008 moveal %fp@(8),%a4
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
56b9a: 264e moveal %fp,%a3
uint32_t freed_cls_cnt = 0;
56b9c: 4282 clrl %d2
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
56b9e: 4285 clrl %d5
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
56ba0: 2e3c 0005 67b8 movel #354232,%d7
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
56ba6: 4bf9 0005 6930 lea 56930 <fat_set_fat_cluster>,%a5
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
56bac: 2c2e 000c movel %fp@(12),%d6
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
56bb0: 2606 movel %d6,%d3
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
56bb2: 246c 0034 moveal %a4@(52),%a2
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
56bb6: 42a3 clrl %a3@-
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
56bb8: 6046 bras 56c00 <fat_free_fat_clusters_chain+0x72>
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
56bba: 2f0b movel %a3,%sp@-
56bbc: 2047 moveal %d7,%a0
56bbe: 2f03 movel %d3,%sp@-
56bc0: 2f0c movel %a4,%sp@-
56bc2: 4e90 jsr %a0@
if ( rc != RC_OK )
56bc4: 4fef 000c lea %sp@(12),%sp
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
56bc8: 2800 movel %d0,%d4
if ( rc != RC_OK )
56bca: 671c beqs 56be8 <fat_free_fat_clusters_chain+0x5a><== ALWAYS TAKEN
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
56bcc: 202a 003a movel %a2@(58),%d0 <== NOT EXECUTED
56bd0: 72ff moveq #-1,%d1 <== NOT EXECUTED
56bd2: b280 cmpl %d0,%d1 <== NOT EXECUTED
56bd4: 6706 beqs 56bdc <fat_free_fat_clusters_chain+0x4e><== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
56bd6: d480 addl %d0,%d2 <== NOT EXECUTED
56bd8: 2542 003a movel %d2,%a2@(58) <== NOT EXECUTED
fat_buf_release(fs_info);
56bdc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56bde: 4eb9 0005 0690 jsr 50690 <fat_buf_release> <== NOT EXECUTED
return rc;
56be4: 588f addql #4,%sp <== NOT EXECUTED
56be6: 6044 bras 56c2c <fat_free_fat_clusters_chain+0x9e><== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
56be8: 42a7 clrl %sp@-
56bea: 2f03 movel %d3,%sp@-
56bec: 2f0c movel %a4,%sp@-
56bee: 4e95 jsr %a5@
if ( rc != RC_OK )
56bf0: 4fef 000c lea %sp@(12),%sp
56bf4: 4a80 tstl %d0
56bf6: 6702 beqs 56bfa <fat_free_fat_clusters_chain+0x6c><== ALWAYS TAKEN
56bf8: 2a00 movel %d0,%d5 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
56bfa: 262e fffc movel %fp@(-4),%d3
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
56bfe: 5282 addql #1,%d2
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
56c00: 2003 movel %d3,%d0
56c02: c0aa 000c andl %a2@(12),%d0
56c06: b0aa 0010 cmpl %a2@(16),%d0
56c0a: 65ae bcss 56bba <fat_free_fat_clusters_chain+0x2c>
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
56c0c: 202a 003a movel %a2@(58),%d0
56c10: 72ff moveq #-1,%d1
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
56c12: 2546 003e movel %d6,%a2@(62)
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
56c16: b280 cmpl %d0,%d1
56c18: 6706 beqs 56c20 <fat_free_fat_clusters_chain+0x92><== ALWAYS TAKEN
fs_info->vol.free_cls += freed_cls_cnt;
56c1a: d480 addl %d0,%d2 <== NOT EXECUTED
56c1c: 2542 003a movel %d2,%a2@(58) <== NOT EXECUTED
fat_buf_release(fs_info);
56c20: 2f0a movel %a2,%sp@-
56c22: 2805 movel %d5,%d4
56c24: 4eb9 0005 0690 jsr 50690 <fat_buf_release>
56c2a: 588f addql #4,%sp
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
56c2c: 2004 movel %d4,%d0
56c2e: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
56c34: 4e5e unlk %fp <== NOT EXECUTED
00050ad8 <fat_free_unique_ino>:
void
fat_free_unique_ino(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
50ad8: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
50adc: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
50ae0: 202e 000c movel %fp@(12),%d0 <== NOT EXECUTED
fat_free_unique_ino(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
50ae4: 2268 0034 moveal %a0@(52),%a1 <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
50ae8: 90a9 006e subl %a1@(110),%d0 <== NOT EXECUTED
50aec: 2200 movel %d0,%d1 <== NOT EXECUTED
50aee: e689 lsrl #3,%d1 <== NOT EXECUTED
50af0: 2069 0062 moveal %a1@(98),%a0 <== NOT EXECUTED
50af4: d1c1 addal %d1,%a0 <== NOT EXECUTED
50af6: 7207 moveq #7,%d1 <== NOT EXECUTED
50af8: c280 andl %d0,%d1 <== NOT EXECUTED
50afa: 7001 moveq #1,%d0 <== NOT EXECUTED
50afc: e3a8 lsll %d1,%d0 <== NOT EXECUTED
50afe: 1210 moveb %a0@,%d1 <== NOT EXECUTED
50b00: 4680 notl %d0 <== NOT EXECUTED
50b02: c081 andl %d1,%d0 <== NOT EXECUTED
50b04: 1080 moveb %d0,%a0@ <== NOT EXECUTED
}
50b06: 4e5e unlk %fp <== NOT EXECUTED
000567b8 <fat_get_fat_cluster>:
rtems_bdbuf_buffer *block0 = NULL;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
567b8: 7001 moveq #1,%d0
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
567ba: 4e56 ffd8 linkw %fp,#-40
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
567be: 206e 0008 moveal %fp@(8),%a0
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
567c2: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
567c6: 242e 000c movel %fp@(12),%d2
567ca: 246e 0010 moveal %fp@(16),%a2
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
567ce: 2668 0034 moveal %a0@(52),%a3
rtems_bdbuf_buffer *block0 = NULL;
567d2: 42ae fffc clrl %fp@(-4)
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
567d6: b082 cmpl %d2,%d0
567d8: 6400 0138 bccw 56912 <fat_get_fat_cluster+0x15a>
567dc: 202b 0030 movel %a3@(48),%d0
567e0: 5280 addql #1,%d0
567e2: b082 cmpl %d2,%d0
567e4: 6500 012c bcsw 56912 <fat_get_fat_cluster+0x15a>
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
567e8: 4280 clrl %d0
567ea: 102b 000a moveb %a3@(10),%d0
567ee: 7201 moveq #1,%d1
567f0: 2802 movel %d2,%d4
567f2: c280 andl %d0,%d1
567f4: 6706 beqs 567fc <fat_get_fat_cluster+0x44> <== NEVER TAKEN
567f6: e28c lsrl #1,%d4
567f8: d882 addl %d2,%d4
567fa: 600c bras 56808 <fat_get_fat_cluster+0x50>
567fc: 0800 0001 btst #1,%d0 <== NOT EXECUTED
56800: 6704 beqs 56806 <fat_get_fat_cluster+0x4e> <== NOT EXECUTED
56802: d884 addl %d4,%d4 <== NOT EXECUTED
56804: 6002 bras 56808 <fat_get_fat_cluster+0x50> <== NOT EXECUTED
56806: e58c lsll #2,%d4 <== NOT EXECUTED
56808: 4283 clrl %d3
5680a: 162b 0002 moveb %a3@(2),%d3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
5680e: 2a02 movel %d2,%d5
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
56810: e6ac lsrl %d3,%d4
56812: d8ab 0044 addl %a3@(68),%d4
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
56816: 4a81 tstl %d1
56818: 6706 beqs 56820 <fat_get_fat_cluster+0x68> <== NEVER TAKEN
5681a: e28d lsrl #1,%d5
5681c: da82 addl %d2,%d5
5681e: 600c bras 5682c <fat_get_fat_cluster+0x74>
56820: 0800 0001 btst #1,%d0 <== NOT EXECUTED
56824: 6704 beqs 5682a <fat_get_fat_cluster+0x72> <== NOT EXECUTED
56826: da85 addl %d5,%d5 <== NOT EXECUTED
56828: 6002 bras 5682c <fat_get_fat_cluster+0x74> <== NOT EXECUTED
5682a: e58d lsll #2,%d5 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
5682c: 2c0e movel %fp,%d6
5682e: 5986 subql #4,%d6
56830: 49f9 0005 04b0 lea 504b0 <fat_buf_access>,%a4
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
56836: 3e13 movew %a3@,%d7
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
56838: 2f06 movel %d6,%sp@-
5683a: 4878 0001 pea 1 <ADD>
5683e: 2f04 movel %d4,%sp@-
56840: 2f0b movel %a3,%sp@-
56842: 4e94 jsr %a4@
if (rc != RC_OK)
56844: 4fef 0010 lea %sp@(16),%sp
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
56848: 2600 movel %d0,%d3
if (rc != RC_OK)
5684a: 6600 00d8 bnew 56924 <fat_get_fat_cluster+0x16c>
return rc;
switch ( fs_info->vol.type )
5684e: 4280 clrl %d0
56850: 102b 000a moveb %a3@(10),%d0
56854: 7202 moveq #2,%d1
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
56856: 0287 0000 ffff andil #65535,%d7
5685c: 5387 subql #1,%d7
5685e: ca87 andl %d7,%d5
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
56860: b280 cmpl %d0,%d1
56862: 677a beqs 568de <fat_get_fat_cluster+0x126> <== NEVER TAKEN
56864: 123c 0004 moveb #4,%d1
56868: b280 cmpl %d0,%d1
5686a: 6700 0090 beqw 568fc <fat_get_fat_cluster+0x144>
5686e: 123c 0001 moveb #1,%d1
56872: b280 cmpl %d0,%d1
56874: 6600 009c bnew 56912 <fat_get_fat_cluster+0x15a>
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
56878: 206e fffc moveal %fp@(-4),%a0
5687c: 4281 clrl %d1
if ( ofs == (fs_info->vol.bps - 1) )
5687e: 4280 clrl %d0
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
56880: 2068 001e moveal %a0@(30),%a0
56884: 1230 5800 moveb %a0@(00000000,%d5:l),%d1
if ( ofs == (fs_info->vol.bps - 1) )
56888: 3013 movew %a3@,%d0
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
5688a: 2481 movel %d1,%a2@
if ( ofs == (fs_info->vol.bps - 1) )
5688c: 5380 subql #1,%d0
5688e: b085 cmpl %d5,%d0
56890: 662a bnes 568bc <fat_get_fat_cluster+0x104> <== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
56892: 2f06 movel %d6,%sp@- <== NOT EXECUTED
56894: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
56898: 2044 moveal %d4,%a0 <== NOT EXECUTED
5689a: 4868 0001 pea %a0@(1) <== NOT EXECUTED
5689e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
568a0: 4e94 jsr %a4@ <== NOT EXECUTED
&block0);
if (rc != RC_OK)
568a2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
568a6: 4a80 tstl %d0 <== NOT EXECUTED
568a8: 6678 bnes 56922 <fat_get_fat_cluster+0x16a> <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
568aa: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
568ae: 4280 clrl %d0 <== NOT EXECUTED
568b0: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
568b4: 1010 moveb %a0@,%d0 <== NOT EXECUTED
568b6: e188 lsll #8,%d0 <== NOT EXECUTED
568b8: 8192 orl %d0,%a2@ <== NOT EXECUTED
568ba: 600c bras 568c8 <fat_get_fat_cluster+0x110> <== NOT EXECUTED
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
568bc: 4280 clrl %d0
568be: 1030 5801 moveb %a0@(00000001,%d5:l),%d0
568c2: e188 lsll #8,%d0
568c4: 8081 orl %d1,%d0
568c6: 2480 movel %d0,%a2@
}
if ( FAT_CLUSTER_IS_ODD(cln) )
568c8: 0802 0000 btst #0,%d2
568cc: 6706 beqs 568d4 <fat_get_fat_cluster+0x11c>
*ret_val = (*ret_val) >> FAT12_SHIFT;
568ce: 2012 movel %a2@,%d0
568d0: e888 lsrl #4,%d0
568d2: 603a bras 5690e <fat_get_fat_cluster+0x156>
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
568d4: 203c 0000 0fff movel #4095,%d0
568da: c192 andl %d0,%a2@
568dc: 6046 bras 56924 <fat_get_fat_cluster+0x16c>
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
568de: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
568e2: 4281 clrl %d1 <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
568e4: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
568e8: 3230 5800 movew %a0@(00000000,%d5:l),%d1 <== NOT EXECUTED
static inline uint16_t m68k_swap_u16(
uint16_t value
)
{
return (((value & 0xff) << 8) | ((value >> 8) & 0xff));
568ec: 2001 movel %d1,%d0 <== NOT EXECUTED
568ee: e089 lsrl #8,%d1 <== NOT EXECUTED
568f0: e188 lsll #8,%d0 <== NOT EXECUTED
568f2: 0280 0000 ff00 andil #65280,%d0 <== NOT EXECUTED
568f8: 8081 orl %d1,%d0 <== NOT EXECUTED
568fa: 6012 bras 5690e <fat_get_fat_cluster+0x156> <== NOT EXECUTED
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
568fc: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
56900: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
*ret_val = CF_LE_L(*ret_val);
56904: 2f30 5800 movel %a0@(00000000,%d5:l),%sp@- <== NOT EXECUTED
56908: 4eba fe76 jsr %pc@(56780 <m68k_swap_u32>) <== NOT EXECUTED
5690c: 588f addql #4,%sp <== NOT EXECUTED
5690e: 2480 movel %d0,%a2@
break;
56910: 6012 bras 56924 <fat_get_fat_cluster+0x16c>
default:
rtems_set_errno_and_return_minus_one(EIO);
56912: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
56918: 76ff moveq #-1,%d3 <== NOT EXECUTED
5691a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5691c: 7005 moveq #5,%d0 <== NOT EXECUTED
5691e: 2080 movel %d0,%a0@ <== NOT EXECUTED
56920: 6002 bras 56924 <fat_get_fat_cluster+0x16c> <== NOT EXECUTED
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
56922: 2600 movel %d0,%d3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
56924: 2003 movel %d3,%d0
56926: 4cee 1cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a4
5692c: 4e5e unlk %fp <== NOT EXECUTED
00050a40 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
50a40: 4e56 ffec linkw %fp,#-20 <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
50a44: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
50a48: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
50a4c: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
50a50: 47f9 0004 6750 lea 46750 <realloc>,%a3 <== NOT EXECUTED
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
50a56: 606c bras 50ac4 <fat_get_unique_ino+0x84> <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
50a58: 222a 0066 movel %a2@(102),%d1 <== NOT EXECUTED
50a5c: 2401 movel %d1,%d2 <== NOT EXECUTED
50a5e: e68a lsrl #3,%d2 <== NOT EXECUTED
50a60: 7607 moveq #7,%d3 <== NOT EXECUTED
50a62: 206a 0062 moveal %a2@(98),%a0 <== NOT EXECUTED
50a66: d1c2 addal %d2,%a0 <== NOT EXECUTED
50a68: 1410 moveb %a0@,%d2 <== NOT EXECUTED
50a6a: c681 andl %d1,%d3 <== NOT EXECUTED
50a6c: 1802 moveb %d2,%d4 <== NOT EXECUTED
50a6e: 49c4 extbl %d4 <== NOT EXECUTED
50a70: 0704 btst %d3,%d4 <== NOT EXECUTED
50a72: 6612 bnes 50a86 <fat_get_unique_ino+0x46> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
50a74: 7001 moveq #1,%d0 <== NOT EXECUTED
50a76: e7a8 lsll %d3,%d0 <== NOT EXECUTED
50a78: 8082 orl %d2,%d0 <== NOT EXECUTED
50a7a: 1080 moveb %d0,%a0@ <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
50a7c: 202a 0066 movel %a2@(102),%d0 <== NOT EXECUTED
50a80: d0aa 006e addl %a2@(110),%d0 <== NOT EXECUTED
50a84: 6048 bras 50ace <fat_get_unique_ino+0x8e> <== NOT EXECUTED
}
fs_info->index++;
50a86: 5281 addql #1,%d1 <== NOT EXECUTED
50a88: 2541 0066 movel %d1,%a2@(102) <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
50a8c: b3c1 cmpal %d1,%a1 <== NOT EXECUTED
50a8e: 6204 bhis 50a94 <fat_get_unique_ino+0x54> <== NOT EXECUTED
fs_info->index = 0;
50a90: 42aa 0066 clrl %a2@(102) <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
50a94: 5280 addql #1,%d0 <== NOT EXECUTED
50a96: b3c0 cmpal %d0,%a1 <== NOT EXECUTED
50a98: 66be bnes 50a58 <fat_get_unique_ino+0x18> <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
50a9a: 223c 0fff ffff movel #268435455,%d1 <== NOT EXECUTED
50aa0: 92aa 006e subl %a2@(110),%d1 <== NOT EXECUTED
50aa4: d080 addl %d0,%d0 <== NOT EXECUTED
50aa6: b280 cmpl %d0,%d1 <== NOT EXECUTED
50aa8: 6322 blss 50acc <fat_get_unique_ino+0x8c> <== NOT EXECUTED
{
fs_info->uino_pool_size <<= 1;
50aaa: 2540 006a movel %d0,%a2@(106) <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
50aae: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50ab0: 2f2a 0062 movel %a2@(98),%sp@- <== NOT EXECUTED
50ab4: 4e93 jsr %a3@ <== NOT EXECUTED
if (fs_info->uino != NULL)
50ab6: 508f addql #8,%sp <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
50ab8: 2540 0062 movel %d0,%a2@(98) <== NOT EXECUTED
if (fs_info->uino != NULL)
50abc: 670e beqs 50acc <fat_get_unique_ino+0x8c> <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
50abe: 256a 006a 0066 movel %a2@(106),%a2@(102) <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
50ac4: 226a 006a moveal %a2@(106),%a1 <== NOT EXECUTED
50ac8: 4280 clrl %d0 <== NOT EXECUTED
50aca: 60ca bras 50a96 <fat_get_unique_ino+0x56> <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
50acc: 4280 clrl %d0 <== NOT EXECUTED
}
50ace: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3 <== NOT EXECUTED
50ad4: 4e5e unlk %fp <== NOT EXECUTED
00050988 <fat_init_clusters_chain>:
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
50988: 4280 clrl %d0
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
5098a: 4e56 ffe0 linkw %fp,#-32
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
5098e: 2d6e 000c fffc movel %fp@(12),%fp@(-4)
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
50994: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
50998: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
5099c: 246b 0034 moveal %a3@(52),%a2
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
509a0: 4878 0001 pea 1 <ADD>
509a4: 302a 0006 movew %a2@(6),%d0
509a8: 2f00 movel %d0,%sp@-
509aa: 4eb9 0004 4e3c jsr 44e3c <calloc>
if ( buf == NULL )
509b0: 508f addql #8,%sp
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
509b2: 2400 movel %d0,%d2
if ( buf == NULL )
509b4: 6654 bnes 50a0a <fat_init_clusters_chain+0x82> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
509b6: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
509bc: 2040 moveal %d0,%a0 <== NOT EXECUTED
509be: 7005 moveq #5,%d0 <== NOT EXECUTED
509c0: 2080 movel %d0,%a0@ <== NOT EXECUTED
509c2: 601c bras 509e0 <fat_init_clusters_chain+0x58> <== NOT EXECUTED
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
509c4: 2f02 movel %d2,%sp@-
509c6: 2f00 movel %d0,%sp@-
509c8: 2f0b movel %a3,%sp@-
509ca: 4e95 jsr %a5@
if ( ret == -1 )
509cc: 4fef 000c lea %sp@(12),%sp
509d0: 72ff moveq #-1,%d1
509d2: b280 cmpl %d0,%d1
509d4: 660e bnes 509e4 <fat_init_clusters_chain+0x5c> <== ALWAYS TAKEN
{
free(buf);
509d6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
509d8: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return -1;
509de: 588f addql #4,%sp <== NOT EXECUTED
509e0: 70ff moveq #-1,%d0 <== NOT EXECUTED
509e2: 6052 bras 50a36 <fat_init_clusters_chain+0xae> <== NOT EXECUTED
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
509e4: 2f03 movel %d3,%sp@-
509e6: 2f2e fffc movel %fp@(-4),%sp@-
509ea: 2f0b movel %a3,%sp@-
509ec: 4e94 jsr %a4@
if ( rc != RC_OK )
509ee: 4fef 000c lea %sp@(12),%sp
509f2: 4a80 tstl %d0
509f4: 6724 beqs 50a1a <fat_init_clusters_chain+0x92> <== ALWAYS TAKEN
{
free(buf);
509f6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
509f8: 2d40 fff8 movel %d0,%fp@(-8) <== NOT EXECUTED
509fc: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rc;
50a02: 202e fff8 movel %fp@(-8),%d0 <== NOT EXECUTED
50a06: 588f addql #4,%sp <== NOT EXECUTED
50a08: 602c bras 50a36 <fat_init_clusters_chain+0xae> <== NOT EXECUTED
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50a0a: 260e movel %fp,%d3
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
50a0c: 4bf9 0005 0942 lea 50942 <fat_cluster_write>,%a5
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
50a12: 5983 subql #4,%d3
50a14: 49f9 0005 67b8 lea 567b8 <fat_get_fat_cluster>,%a4
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
50a1a: 202e fffc movel %fp@(-4),%d0
50a1e: 2200 movel %d0,%d1
50a20: c2aa 000c andl %a2@(12),%d1
50a24: b2aa 0010 cmpl %a2@(16),%d1
50a28: 659a bcss 509c4 <fat_init_clusters_chain+0x3c>
free(buf);
return rc;
}
}
free(buf);
50a2a: 2f02 movel %d2,%sp@-
50a2c: 4eb9 0004 54d0 jsr 454d0 <free>
return rc;
50a32: 588f addql #4,%sp
50a34: 4280 clrl %d0
}
50a36: 4cee 3c0c ffe0 moveml %fp@(-32),%d2-%d3/%a2-%a5
50a3c: 4e5e unlk %fp <== NOT EXECUTED
00050cac <fat_init_volume_info>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
50cac: 4e56 ff64 linkw %fp,#-156
50cb0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
50cb4: 266e 0008 moveal %fp@(8),%a3
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
50cb8: 246b 0034 moveal %a3@(52),%a2
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
50cbc: 486e ffaa pea %fp@(-86)
50cc0: 2f2b 0070 movel %a3@(112),%sp@-
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
50cc4: 42ae fffc clrl %fp@(-4)
rc = stat(mt_entry->dev, &stat_buf);
50cc8: 4eb9 0004 6960 jsr 46960 <stat>
if (rc == -1)
50cce: 508f addql #8,%sp
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
50cd0: 2400 movel %d0,%d2
if (rc == -1)
50cd2: 70ff moveq #-1,%d0
50cd4: b082 cmpl %d2,%d0
50cd6: 6700 0756 beqw 5142e <fat_init_volume_info+0x782>
return rc;
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
50cda: 202e ffb6 movel %fp@(-74),%d0
50cde: 0280 0000 f000 andil #61440,%d0
50ce4: 0c80 0000 6000 cmpil #24576,%d0
50cea: 6710 beqs 50cfc <fat_init_volume_info+0x50> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOTTY);
50cec: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
50cf2: 7619 moveq #25,%d3 <== NOT EXECUTED
50cf4: 2040 moveal %d0,%a0 <== NOT EXECUTED
50cf6: 2083 movel %d3,%a0@ <== NOT EXECUTED
50cf8: 6000 072e braw 51428 <fat_init_volume_info+0x77c> <== NOT EXECUTED
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
50cfc: 2f2e ffc4 movel %fp@(-60),%sp@-
50d00: 2f2e ffc0 movel %fp@(-64),%sp@-
50d04: 4eb9 0004 44ba jsr 444ba <rtems_disk_obtain>
if (vol->dd == NULL)
50d0a: 508f addql #8,%sp
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
rtems_set_errno_and_return_minus_one(ENOTTY);
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
50d0c: 2540 0052 movel %d0,%a2@(82)
if (vol->dd == NULL)
50d10: 6610 bnes 50d22 <fat_init_volume_info+0x76> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
50d12: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
50d18: 7405 moveq #5,%d2 <== NOT EXECUTED
50d1a: 2240 moveal %d0,%a1 <== NOT EXECUTED
50d1c: 2282 movel %d2,%a1@ <== NOT EXECUTED
50d1e: 6000 0708 braw 51428 <fat_init_volume_info+0x77c> <== NOT EXECUTED
vol->dev = stat_buf.st_rdev;
50d22: 202e ffc0 movel %fp@(-64),%d0
50d26: 222e ffc4 movel %fp@(-60),%d1
50d2a: 2540 004a movel %d0,%a2@(74)
50d2e: 2541 004e movel %d1,%a2@(78)
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
50d32: 486e fffc pea %fp@(-4)
50d36: 42a7 clrl %sp@-
50d38: 2f01 movel %d1,%sp@-
50d3a: 2f00 movel %d0,%sp@-
50d3c: 4eb9 0004 eefc jsr 4eefc <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
50d42: 4fef 0010 lea %sp@(16),%sp
50d46: 4a80 tstl %d0
50d48: 6600 00d4 bnew 50e1e <fat_init_volume_info+0x172>
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
50d4c: 206e fffc moveal %fp@(-4),%a0
50d50: 2268 001e moveal %a0@(30),%a1
50d54: 1229 000b moveb %a1@(11),%d1
50d58: 1829 000e moveb %a1@(14),%d4
50d5c: 1029 000f moveb %a1@(15),%d0
50d60: 1d41 ff95 moveb %d1,%fp@(-107)
50d64: 1229 0011 moveb %a1@(17),%d1
50d68: 3844 moveaw %d4,%a4
50d6a: 1d41 ff9c moveb %d1,%fp@(-100)
50d6e: 1229 0012 moveb %a1@(18),%d1
50d72: 1c29 000c moveb %a1@(12),%d6
50d76: 1d41 ff9b moveb %d1,%fp@(-101)
50d7a: 1229 0013 moveb %a1@(19),%d1
50d7e: 1429 000d moveb %a1@(13),%d2
50d82: 1d41 ff9a moveb %d1,%fp@(-102)
50d86: 1229 0014 moveb %a1@(20),%d1
50d8a: 1829 0010 moveb %a1@(16),%d4
50d8e: 1d41 ff99 moveb %d1,%fp@(-103)
50d92: 1229 0016 moveb %a1@(22),%d1
50d96: 3a40 moveaw %d0,%a5
50d98: 1d41 ff97 moveb %d1,%fp@(-105)
50d9c: 1229 0017 moveb %a1@(23),%d1
50da0: 1d41 ff96 moveb %d1,%fp@(-106)
50da4: 1229 0020 moveb %a1@(32),%d1
50da8: 1d41 ff9f moveb %d1,%fp@(-97)
50dac: 1229 0021 moveb %a1@(33),%d1
50db0: 1d41 ff9e moveb %d1,%fp@(-98)
50db4: 1229 0022 moveb %a1@(34),%d1
50db8: 1d41 ff9d moveb %d1,%fp@(-99)
50dbc: 1229 0023 moveb %a1@(35),%d1
50dc0: 1d41 ff8f moveb %d1,%fp@(-113)
50dc4: 1229 0024 moveb %a1@(36),%d1
50dc8: 1d41 ffa1 moveb %d1,%fp@(-95)
50dcc: 1229 0025 moveb %a1@(37),%d1
50dd0: 1d41 ffa0 moveb %d1,%fp@(-96)
50dd4: 1229 0026 moveb %a1@(38),%d1
50dd8: 1d41 ffa5 moveb %d1,%fp@(-91)
50ddc: 1229 002c moveb %a1@(44),%d1
50de0: 1e29 0027 moveb %a1@(39),%d7
50de4: 1629 0028 moveb %a1@(40),%d3
50de8: 1d41 ffa4 moveb %d1,%fp@(-92)
50dec: 1229 002d moveb %a1@(45),%d1
50df0: 1a29 002f moveb %a1@(47),%d5
50df4: 1d41 ffa3 moveb %d1,%fp@(-93)
50df8: 1229 002e moveb %a1@(46),%d1
50dfc: 1d41 ffa2 moveb %d1,%fp@(-94)
50e00: 1229 0030 moveb %a1@(48),%d1
50e04: 1d41 ffa7 moveb %d1,%fp@(-89)
50e08: 1229 0031 moveb %a1@(49),%d1
sc = rtems_bdbuf_release( block);
50e0c: 2f08 movel %a0,%sp@-
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
50e0e: 1d41 ffa6 moveb %d1,%fp@(-90)
sc = rtems_bdbuf_release( block);
50e12: 4eb9 0004 f116 jsr 4f116 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
50e18: 588f addql #4,%sp
50e1a: 4a80 tstl %d0
50e1c: 671a beqs 50e38 <fat_init_volume_info+0x18c> <== ALWAYS TAKEN
{
rtems_disk_release(vol->dd);
50e1e: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
50e22: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
50e28: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
50e2e: 7205 moveq #5,%d1 <== NOT EXECUTED
50e30: 2040 moveal %d0,%a0 <== NOT EXECUTED
50e32: 2081 movel %d1,%a0@ <== NOT EXECUTED
50e34: 6000 04fe braw 51334 <fat_init_volume_info+0x688> <== NOT EXECUTED
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
50e38: 4280 clrl %d0
50e3a: 1006 moveb %d6,%d0
50e3c: 4281 clrl %d1
50e3e: 122e ff95 moveb %fp@(-107),%d1
50e42: e188 lsll #8,%d0
50e44: 8081 orl %d1,%d0
if ( (vol->bps != 512) &&
50e46: 3200 movew %d0,%d1
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
50e48: 3480 movew %d0,%a2@
50e4a: 3040 moveaw %d0,%a0
if ( (vol->bps != 512) &&
50e4c: 0c81 0000 0200 cmpil #512,%d1
50e52: 6732 beqs 50e86 <fat_init_volume_info+0x1da> <== ALWAYS TAKEN
50e54: 0c81 0000 0400 cmpil #1024,%d1 <== NOT EXECUTED
50e5a: 672a beqs 50e86 <fat_init_volume_info+0x1da> <== NOT EXECUTED
(vol->bps != 1024) &&
50e5c: 0c81 0000 0800 cmpil #2048,%d1 <== NOT EXECUTED
50e62: 6722 beqs 50e86 <fat_init_volume_info+0x1da> <== NOT EXECUTED
(vol->bps != 2048) &&
50e64: 0c81 0000 1000 cmpil #4096,%d1 <== NOT EXECUTED
50e6a: 671a beqs 50e86 <fat_init_volume_info+0x1da> <== NOT EXECUTED
(vol->bps != 4096))
{
rtems_disk_release(vol->dd);
50e6c: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
50e70: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
50e76: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
50e7c: 2240 moveal %d0,%a1 <== NOT EXECUTED
50e7e: 7016 moveq #22,%d0 <== NOT EXECUTED
50e80: 2280 movel %d0,%a1@ <== NOT EXECUTED
50e82: 6000 04b0 braw 51334 <fat_init_volume_info+0x688> <== NOT EXECUTED
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
50e86: 7c09 moveq #9,%d6
50e88: eca9 lsrl %d6,%d1
50e8a: 4200 clrb %d0
50e8c: 1c2e ff8f moveb %fp@(-113),%d6
50e90: 1540 0003 moveb %d0,%a2@(3)
50e94: 600c bras 50ea2 <fat_init_volume_info+0x1f6>
i >>= 1, vol->sec_mul++);
50e96: e281 asrl #1,%d1 <== NOT EXECUTED
50e98: 102a 0003 moveb %a2@(3),%d0 <== NOT EXECUTED
50e9c: 5280 addql #1,%d0 <== NOT EXECUTED
50e9e: 1540 0003 moveb %d0,%a2@(3) <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
50ea2: 0801 0000 btst #0,%d1
50ea6: 67ee beqs 50e96 <fat_init_volume_info+0x1ea> <== NEVER TAKEN
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
50ea8: 4281 clrl %d1
50eaa: 3208 movew %a0,%d1
50eac: 4200 clrb %d0
50eae: 1d46 ff8f moveb %d6,%fp@(-113)
50eb2: 2d41 ff90 movel %d1,%fp@(-112)
50eb6: 2241 moveal %d1,%a1
50eb8: 1540 0002 moveb %d0,%a2@(2)
50ebc: 6010 bras 50ece <fat_init_volume_info+0x222>
i >>= 1, vol->sec_log2++);
50ebe: e281 asrl #1,%d1
50ec0: 102a 0002 moveb %a2@(2),%d0
50ec4: 3040 moveaw %d0,%a0
50ec6: 5288 addql #1,%a0
50ec8: 3008 movew %a0,%d0
50eca: 1540 0002 moveb %d0,%a2@(2)
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
50ece: 0801 0000 btst #0,%d1
50ed2: 67ea beqs 50ebe <fat_init_volume_info+0x212>
50ed4: 2d49 ff90 movel %a1,%fp@(-112)
50ed8: 1d46 ff8f moveb %d6,%fp@(-113)
i >>= 1, vol->sec_log2++);
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
50edc: 1542 0004 moveb %d2,%a2@(4)
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
50ee0: 6700 0258 beqw 5113a <fat_init_volume_info+0x48e>
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
50ee4: 4281 clrl %d1
50ee6: 1202 moveb %d2,%d1
50ee8: 4200 clrb %d0
50eea: 226e ff90 moveal %fp@(-112),%a1
50eee: 1540 0005 moveb %d0,%a2@(5)
50ef2: 1c2e ff8f moveb %fp@(-113),%d6
50ef6: 6010 bras 50f08 <fat_init_volume_info+0x25c>
i >>= 1, vol->spc_log2++);
50ef8: e281 asrl #1,%d1
50efa: 102a 0005 moveb %a2@(5),%d0
50efe: 3040 moveaw %d0,%a0
50f00: 5288 addql #1,%a0
50f02: 3008 movew %a0,%d0
50f04: 1540 0005 moveb %d0,%a2@(5)
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
50f08: 0801 0000 btst #0,%d1
50f0c: 67ea beqs 50ef8 <fat_init_volume_info+0x24c>
i >>= 1, vol->spc_log2++);
/*
* "bytes per cluster" value greater than 32K is invalid
*/
if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
50f0e: 4281 clrl %d1
50f10: 122a 0005 moveb %a2@(5),%d1
50f14: 4280 clrl %d0
50f16: 1d46 ff8f moveb %d6,%fp@(-113)
50f1a: 2c09 movel %a1,%d6
50f1c: e3ae lsll %d1,%d6
50f1e: 2d49 ff90 movel %a1,%fp@(-112)
50f22: 3006 movew %d6,%d0
50f24: 3546 0006 movew %d6,%a2@(6)
50f28: 2040 moveal %d0,%a0
50f2a: b1fc 0000 8000 cmpal #32768,%a0
50f30: 6200 0208 bhiw 5113a <fat_init_volume_info+0x48e>
50f34: 226e ff90 moveal %fp@(-112),%a1
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
50f38: 2208 movel %a0,%d1
50f3a: 4200 clrb %d0
50f3c: 1c2e ff8f moveb %fp@(-113),%d6
50f40: 1540 0008 moveb %d0,%a2@(8)
50f44: 6010 bras 50f56 <fat_init_volume_info+0x2aa>
i >>= 1, vol->bpc_log2++);
50f46: e281 asrl #1,%d1
50f48: 102a 0008 moveb %a2@(8),%d0
50f4c: 3040 moveaw %d0,%a0
50f4e: 5288 addql #1,%a0
50f50: 3008 movew %a0,%d0
50f52: 1540 0008 moveb %d0,%a2@(8)
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
50f56: 0801 0000 btst #0,%d1
50f5a: 67ea beqs 50f46 <fat_init_volume_info+0x29a>
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
50f5c: 4280 clrl %d0
50f5e: 102e ff9b moveb %fp@(-101),%d0
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
50f62: 320d movew %a5,%d1
50f64: 1d46 ff8f moveb %d6,%fp@(-113)
50f68: 3c0c movew %a4,%d6
50f6a: 0281 0000 00ff andil #255,%d1
50f70: 2d49 ff90 movel %a1,%fp@(-112)
50f74: 0286 0000 00ff andil #255,%d6
50f7a: e189 lsll #8,%d1
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
50f7c: e188 lsll #8,%d0
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
50f7e: 8286 orl %d6,%d1
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
50f80: 1544 0009 moveb %d4,%a2@(9)
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
50f84: 3041 moveaw %d1,%a0
50f86: 3541 0014 movew %d1,%a2@(20)
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
50f8a: 4281 clrl %d1
50f8c: 122e ff9c moveb %fp@(-100),%d1
50f90: 8081 orl %d1,%d0
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
50f92: 2200 movel %d0,%d1
50f94: eb89 lsll #5,%d1
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
50f96: 3540 001e movew %d0,%a2@(30)
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
50f9a: 49f1 18ff lea %a1@(ffffffff,%d1:l),%a4
50f9e: 2209 movel %a1,%d1
50fa0: 200c movel %a4,%d0
50fa2: 4c41 0800 remsl %d1,%d0,%d0
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
50fa6: 4286 clrl %d6
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
50fa8: 2840 moveal %d0,%a4
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
50faa: 220c movel %a4,%d1
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
50fac: 1c2e ff97 moveb %fp@(-105),%d6
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
50fb0: 2540 0020 movel %d0,%a2@(32)
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
50fb4: 4280 clrl %d0
50fb6: 102a 0002 moveb %a2@(2),%d0
50fba: e1a9 lsll %d0,%d1
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
50fbc: 4280 clrl %d0
50fbe: 102e ff96 moveb %fp@(-106),%d0
50fc2: e188 lsll #8,%d0
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
50fc4: 2541 0024 movel %d1,%a2@(36)
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
50fc8: 8086 orl %d6,%d0
50fca: 4a40 tstw %d0
50fcc: 6708 beqs 50fd6 <fat_init_volume_info+0x32a> <== NEVER TAKEN
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
50fce: 0280 0000 ffff andil #65535,%d0
50fd4: 6022 bras 50ff8 <fat_init_volume_info+0x34c>
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
50fd6: 4280 clrl %d0 <== NOT EXECUTED
50fd8: 4281 clrl %d1 <== NOT EXECUTED
50fda: 102e ffa0 moveb %fp@(-96),%d0 <== NOT EXECUTED
50fde: 122e ffa5 moveb %fp@(-91),%d1 <== NOT EXECUTED
50fe2: 4286 clrl %d6 <== NOT EXECUTED
50fe4: 1c2e ffa1 moveb %fp@(-95),%d6 <== NOT EXECUTED
50fe8: 4841 swap %d1 <== NOT EXECUTED
50fea: 4241 clrw %d1 <== NOT EXECUTED
50fec: e188 lsll #8,%d0 <== NOT EXECUTED
50fee: 8081 orl %d1,%d0 <== NOT EXECUTED
50ff0: 7218 moveq #24,%d1 <== NOT EXECUTED
50ff2: 8086 orl %d6,%d0 <== NOT EXECUTED
50ff4: e3af lsll %d1,%d7 <== NOT EXECUTED
50ff6: 8087 orl %d7,%d0 <== NOT EXECUTED
50ff8: 2540 0016 movel %d0,%a2@(22)
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
50ffc: 4280 clrl %d0
50ffe: 220c movel %a4,%d1
51000: 0284 0000 00ff andil #255,%d4
51006: 3008 movew %a0,%d0
51008: 41ea 0016 lea %a2@(22),%a0
5100c: 4c10 4800 mulsl %a0@,%d4
51010: d880 addl %d0,%d4
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
51012: 4280 clrl %d0
51014: 102e ff99 moveb %fp@(-103),%d0
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
51018: d284 addl %d4,%d1
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
5101a: 2544 001a movel %d4,%a2@(26)
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
5101e: 4284 clrl %d4
51020: 182e ff9a moveb %fp@(-102),%d4
51024: e188 lsll #8,%d0
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
51026: 2541 002c movel %d1,%a2@(44)
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
5102a: 8084 orl %d4,%d0
5102c: 4a40 tstw %d0
5102e: 6708 beqs 51038 <fat_init_volume_info+0x38c> <== NEVER TAKEN
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
51030: 0280 0000 ffff andil #65535,%d0
51036: 6026 bras 5105e <fat_init_volume_info+0x3b2>
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
51038: 4280 clrl %d0 <== NOT EXECUTED
5103a: 4284 clrl %d4 <== NOT EXECUTED
5103c: 102e ff9e moveb %fp@(-98),%d0 <== NOT EXECUTED
51040: 182e ff9d moveb %fp@(-99),%d4 <== NOT EXECUTED
51044: e188 lsll #8,%d0 <== NOT EXECUTED
51046: 4844 swap %d4 <== NOT EXECUTED
51048: 4244 clrw %d4 <== NOT EXECUTED
5104a: 1c2e ff8f moveb %fp@(-113),%d6 <== NOT EXECUTED
5104e: 8084 orl %d4,%d0 <== NOT EXECUTED
51050: 4284 clrl %d4 <== NOT EXECUTED
51052: 182e ff9f moveb %fp@(-97),%d4 <== NOT EXECUTED
51056: 8084 orl %d4,%d0 <== NOT EXECUTED
51058: 7818 moveq #24,%d4 <== NOT EXECUTED
5105a: e9ae lsll %d4,%d6 <== NOT EXECUTED
5105c: 8086 orl %d6,%d0 <== NOT EXECUTED
5105e: 2540 0028 movel %d0,%a2@(40)
data_secs = vol->tot_secs - vol->data_fsec;
51062: 2c2a 0028 movel %a2@(40),%d6
51066: 9c81 subl %d1,%d6
51068: 2206 movel %d6,%d1
vol->data_cls = data_secs / vol->spc;
5106a: 0282 0000 00ff andil #255,%d2
51070: 4c42 1001 remul %d2,%d1,%d1
51074: 2541 0030 movel %d1,%a2@(48)
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
51078: 0c81 0000 0ff4 cmpil #4084,%d1
5107e: 6218 bhis 51098 <fat_init_volume_info+0x3ec> <== NEVER TAKEN
{
vol->type = FAT_FAT12;
vol->mask = FAT_FAT12_MASK;
51080: 223c 0000 0fff movel #4095,%d1
vol->eoc_val = FAT_FAT12_EOC;
51086: 243c 0000 0ff8 movel #4088,%d2
vol->data_cls = data_secs / vol->spc;
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
5108c: 7001 moveq #1,%d0
vol->mask = FAT_FAT12_MASK;
5108e: 2541 000c movel %d1,%a2@(12)
vol->data_cls = data_secs / vol->spc;
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
51092: 1540 000a moveb %d0,%a2@(10)
51096: 603a bras 510d2 <fat_init_volume_info+0x426>
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
51098: 0c81 0000 fff4 cmpil #65524,%d1 <== NOT EXECUTED
5109e: 621c bhis 510bc <fat_init_volume_info+0x410> <== NOT EXECUTED
{
vol->type = FAT_FAT16;
vol->mask = FAT_FAT16_MASK;
510a0: 2c3c 0000 ffff movel #65535,%d6 <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
510a6: 207c 0000 fff8 moveal #65528,%a0 <== NOT EXECUTED
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
510ac: 7802 moveq #2,%d4 <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
510ae: 2546 000c movel %d6,%a2@(12) <== NOT EXECUTED
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
510b2: 1544 000a moveb %d4,%a2@(10) <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
510b6: 2548 0010 movel %a0,%a2@(16) <== NOT EXECUTED
510ba: 601a bras 510d6 <fat_init_volume_info+0x42a> <== NOT EXECUTED
}
else
{
vol->type = FAT_FAT32;
510bc: 7004 moveq #4,%d0 <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
510be: 223c 0fff ffff movel #268435455,%d1 <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
510c4: 1540 000a moveb %d0,%a2@(10) <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
510c8: 2541 000c movel %d1,%a2@(12) <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
510cc: 243c 0fff fff8 movel #268435448,%d2 <== NOT EXECUTED
510d2: 2542 0010 movel %d2,%a2@(16)
}
}
if (vol->type == FAT_FAT32)
510d6: 4280 clrl %d0
510d8: 102a 000a moveb %a2@(10),%d0
510dc: 7804 moveq #4,%d4
510de: b880 cmpl %d0,%d4
510e0: 6600 01ac bnew 5128e <fat_init_volume_info+0x5e2>
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
510e4: 4280 clrl %d0 <== NOT EXECUTED
510e6: 4281 clrl %d1 <== NOT EXECUTED
510e8: 102e ffa3 moveb %fp@(-93),%d0 <== NOT EXECUTED
510ec: 122e ffa2 moveb %fp@(-94),%d1 <== NOT EXECUTED
510f0: 7c18 moveq #24,%d6 <== NOT EXECUTED
510f2: 4841 swap %d1 <== NOT EXECUTED
510f4: 4241 clrw %d1 <== NOT EXECUTED
510f6: e188 lsll #8,%d0 <== NOT EXECUTED
510f8: edad lsll %d6,%d5 <== NOT EXECUTED
510fa: 8081 orl %d1,%d0 <== NOT EXECUTED
510fc: 4281 clrl %d1 <== NOT EXECUTED
510fe: 122e ffa4 moveb %fp@(-92),%d1 <== NOT EXECUTED
51102: 8081 orl %d1,%d0 <== NOT EXECUTED
51104: 8085 orl %d5,%d0 <== NOT EXECUTED
51106: 2540 0034 movel %d0,%a2@(52) <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
5110a: 7080 moveq #-128,%d0 <== NOT EXECUTED
5110c: c083 andl %d3,%d0 <== NOT EXECUTED
5110e: 1540 0042 moveb %d0,%a2@(66) <== NOT EXECUTED
if (vol->mirror)
51112: 670a beqs 5111e <fat_init_volume_info+0x472> <== NOT EXECUTED
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
51114: 700f moveq #15,%d0 <== NOT EXECUTED
51116: c680 andl %d0,%d3 <== NOT EXECUTED
51118: 1543 0048 moveb %d3,%a2@(72) <== NOT EXECUTED
5111c: 6006 bras 51124 <fat_init_volume_info+0x478> <== NOT EXECUTED
else
vol->afat = 0;
5111e: 4201 clrb %d1 <== NOT EXECUTED
51120: 1541 0048 moveb %d1,%a2@(72) <== NOT EXECUTED
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
51124: 4280 clrl %d0 <== NOT EXECUTED
51126: 102e ffa6 moveb %fp@(-90),%d0 <== NOT EXECUTED
5112a: 4281 clrl %d1 <== NOT EXECUTED
5112c: 122e ffa7 moveb %fp@(-89),%d1 <== NOT EXECUTED
51130: e188 lsll #8,%d0 <== NOT EXECUTED
51132: 8081 orl %d1,%d0 <== NOT EXECUTED
51134: 3540 0038 movew %d0,%a2@(56) <== NOT EXECUTED
if( vol->info_sec == 0 )
51138: 661a bnes 51154 <fat_init_volume_info+0x4a8> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
5113a: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
5113e: 7e16 moveq #22,%d7 <== NOT EXECUTED
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
if( vol->info_sec == 0 )
{
rtems_disk_release(vol->dd);
51140: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
51146: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
5114c: 2040 moveal %d0,%a0 <== NOT EXECUTED
5114e: 2087 movel %d7,%a0@ <== NOT EXECUTED
51150: 6000 01e2 braw 51334 <fat_init_volume_info+0x688> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , 0,
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
51154: 49ee fff0 lea %fp@(-16),%a4 <== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , 0,
51158: 4bf9 0005 07c2 lea 507c2 <_fat_block_read>,%a5 <== NOT EXECUTED
5115e: 2f0c movel %a4,%sp@- <== NOT EXECUTED
51160: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
51164: 42a7 clrl %sp@- <== NOT EXECUTED
51166: 3f00 movew %d0,%sp@- <== NOT EXECUTED
51168: 4267 clrw %sp@- <== NOT EXECUTED
5116a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5116c: 4e95 jsr %a5@ <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
5116e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
51172: 4a80 tstl %d0 <== NOT EXECUTED
51174: 6c0e bges 51184 <fat_init_volume_info+0x4d8> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
51176: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
5117a: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
51180: 6000 01b2 braw 51334 <fat_init_volume_info+0x688> <== NOT EXECUTED
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
51184: 4280 clrl %d0 <== NOT EXECUTED
51186: 4281 clrl %d1 <== NOT EXECUTED
51188: 102c 0001 moveb %a4@(1),%d0 <== NOT EXECUTED
5118c: 122c 0002 moveb %a4@(2),%d1 <== NOT EXECUTED
51190: 7418 moveq #24,%d2 <== NOT EXECUTED
51192: 4841 swap %d1 <== NOT EXECUTED
51194: 4241 clrw %d1 <== NOT EXECUTED
51196: e188 lsll #8,%d0 <== NOT EXECUTED
51198: 8081 orl %d1,%d0 <== NOT EXECUTED
5119a: 4281 clrl %d1 <== NOT EXECUTED
5119c: 1214 moveb %a4@,%d1 <== NOT EXECUTED
5119e: 8081 orl %d1,%d0 <== NOT EXECUTED
511a0: 122c 0003 moveb %a4@(3),%d1 <== NOT EXECUTED
511a4: e5a9 lsll %d2,%d1 <== NOT EXECUTED
511a6: 8081 orl %d1,%d0 <== NOT EXECUTED
511a8: 0c80 4161 5252 cmpil #1096897106,%d0 <== NOT EXECUTED
511ae: 6724 beqs 511d4 <fat_init_volume_info+0x528> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
511b0: 2f2b 0034 movel %a3@(52),%sp@- <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
511b4: 7c16 moveq #22,%d6 <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
511b6: 4eb9 0005 0690 jsr 50690 <fat_buf_release> <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
511bc: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
511c0: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
511c6: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
511cc: 2040 moveal %d0,%a0 <== NOT EXECUTED
511ce: 2086 movel %d6,%a0@ <== NOT EXECUTED
511d0: 6000 01de braw 513b0 <fat_init_volume_info+0x704> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
511d4: 2f0c movel %a4,%sp@- <== NOT EXECUTED
511d6: 4878 000c pea c <OPER1> <== NOT EXECUTED
511da: 4280 clrl %d0 <== NOT EXECUTED
511dc: 4878 01e4 pea 1e4 <DBL_MANT_DIG+0x1af> <== NOT EXECUTED
511e0: 302a 0038 movew %a2@(56),%d0 <== NOT EXECUTED
511e4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
511e6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
511e8: 4e95 jsr %a5@ <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
511ea: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
511ee: 4a80 tstl %d0 <== NOT EXECUTED
511f0: 6c18 bges 5120a <fat_init_volume_info+0x55e> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
511f2: 2f2b 0034 movel %a3@(52),%sp@- <== NOT EXECUTED
511f6: 4eb9 0005 0690 jsr 50690 <fat_buf_release> <== NOT EXECUTED
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
511fc: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
51200: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
51206: 6000 01a8 braw 513b0 <fat_init_volume_info+0x704> <== NOT EXECUTED
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
5120a: 4280 clrl %d0 <== NOT EXECUTED
5120c: 4281 clrl %d1 <== NOT EXECUTED
5120e: 102c 0005 moveb %a4@(5),%d0 <== NOT EXECUTED
51212: 122c 0006 moveb %a4@(6),%d1 <== NOT EXECUTED
51216: 7418 moveq #24,%d2 <== NOT EXECUTED
51218: 4841 swap %d1 <== NOT EXECUTED
5121a: 4241 clrw %d1 <== NOT EXECUTED
5121c: e188 lsll #8,%d0 <== NOT EXECUTED
5121e: 8081 orl %d1,%d0 <== NOT EXECUTED
51220: 4281 clrl %d1 <== NOT EXECUTED
51222: 122c 0004 moveb %a4@(4),%d1 <== NOT EXECUTED
51226: 8081 orl %d1,%d0 <== NOT EXECUTED
51228: 122c 0007 moveb %a4@(7),%d1 <== NOT EXECUTED
5122c: e5a9 lsll %d2,%d1 <== NOT EXECUTED
5122e: 8081 orl %d1,%d0 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
51230: 4281 clrl %d1 <== NOT EXECUTED
51232: 122c 000a moveb %a4@(10),%d1 <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
51236: 2540 003a movel %d0,%a2@(58) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
5123a: 4280 clrl %d0 <== NOT EXECUTED
5123c: 102c 0009 moveb %a4@(9),%d0 <== NOT EXECUTED
51240: 4841 swap %d1 <== NOT EXECUTED
51242: 4241 clrw %d1 <== NOT EXECUTED
51244: e188 lsll #8,%d0 <== NOT EXECUTED
51246: 8081 orl %d1,%d0 <== NOT EXECUTED
51248: 4281 clrl %d1 <== NOT EXECUTED
5124a: 122c 0008 moveb %a4@(8),%d1 <== NOT EXECUTED
5124e: 8081 orl %d1,%d0 <== NOT EXECUTED
51250: 122c 000b moveb %a4@(11),%d1 <== NOT EXECUTED
51254: e5a9 lsll %d2,%d1 <== NOT EXECUTED
51256: 8081 orl %d1,%d0 <== NOT EXECUTED
51258: 2540 003e movel %d0,%a2@(62) <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
5125c: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
51260: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
51264: 2f0b movel %a3,%sp@- <== NOT EXECUTED
51266: 4eb9 0005 0b26 jsr 50b26 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
5126c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
51270: 2400 movel %d0,%d2 <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
51272: 6732 beqs 512a6 <fat_init_volume_info+0x5fa> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
51274: 2f2b 0034 movel %a3@(52),%sp@- <== NOT EXECUTED
51278: 4eb9 0005 0690 jsr 50690 <fat_buf_release> <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
0xFFFFFFFF);
if ( rc != RC_OK )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
5127e: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
51282: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
return rc;
51288: 508f addql #8,%sp <== NOT EXECUTED
5128a: 6000 01a2 braw 5142e <fat_init_volume_info+0x782> <== NOT EXECUTED
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = 0xFFFFFFFF;
5128e: 7cff moveq #-1,%d6
}
}
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
51290: 4204 clrb %d4
}
}
}
else
{
vol->rdir_cl = 0;
51292: 42aa 0034 clrl %a2@(52)
vol->mirror = 0;
51296: 1544 0042 moveb %d4,%a2@(66)
vol->afat = 0;
5129a: 1544 0048 moveb %d4,%a2@(72)
vol->free_cls = 0xFFFFFFFF;
5129e: 2546 003a movel %d6,%a2@(58)
vol->next_cl = 0xFFFFFFFF;
512a2: 2546 003e movel %d6,%a2@(62)
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
512a6: 2f2b 0034 movel %a3@(52),%sp@-
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
512aa: 47f9 0004 4e3c lea 44e3c <calloc>,%a3
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
512b0: 4eb9 0005 0690 jsr 50690 <fat_buf_release>
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
512b6: 4280 clrl %d0
512b8: 102a 0048 moveb %a2@(72),%d0
512bc: 41ea 0016 lea %a2@(22),%a0
512c0: 4c10 0800 mulsl %a0@,%d0
512c4: 4281 clrl %d1
512c6: 322a 0014 movew %a2@(20),%d1
512ca: d081 addl %d1,%d0
512cc: 2540 0044 movel %d0,%a2@(68)
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
512d0: 4878 000c pea c <OPER1>
512d4: 4878 0002 pea 2 <DOUBLE_FLOAT>
512d8: 4e93 jsr %a3@
if ( fs_info->vhash == NULL )
512da: 4fef 000c lea %sp@(12),%sp
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
512de: 2040 moveal %d0,%a0
512e0: 2540 005a movel %d0,%a2@(90)
if ( fs_info->vhash == NULL )
512e4: 6738 beqs 5131e <fat_init_volume_info+0x672> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
512e6: 2240 moveal %d0,%a1
512e8: 5889 addql #4,%a1
512ea: 2089 movel %a1,%a0@
512ec: 43e8 0010 lea %a0@(16),%a1
512f0: 2149 000c movel %a1,%a0@(12)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
512f4: 43e8 000c lea %a0@(12),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
512f8: 42a8 0004 clrl %a0@(4)
tail->previous = head;
512fc: 2140 0008 movel %d0,%a0@(8)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
51300: 42a8 0010 clrl %a0@(16)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
51304: 2149 0014 movel %a1,%a0@(20)
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
51308: 4878 000c pea c <OPER1>
5130c: 4878 0002 pea 2 <DOUBLE_FLOAT>
51310: 4e93 jsr %a3@
if ( fs_info->rhash == NULL )
51312: 508f addql #8,%sp
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
51314: 2040 moveal %d0,%a0
51316: 2540 005e movel %d0,%a2@(94)
if ( fs_info->rhash == NULL )
5131a: 661e bnes 5133a <fat_init_volume_info+0x68e> <== ALWAYS TAKEN
5131c: 6072 bras 51390 <fat_init_volume_info+0x6e4> <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
rtems_disk_release(vol->dd);
5131e: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
51322: 7a0c moveq #12,%d5 <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
rtems_disk_release(vol->dd);
51324: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
5132a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
51330: 2040 moveal %d0,%a0 <== NOT EXECUTED
51332: 2085 movel %d5,%a0@ <== NOT EXECUTED
51334: 588f addql #4,%sp <== NOT EXECUTED
51336: 6000 00f0 braw 51428 <fat_init_volume_info+0x77c> <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
5133a: 2240 moveal %d0,%a1
5133c: 5889 addql #4,%a1
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
5133e: 4281 clrl %d1
51340: 2089 movel %a1,%a0@
51342: 43e8 0010 lea %a0@(16),%a1
51346: 2149 000c movel %a1,%a0@(12)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
5134a: 43e8 000c lea %a0@(12),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
5134e: 2140 0008 movel %d0,%a0@(8)
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
51352: 203c 0000 0100 movel #256,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
51358: 42a8 0004 clrl %a0@(4)
5135c: 42a8 0010 clrl %a0@(16)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
51360: 2149 0014 movel %a1,%a0@(20)
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
51364: 122a 0003 moveb %a2@(3),%d1
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
51368: 2540 006a movel %d0,%a2@(106)
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
5136c: 202a 0028 movel %a2@(40),%d0
51370: e3a8 lsll %d1,%d0
fs_info->index = 0;
51372: 42aa 0066 clrl %a2@(102)
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
51376: e988 lsll #4,%d0
51378: 2540 006e movel %d0,%a2@(110)
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
5137c: 4878 0001 pea 1 <ADD>
51380: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
51384: 4e93 jsr %a3@
if ( fs_info->uino == NULL )
51386: 508f addql #8,%sp
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
51388: 2540 0062 movel %d0,%a2@(98)
if ( fs_info->uino == NULL )
5138c: 6654 bnes 513e2 <fat_init_volume_info+0x736> <== ALWAYS TAKEN
5138e: 6024 bras 513b4 <fat_init_volume_info+0x708> <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->rhash == NULL )
{
rtems_disk_release(vol->dd);
51390: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
free(fs_info->vhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
51394: 780c moveq #12,%d4 <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->rhash == NULL )
{
rtems_disk_release(vol->dd);
51396: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
5139c: 2f2a 005a movel %a2@(90),%sp@- <== NOT EXECUTED
513a0: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
513a6: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
513ac: 2040 moveal %d0,%a0 <== NOT EXECUTED
513ae: 2084 movel %d4,%a0@ <== NOT EXECUTED
513b0: 508f addql #8,%sp <== NOT EXECUTED
513b2: 6074 bras 51428 <fat_init_volume_info+0x77c> <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
rtems_disk_release(vol->dd);
513b4: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
free(fs_info->vhash);
513b8: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
513be: 760c moveq #12,%d3 <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
rtems_disk_release(vol->dd);
513c0: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
513c6: 2f2a 005a movel %a2@(90),%sp@- <== NOT EXECUTED
513ca: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->rhash);
513cc: 2f2a 005e movel %a2@(94),%sp@- <== NOT EXECUTED
513d0: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
513d2: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
513d8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
513dc: 2240 moveal %d0,%a1 <== NOT EXECUTED
513de: 2283 movel %d3,%a1@ <== NOT EXECUTED
513e0: 6046 bras 51428 <fat_init_volume_info+0x77c> <== NOT EXECUTED
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
513e2: 4878 0001 pea 1 <ADD>
513e6: 4280 clrl %d0
513e8: 3012 movew %a2@,%d0
513ea: 2f00 movel %d0,%sp@-
513ec: 4e93 jsr %a3@
if (fs_info->sec_buf == NULL)
513ee: 508f addql #8,%sp
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
513f0: 2540 007c movel %d0,%a2@(124)
if (fs_info->sec_buf == NULL)
513f4: 6636 bnes 5142c <fat_init_volume_info+0x780> <== ALWAYS TAKEN
{
rtems_disk_release(vol->dd);
513f6: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
free(fs_info->vhash);
513fa: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
free(fs_info->rhash);
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
51400: 740c moveq #12,%d2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
if (fs_info->sec_buf == NULL)
{
rtems_disk_release(vol->dd);
51402: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
51408: 2f2a 005a movel %a2@(90),%sp@- <== NOT EXECUTED
5140c: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->rhash);
5140e: 2f2a 005e movel %a2@(94),%sp@- <== NOT EXECUTED
51412: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->uino);
51414: 2f2a 0062 movel %a2@(98),%sp@- <== NOT EXECUTED
51418: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
5141a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
51420: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
51424: 2040 moveal %d0,%a0 <== NOT EXECUTED
51426: 2082 movel %d2,%a0@ <== NOT EXECUTED
51428: 74ff moveq #-1,%d2 <== NOT EXECUTED
5142a: 6002 bras 5142e <fat_init_volume_info+0x782> <== NOT EXECUTED
}
return RC_OK;
5142c: 4282 clrl %d2
}
5142e: 2002 movel %d2,%d0
51430: 4cee 3cfc ff64 moveml %fp@(-156),%d2-%d7/%a2-%a5
51436: 4e5e unlk %fp
...
00056c38 <fat_scan_fat_for_free_clusters>:
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
56c38: 4e56 ffd4 linkw %fp,#-44
56c3c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
56c40: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
56c44: 246b 0034 moveal %a3@(52),%a2
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
56c48: 286e 0014 moveal %fp@(20),%a4
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
56c4c: 2e2a 0030 movel %a2@(48),%d7
56c50: 5487 addql #2,%d7
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
56c52: 2a6e 000c moveal %fp@(12),%a5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
56c56: 42ae fffc clrl %fp@(-4)
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
56c5a: 4294 clrl %a4@
if (count == 0)
56c5c: 4aae 0010 tstl %fp@(16)
56c60: 6700 0138 beqw 56d9a <fat_scan_fat_for_free_clusters+0x162>
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
56c64: 242a 003e movel %a2@(62),%d2
56c68: 70ff moveq #-1,%d0
56c6a: b082 cmpl %d2,%d0
56c6c: 6602 bnes 56c70 <fat_scan_fat_for_free_clusters+0x38>
uint32_t *last_cl
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
56c6e: 7402 moveq #2,%d2
}
}
i++;
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
56c70: 7c02 moveq #2,%d6
56c72: 4284 clrl %d4
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
56c74: 2a3c 0005 6930 movel #354608,%d5
56c7a: 6000 00f4 braw 56d70 <fat_scan_fat_for_free_clusters+0x138>
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
56c7e: 486e fffc pea %fp@(-4)
56c82: 2f02 movel %d2,%sp@-
56c84: 2f0b movel %a3,%sp@-
56c86: 4eb9 0005 67b8 jsr 567b8 <fat_get_fat_cluster>
if ( rc != RC_OK )
56c8c: 4fef 000c lea %sp@(12),%sp
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
56c90: 2600 movel %d0,%d3
if ( rc != RC_OK )
56c92: 6716 beqs 56caa <fat_scan_fat_for_free_clusters+0x72><== ALWAYS TAKEN
{
if (*cls_added != 0)
56c94: 4a94 tstl %a4@ <== NOT EXECUTED
56c96: 6700 0108 beqw 56da0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, (*chain));
56c9a: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
56c9c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56c9e: 4eb9 0005 6b8e jsr 56b8e <fat_free_fat_clusters_chain> <== NOT EXECUTED
56ca4: 508f addql #8,%sp <== NOT EXECUTED
56ca6: 6000 00f8 braw 56da0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
56caa: 4aae fffc tstl %fp@(-4)
56cae: 6600 00b6 bnew 56d66 <fat_scan_fat_for_free_clusters+0x12e>
/*
* We are enforced to process allocation of the first free cluster
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
56cb2: 4a94 tstl %a4@
56cb4: 661a bnes 56cd0 <fat_scan_fat_for_free_clusters+0x98><== NEVER TAKEN
{
*chain = cl4find;
56cb6: 2a82 movel %d2,%a5@
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
56cb8: 4878 ffff pea ffffffff <LESS>
56cbc: 2045 moveal %d5,%a0
56cbe: 2f02 movel %d2,%sp@-
56cc0: 2f0b movel %a3,%sp@-
56cc2: 4e90 jsr %a0@
if ( rc != RC_OK )
56cc4: 4fef 000c lea %sp@(12),%sp
56cc8: 4a80 tstl %d0
56cca: 6766 beqs 56d32 <fat_scan_fat_for_free_clusters+0xfa><== ALWAYS TAKEN
56ccc: 6000 00d0 braw 56d9e <fat_scan_fat_for_free_clusters+0x166><== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
56cd0: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
56cd4: 2045 moveal %d5,%a0 <== NOT EXECUTED
56cd6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56cd8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56cda: 4e90 jsr %a0@ <== NOT EXECUTED
if ( rc != RC_OK )
56cdc: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
56ce0: 4a80 tstl %d0 <== NOT EXECUTED
56ce2: 6714 beqs 56cf8 <fat_scan_fat_for_free_clusters+0xc0><== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
56ce4: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
56ce6: 2e00 movel %d0,%d7 <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
56ce8: 2607 movel %d7,%d3 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
56cea: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56cec: 4eb9 0005 6b8e jsr 56b8e <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
56cf2: 508f addql #8,%sp <== NOT EXECUTED
56cf4: 6000 00aa braw 56da0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
56cf8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56cfa: 2045 moveal %d5,%a0 <== NOT EXECUTED
56cfc: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56cfe: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56d00: 4e90 jsr %a0@ <== NOT EXECUTED
if ( rc != RC_OK )
56d02: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
56d06: 4a80 tstl %d0 <== NOT EXECUTED
56d08: 6728 beqs 56d32 <fat_scan_fat_for_free_clusters+0xfa><== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
56d0a: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
56d0c: 2800 movel %d0,%d4 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
56d0e: 2604 movel %d4,%d3 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
56d10: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56d12: 4eb9 0005 6b8e jsr 56b8e <fat_free_fat_clusters_chain> <== NOT EXECUTED
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_FREE);
56d18: 42a7 clrl %sp@- <== NOT EXECUTED
56d1a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56d1c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56d1e: 4eb9 0005 6930 jsr 56930 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
56d24: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56d26: 4eb9 0005 0690 jsr 50690 <fat_buf_release> <== NOT EXECUTED
return rc;
56d2c: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
56d30: 606e bras 56da0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
}
}
save_cln = cl4find;
(*cls_added)++;
56d32: 2014 movel %a4@,%d0
56d34: 5280 addql #1,%d0
56d36: 2880 movel %d0,%a4@
/* have we satisfied request ? */
if (*cls_added == count)
56d38: b0ae 0010 cmpl %fp@(16),%d0
56d3c: 6626 bnes 56d64 <fat_scan_fat_for_free_clusters+0x12c><== NEVER TAKEN
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
56d3e: 202a 003a movel %a2@(58),%d0
56d42: 72ff moveq #-1,%d1
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
56d44: 2542 003e movel %d2,%a2@(62)
if (fs_info->vol.free_cls != 0xFFFFFFFF)
56d48: b280 cmpl %d0,%d1
56d4a: 6706 beqs 56d52 <fat_scan_fat_for_free_clusters+0x11a><== ALWAYS TAKEN
fs_info->vol.free_cls -= (*cls_added);
56d4c: 9094 subl %a4@,%d0 <== NOT EXECUTED
56d4e: 2540 003a movel %d0,%a2@(58) <== NOT EXECUTED
*last_cl = save_cln;
56d52: 206e 0018 moveal %fp@(24),%a0
56d56: 2082 movel %d2,%a0@
fat_buf_release(fs_info);
56d58: 2f0a movel %a2,%sp@-
56d5a: 4eb9 0005 0690 jsr 50690 <fat_buf_release>
return rc;
56d60: 588f addql #4,%sp
56d62: 603c bras 56da0 <fat_scan_fat_for_free_clusters+0x168>
save_cln = cl4find;
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
56d64: 2802 movel %d2,%d4 <== NOT EXECUTED
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
}
}
i++;
56d66: 5286 addql #1,%d6
cl4find++;
56d68: 5282 addql #1,%d2
if (cl4find >= data_cls_val)
56d6a: be82 cmpl %d2,%d7
56d6c: 6202 bhis 56d70 <fat_scan_fat_for_free_clusters+0x138><== ALWAYS TAKEN
cl4find = 2;
56d6e: 7402 moveq #2,%d2 <== NOT EXECUTED
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
56d70: be86 cmpl %d6,%d7
56d72: 6200 ff0a bhiw 56c7e <fat_scan_fat_for_free_clusters+0x46>
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
56d76: 202a 003a movel %a2@(58),%d0 <== NOT EXECUTED
56d7a: 72ff moveq #-1,%d1 <== NOT EXECUTED
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
56d7c: 2544 003e movel %d4,%a2@(62) <== NOT EXECUTED
if (fs_info->vol.free_cls != 0xFFFFFFFF)
56d80: b280 cmpl %d0,%d1 <== NOT EXECUTED
56d82: 6706 beqs 56d8a <fat_scan_fat_for_free_clusters+0x152><== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
56d84: 9094 subl %a4@,%d0 <== NOT EXECUTED
56d86: 2540 003a movel %d0,%a2@(58) <== NOT EXECUTED
*last_cl = save_cln;
56d8a: 206e 0018 moveal %fp@(24),%a0 <== NOT EXECUTED
56d8e: 2084 movel %d4,%a0@ <== NOT EXECUTED
fat_buf_release(fs_info);
56d90: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56d92: 4eb9 0005 0690 jsr 50690 <fat_buf_release> <== NOT EXECUTED
return RC_OK;
56d98: 588f addql #4,%sp <== NOT EXECUTED
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
return rc;
56d9a: 4283 clrl %d3 <== NOT EXECUTED
56d9c: 6002 bras 56da0 <fat_scan_fat_for_free_clusters+0x168><== NOT EXECUTED
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
56d9e: 2600 movel %d0,%d3 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
fat_buf_release(fs_info);
return RC_OK;
}
56da0: 2003 movel %d3,%d0
56da2: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
56da8: 4e5e unlk %fp <== NOT EXECUTED
00056930 <fat_set_fat_cluster>:
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
56930: 7001 moveq #1,%d0
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
56932: 4e56 ffd8 linkw %fp,#-40
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
56936: 206e 0008 moveal %fp@(8),%a0
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
5693a: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
5693e: 242e 000c movel %fp@(12),%d2
56942: 2a2e 0010 movel %fp@(16),%d5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
56946: 2468 0034 moveal %a0@(52),%a2
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
5694a: 42ae fffc clrl %fp@(-4)
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
5694e: b082 cmpl %d2,%d0
56950: 6400 0222 bccw 56b74 <fat_set_fat_cluster+0x244>
56954: 202a 0030 movel %a2@(48),%d0
56958: 5280 addql #1,%d0
5695a: b082 cmpl %d2,%d0
5695c: 6500 0216 bcsw 56b74 <fat_set_fat_cluster+0x244>
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
56960: 4280 clrl %d0
56962: 102a 000a moveb %a2@(10),%d0
56966: 7601 moveq #1,%d3
56968: 2202 movel %d2,%d1
5696a: c680 andl %d0,%d3
5696c: 6706 beqs 56974 <fat_set_fat_cluster+0x44> <== NEVER TAKEN
5696e: e289 lsrl #1,%d1
56970: d282 addl %d2,%d1
56972: 600c bras 56980 <fat_set_fat_cluster+0x50>
56974: 0800 0001 btst #1,%d0 <== NOT EXECUTED
56978: 6704 beqs 5697e <fat_set_fat_cluster+0x4e> <== NOT EXECUTED
5697a: d281 addl %d1,%d1 <== NOT EXECUTED
5697c: 6002 bras 56980 <fat_set_fat_cluster+0x50> <== NOT EXECUTED
5697e: e589 lsll #2,%d1 <== NOT EXECUTED
56980: 4284 clrl %d4
56982: 182a 0002 moveb %a2@(2),%d4
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
56986: 2e02 movel %d2,%d7
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
56988: e8a9 lsrl %d4,%d1
5698a: 2641 moveal %d1,%a3
5698c: d7ea 0044 addal %a2@(68),%a3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
56990: 4a83 tstl %d3
56992: 6706 beqs 5699a <fat_set_fat_cluster+0x6a> <== NEVER TAKEN
56994: e28f lsrl #1,%d7
56996: de82 addl %d2,%d7
56998: 600c bras 569a6 <fat_set_fat_cluster+0x76>
5699a: 0800 0001 btst #1,%d0 <== NOT EXECUTED
5699e: 6704 beqs 569a4 <fat_set_fat_cluster+0x74> <== NOT EXECUTED
569a0: de87 addl %d7,%d7 <== NOT EXECUTED
569a2: 6002 bras 569a6 <fat_set_fat_cluster+0x76> <== NOT EXECUTED
569a4: e58f lsll #2,%d7 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
569a6: 2c0e movel %fp,%d6
569a8: 5986 subql #4,%d6
569aa: 49f9 0005 04b0 lea 504b0 <fat_buf_access>,%a4
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
569b0: 3612 movew %a2@,%d3
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
569b2: 2f06 movel %d6,%sp@-
569b4: 4878 0001 pea 1 <ADD>
569b8: 2f0b movel %a3,%sp@-
569ba: 2f0a movel %a2,%sp@-
569bc: 4e94 jsr %a4@
if (rc != RC_OK)
569be: 4fef 0010 lea %sp@(16),%sp
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
569c2: 2800 movel %d0,%d4
if (rc != RC_OK)
569c4: 6600 01bc bnew 56b82 <fat_set_fat_cluster+0x252>
return rc;
switch ( fs_info->vol.type )
569c8: 4280 clrl %d0
569ca: 102a 000a moveb %a2@(10),%d0
569ce: 7202 moveq #2,%d1
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
569d0: 0283 0000 ffff andil #65535,%d3
569d6: 5383 subql #1,%d3
569d8: c687 andl %d7,%d3
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
569da: b280 cmpl %d0,%d1
569dc: 6700 0142 beqw 56b20 <fat_set_fat_cluster+0x1f0>
569e0: 123c 0004 moveb #4,%d1
569e4: b280 cmpl %d0,%d1
569e6: 6700 015a beqw 56b42 <fat_set_fat_cluster+0x212>
569ea: 123c 0001 moveb #1,%d1
569ee: b280 cmpl %d0,%d1
569f0: 6600 0182 bnew 56b74 <fat_set_fat_cluster+0x244>
569f4: 206e fffc moveal %fp@(-4),%a0
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
569f8: 0802 0000 btst #0,%d2
569fc: 6700 0084 beqw 56a82 <fat_set_fat_cluster+0x152>
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
56a00: 2068 001e moveal %a0@(30),%a0
56a04: d1c3 addal %d3,%a0
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
56a06: 123c 000f moveb #15,%d1
56a0a: 1010 moveb %a0@,%d0
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
56a0c: e98d lsll #4,%d5
*((uint8_t *)(block0->buffer + ofs)) =
56a0e: c081 andl %d1,%d0
56a10: 1080 moveb %d0,%a0@
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
56a12: 206e fffc moveal %fp@(-4),%a0
56a16: 2068 001e moveal %a0@(30),%a0
56a1a: d1c3 addal %d3,%a0
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
56a1c: 1010 moveb %a0@,%d0
56a1e: 8085 orl %d5,%d0
56a20: 1080 moveb %d0,%a0@
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
56a22: 7001 moveq #1,%d0
56a24: 1540 0076 moveb %d0,%a2@(118)
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
56a28: 4280 clrl %d0
56a2a: 3012 movew %a2@,%d0
56a2c: 5380 subql #1,%d0
56a2e: b083 cmpl %d3,%d0
56a30: 663c bnes 56a6e <fat_set_fat_cluster+0x13e> <== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
56a32: 2f06 movel %d6,%sp@- <== NOT EXECUTED
56a34: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
56a38: 486b 0001 pea %a3@(1) <== NOT EXECUTED
56a3c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56a3e: 4e94 jsr %a4@ <== NOT EXECUTED
&block0);
if (rc != RC_OK)
56a40: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
56a44: 2800 movel %d0,%d4 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
56a46: 6600 013a bnew 56b82 <fat_set_fat_cluster+0x252> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
56a4a: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
56a4e: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
56a52: 4210 clrb %a0@ <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
56a54: 0285 0000 ffff andil #65535,%d5 <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
56a5a: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
(uint8_t )((fat16_clv & 0xFF00)>>8);
56a5e: e08d lsrl #8,%d5 <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
56a60: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
56a64: 1010 moveb %a0@,%d0 <== NOT EXECUTED
56a66: 8a80 orl %d0,%d5 <== NOT EXECUTED
56a68: 1085 moveb %d5,%a0@ <== NOT EXECUTED
56a6a: 6000 0100 braw 56b6c <fat_set_fat_cluster+0x23c> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
56a6e: 206e fffc moveal %fp@(-4),%a0
56a72: 5283 addql #1,%d3
56a74: 2068 001e moveal %a0@(30),%a0
56a78: 4200 clrb %d0
56a7a: 1180 3800 moveb %d0,%a0@(00000000,%d3:l)
56a7e: 6000 0086 braw 56b06 <fat_set_fat_cluster+0x1d6>
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
56a82: 2068 001e moveal %a0@(30),%a0
56a86: 4201 clrb %d1
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
56a88: 0285 0000 0fff andil #4095,%d5
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
56a8e: 1181 3800 moveb %d1,%a0@(00000000,%d3:l)
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
56a92: 206e fffc moveal %fp@(-4),%a0
56a96: 2068 001e moveal %a0@(30),%a0
56a9a: d1c3 addal %d3,%a0
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs)) =
56a9c: 1010 moveb %a0@,%d0
56a9e: 8085 orl %d5,%d0
56aa0: 1080 moveb %d0,%a0@
56aa2: 7001 moveq #1,%d0
56aa4: 1540 0076 moveb %d0,%a2@(118)
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
56aa8: 4280 clrl %d0
56aaa: 3012 movew %a2@,%d0
56aac: 5380 subql #1,%d0
56aae: b083 cmpl %d3,%d0
56ab0: 6640 bnes 56af2 <fat_set_fat_cluster+0x1c2> <== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
56ab2: 2f06 movel %d6,%sp@- <== NOT EXECUTED
56ab4: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
56ab8: 486b 0001 pea %a3@(1) <== NOT EXECUTED
56abc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56abe: 4e94 jsr %a4@ <== NOT EXECUTED
&block0);
if (rc != RC_OK)
56ac0: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
56ac4: 2800 movel %d0,%d4 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
56ac6: 6600 00ba bnew 56b82 <fat_set_fat_cluster+0x252> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
56aca: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
56ace: 72f0 moveq #-16,%d1 <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
56ad0: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
56ad4: 1010 moveb %a0@,%d0 <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
56ad6: 0285 0000 ffff andil #65535,%d5 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
56adc: c081 andl %d1,%d0 <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
56ade: e08d lsrl #8,%d5 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
56ae0: 1080 moveb %d0,%a0@ <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
56ae2: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
56ae6: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
56aea: 1010 moveb %a0@,%d0 <== NOT EXECUTED
56aec: 8a80 orl %d0,%d5 <== NOT EXECUTED
56aee: 1085 moveb %d5,%a0@ <== NOT EXECUTED
56af0: 6048 bras 56b3a <fat_set_fat_cluster+0x20a> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
56af2: 206e fffc moveal %fp@(-4),%a0
56af6: 5283 addql #1,%d3
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
56af8: 72f0 moveq #-16,%d1
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
56afa: 2068 001e moveal %a0@(30),%a0
56afe: d1c3 addal %d3,%a0
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
56b00: 1010 moveb %a0@,%d0
56b02: c081 andl %d1,%d0
56b04: 1080 moveb %d0,%a0@
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
56b06: 206e fffc moveal %fp@(-4),%a0
56b0a: 2068 001e moveal %a0@(30),%a0
56b0e: d1c3 addal %d3,%a0
(uint8_t )((fat16_clv & 0xFF00)>>8);
56b10: 0285 0000 ffff andil #65535,%d5
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
56b16: 1010 moveb %a0@,%d0
(*((uint8_t *)(block0->buffer + ofs+1))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
56b18: e08d lsrl #8,%d5
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
56b1a: 8a80 orl %d0,%d5
56b1c: 1085 moveb %d5,%a0@
56b1e: 6062 bras 56b82 <fat_set_fat_cluster+0x252>
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
56b20: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
56b24: 0285 0000 ffff andil #65535,%d5 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
56b2a: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
56b2e: 2005 movel %d5,%d0 <== NOT EXECUTED
56b30: e08d lsrl #8,%d5 <== NOT EXECUTED
56b32: e188 lsll #8,%d0 <== NOT EXECUTED
56b34: 8085 orl %d5,%d0 <== NOT EXECUTED
56b36: 3180 3800 movew %d0,%a0@(00000000,%d3:l) <== NOT EXECUTED
56b3a: 7001 moveq #1,%d0 <== NOT EXECUTED
56b3c: 1540 0076 moveb %d0,%a2@(118) <== NOT EXECUTED
56b40: 6040 bras 56b82 <fat_set_fat_cluster+0x252> <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
56b42: 49fa fc3c lea %pc@(56780 <m68k_swap_u32>),%a4 <== NOT EXECUTED
56b46: 0285 0fff ffff andil #268435455,%d5 <== NOT EXECUTED
56b4c: 2f05 movel %d5,%sp@- <== NOT EXECUTED
56b4e: 4e94 jsr %a4@ <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
56b50: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
56b54: 2400 movel %d0,%d2 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
56b56: 2668 001e moveal %a0@(30),%a3 <== NOT EXECUTED
56b5a: d7c3 addal %d3,%a3 <== NOT EXECUTED
56b5c: 2ebc f000 0000 movel #-268435456,%sp@ <== NOT EXECUTED
56b62: 4e94 jsr %a4@ <== NOT EXECUTED
56b64: 588f addql #4,%sp <== NOT EXECUTED
56b66: c093 andl %a3@,%d0 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
fat32_clv | (*((uint32_t *)(block0->buffer + ofs)));
56b68: 8082 orl %d2,%d0 <== NOT EXECUTED
56b6a: 2680 movel %d0,%a3@ <== NOT EXECUTED
56b6c: 7201 moveq #1,%d1 <== NOT EXECUTED
56b6e: 1541 0076 moveb %d1,%a2@(118) <== NOT EXECUTED
56b72: 600e bras 56b82 <fat_set_fat_cluster+0x252> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
56b74: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
56b7a: 78ff moveq #-1,%d4 <== NOT EXECUTED
56b7c: 7205 moveq #5,%d1 <== NOT EXECUTED
56b7e: 2040 moveal %d0,%a0 <== NOT EXECUTED
56b80: 2081 movel %d1,%a0@ <== NOT EXECUTED
break;
}
return RC_OK;
}
56b82: 2004 movel %d4,%d0
56b84: 4cee 1cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a4
56b8a: 4e5e unlk %fp <== NOT EXECUTED
00050ba4 <fat_shutdown_drive>:
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
50ba4: 4280 clrl %d0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
50ba6: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED
50baa: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
50bae: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@ <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
50bb2: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
50bb6: 102a 000a moveb %a2@(10),%d0 <== NOT EXECUTED
50bba: 44c0 movew %d0,%ccr <== NOT EXECUTED
50bbc: 661c bnes 50bda <fat_shutdown_drive+0x36> <== NOT EXECUTED
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
50bbe: 2f2a 003e movel %a2@(62),%sp@- <== NOT EXECUTED
50bc2: 2f2a 003a movel %a2@(58),%sp@- <== NOT EXECUTED
50bc6: 2f08 movel %a0,%sp@- <== NOT EXECUTED
50bc8: 4eb9 0005 0b26 jsr 50b26 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
50bce: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
50bd2: 2400 movel %d0,%d2 <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
50bd4: 6706 beqs 50bdc <fat_shutdown_drive+0x38> <== NOT EXECUTED
rc = -1;
50bd6: 74ff moveq #-1,%d2 <== NOT EXECUTED
50bd8: 6002 bras 50bdc <fat_shutdown_drive+0x38> <== NOT EXECUTED
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
int rc = RC_OK;
50bda: 4282 clrl %d2 <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
rc = -1;
}
fat_buf_release(fs_info);
50bdc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
50bde: 4eb9 0005 0690 jsr 50690 <fat_buf_release> <== NOT EXECUTED
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
50be4: 2f2a 004e movel %a2@(78),%sp@- <== NOT EXECUTED
50be8: 2f2a 004a movel %a2@(74),%sp@- <== NOT EXECUTED
50bec: 4eb9 0004 f356 jsr 4f356 <rtems_bdbuf_syncdev> <== NOT EXECUTED
50bf2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
50bf6: 4a80 tstl %d0 <== NOT EXECUTED
50bf8: 6702 beqs 50bfc <fat_shutdown_drive+0x58> <== NOT EXECUTED
rc = -1;
50bfa: 74ff moveq #-1,%d2 <== NOT EXECUTED
50bfc: 4283 clrl %d3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
50bfe: 49f9 0004 9a0c lea 49a0c <_Chain_Get>,%a4 <== NOT EXECUTED
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
50c04: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
50c0a: 282a 005a movel %a2@(90),%d4 <== NOT EXECUTED
50c0e: d883 addl %d3,%d4 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
50c10: 6006 bras 50c18 <fat_shutdown_drive+0x74> <== NOT EXECUTED
free(node);
50c12: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50c14: 4e93 jsr %a3@ <== NOT EXECUTED
50c16: 588f addql #4,%sp <== NOT EXECUTED
50c18: 2f04 movel %d4,%sp@- <== NOT EXECUTED
50c1a: 4e94 jsr %a4@ <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
50c1c: 588f addql #4,%sp <== NOT EXECUTED
50c1e: 4a80 tstl %d0 <== NOT EXECUTED
50c20: 66f0 bnes 50c12 <fat_shutdown_drive+0x6e> <== NOT EXECUTED
50c22: 0683 0000 000c addil #12,%d3 <== NOT EXECUTED
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
50c28: 103c 0018 moveb #24,%d0 <== NOT EXECUTED
50c2c: b083 cmpl %d3,%d0 <== NOT EXECUTED
50c2e: 66da bnes 50c0a <fat_shutdown_drive+0x66> <== NOT EXECUTED
50c30: 4283 clrl %d3 <== NOT EXECUTED
50c32: 49f9 0004 9a0c lea 49a0c <_Chain_Get>,%a4 <== NOT EXECUTED
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
50c38: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
50c3e: 282a 005e movel %a2@(94),%d4 <== NOT EXECUTED
50c42: d883 addl %d3,%d4 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
50c44: 6006 bras 50c4c <fat_shutdown_drive+0xa8> <== NOT EXECUTED
free(node);
50c46: 2f00 movel %d0,%sp@- <== NOT EXECUTED
50c48: 4e93 jsr %a3@ <== NOT EXECUTED
50c4a: 588f addql #4,%sp <== NOT EXECUTED
50c4c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
50c4e: 4e94 jsr %a4@ <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
50c50: 588f addql #4,%sp <== NOT EXECUTED
50c52: 4a80 tstl %d0 <== NOT EXECUTED
50c54: 66f0 bnes 50c46 <fat_shutdown_drive+0xa2> <== NOT EXECUTED
50c56: 0683 0000 000c addil #12,%d3 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
50c5c: 103c 0018 moveb #24,%d0 <== NOT EXECUTED
50c60: b083 cmpl %d3,%d0 <== NOT EXECUTED
50c62: 66da bnes 50c3e <fat_shutdown_drive+0x9a> <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
50c64: 2f2a 005a movel %a2@(90),%sp@- <== NOT EXECUTED
50c68: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
50c6e: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->rhash);
50c70: 2f2a 005e movel %a2@(94),%sp@- <== NOT EXECUTED
50c74: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->uino);
50c76: 2f2a 0062 movel %a2@(98),%sp@- <== NOT EXECUTED
50c7a: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info->sec_buf);
50c7c: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
50c80: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_disk_release(fs_info->vol.dd);
50c82: 2f2a 0052 movel %a2@(82),%sp@- <== NOT EXECUTED
50c86: 4eb9 0004 4522 jsr 44522 <rtems_disk_release> <== NOT EXECUTED
if (rc)
50c8c: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
50c90: 4a82 tstl %d2 <== NOT EXECUTED
50c92: 670c beqs 50ca0 <fat_shutdown_drive+0xfc> <== NOT EXECUTED
errno = EIO;
50c94: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
50c9a: 7205 moveq #5,%d1 <== NOT EXECUTED
50c9c: 2040 moveal %d0,%a0 <== NOT EXECUTED
50c9e: 2081 movel %d1,%a0@ <== NOT EXECUTED
return rc;
}
50ca0: 2002 movel %d2,%d0 <== NOT EXECUTED
50ca2: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 <== NOT EXECUTED
50ca8: 4e5e unlk %fp <== NOT EXECUTED
0005af54 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
5af54: 4e56 fff0 linkw %fp,#-16
5af58: 202e 0008 movel %fp@(8),%d0
5af5c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
5af60: 262e 000c movel %fp@(12),%d3
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
5af64: 2239 0005 d9b2 movel 5d9b2 <rtems_libio_number_iops>,%d1
5af6a: b280 cmpl %d0,%d1
5af6c: 631c blss 5af8a <fcntl+0x36>
iop = rtems_libio_iop( fd );
5af6e: 2400 movel %d0,%d2
5af70: ed88 lsll #6,%d0
5af72: e78a lsll #3,%d2
5af74: 2679 0005 f118 moveal 5f118 <rtems_libio_iops>,%a3
5af7a: 9082 subl %d2,%d0
5af7c: 45f3 0800 lea %a3@(00000000,%d0:l),%a2
rtems_libio_check_is_open(iop);
5af80: 202a 0014 movel %a2@(20),%d0
5af84: 0800 0008 btst #8,%d0
5af88: 6610 bnes 5af9a <fcntl+0x46>
5af8a: 4eb9 0004 cc98 jsr 4cc98 <__errno>
5af90: 7209 moveq #9,%d1
5af92: 2040 moveal %d0,%a0
5af94: 2081 movel %d1,%a0@
5af96: 6000 0116 braw 5b0ae <fcntl+0x15a>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
5af9a: 7409 moveq #9,%d2
5af9c: b483 cmpl %d3,%d2
5af9e: 6500 00de bcsw 5b07e <fcntl+0x12a>
5afa2: 307b 3a06 moveaw %pc@(5afaa <fcntl+0x56>,%d3:l:2),%a0
5afa6: 4efb 8802 jmp %pc@(5afaa <fcntl+0x56>,%a0:l)
5afaa: 0014 .short 0x0014 <== NOT EXECUTED
5afac: 006e .short 0x006e <== NOT EXECUTED
5afae: 007a .short 0x007a <== NOT EXECUTED
5afb0: 0090 009e 00c4 oril #10354884,%d0 <== NOT EXECUTED
5afb6: 00c4 bitrev %d4 <== NOT EXECUTED
5afb8: 00c4 bitrev %d4 <== NOT EXECUTED
5afba: 00c4 bitrev %d4 <== NOT EXECUTED
5afbc: 00c4 bitrev %d4 <== NOT EXECUTED
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
5afbe: 242e 0010 movel %fp@(16),%d2
if ( fd2 )
5afc2: 6710 beqs 5afd4 <fcntl+0x80>
diop = rtems_libio_iop( fd2 );
5afc4: b282 cmpl %d2,%d1
5afc6: 631c blss 5afe4 <fcntl+0x90> <== NEVER TAKEN
5afc8: 2002 movel %d2,%d0
5afca: ed8a lsll #6,%d2
5afcc: e788 lsll #3,%d0
5afce: 9480 subl %d0,%d2
5afd0: d7c2 addal %d2,%a3
5afd2: 6012 bras 5afe6 <fcntl+0x92>
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
5afd4: 4eb9 0004 358c jsr 4358c <rtems_libio_allocate>
5afda: 2640 moveal %d0,%a3
if ( diop == 0 ) {
5afdc: 4a80 tstl %d0
5afde: 6606 bnes 5afe6 <fcntl+0x92> <== ALWAYS TAKEN
5afe0: 6000 00cc braw 5b0ae <fcntl+0x15a> <== NOT EXECUTED
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
5afe4: 97cb subal %a3,%a3 <== NOT EXECUTED
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
5afe6: 240b movel %a3,%d2
ret = -1;
break;
}
}
diop->flags = iop->flags;
5afe8: 276a 0014 0014 movel %a2@(20),%a3@(20)
diop->pathinfo = iop->pathinfo;
5afee: 4878 0014 pea 14 <OPER2>
5aff2: 486a 0018 pea %a2@(24)
5aff6: 486b 0018 pea %a3@(24)
5affa: 4eb9 0004 d988 jsr 4d988 <memcpy>
ret = (int) (diop - rtems_libio_iops);
5b000: 4fef 000c lea %sp@(12),%sp
5b004: 94b9 0005 f118 subl 5f118 <rtems_libio_iops>,%d2
5b00a: 203c b6db 6db7 movel #-1227133513,%d0
5b010: e682 asrl #3,%d2
5b012: 4c00 2800 mulsl %d0,%d2
5b016: 6074 bras 5b08c <fcntl+0x138>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
5b018: 0800 000b btst #11,%d0
5b01c: 56c2 sne %d2
5b01e: 49c2 extbl %d2
5b020: 4482 negl %d2
5b022: 606c bras 5b090 <fcntl+0x13c>
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
5b024: 4aae 0010 tstl %fp@(16)
5b028: 6706 beqs 5b030 <fcntl+0xdc>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
5b02a: 08c0 000b bset #11,%d0
5b02e: 6004 bras 5b034 <fcntl+0xe0>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
5b030: 0880 000b bclr #11,%d0
5b034: 2540 0014 movel %d0,%a2@(20)
5b038: 6030 bras 5b06a <fcntl+0x116>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
5b03a: 2f00 movel %d0,%sp@-
5b03c: 4eb9 0004 353e jsr 4353e <rtems_libio_to_fcntl_flags>
5b042: 588f addql #4,%sp
5b044: 2400 movel %d0,%d2
5b046: 6044 bras 5b08c <fcntl+0x138>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
5b048: 2f2e 0010 movel %fp@(16),%sp@-
5b04c: 4eb9 0004 34fe jsr 434fe <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
5b052: 222a 0014 movel %a2@(20),%d1
5b056: 588f addql #4,%sp
5b058: 0280 0000 0201 andil #513,%d0
5b05e: 0281 ffff fdfe andil #-514,%d1
5b064: 8081 orl %d1,%d0
5b066: 2540 0014 movel %d0,%a2@(20)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
5b06a: 4282 clrl %d2
5b06c: 6022 bras 5b090 <fcntl+0x13c>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
5b06e: 4eb9 0004 cc98 jsr 4cc98 <__errno>
5b074: 2040 moveal %d0,%a0
5b076: 20bc 0000 0086 movel #134,%a0@
5b07c: 6030 bras 5b0ae <fcntl+0x15a>
ret = -1;
break;
default:
errno = EINVAL;
5b07e: 4eb9 0004 cc98 jsr 4cc98 <__errno>
5b084: 2040 moveal %d0,%a0
5b086: 7016 moveq #22,%d0
5b088: 2080 movel %d0,%a0@
5b08a: 6022 bras 5b0ae <fcntl+0x15a>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
5b08c: 4a82 tstl %d2
5b08e: 6d20 blts 5b0b0 <fcntl+0x15c> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
5b090: 206a 0020 moveal %a2@(32),%a0
5b094: 2f0a movel %a2,%sp@-
5b096: 2f03 movel %d3,%sp@-
5b098: 2068 0030 moveal %a0@(48),%a0
5b09c: 4e90 jsr %a0@
if (err) {
5b09e: 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 );
5b0a0: 2600 movel %d0,%d3
if (err) {
5b0a2: 670c beqs 5b0b0 <fcntl+0x15c> <== ALWAYS TAKEN
errno = err;
5b0a4: 4eb9 0004 cc98 jsr 4cc98 <__errno> <== NOT EXECUTED
5b0aa: 2040 moveal %d0,%a0 <== NOT EXECUTED
5b0ac: 2083 movel %d3,%a0@ <== NOT EXECUTED
ret = -1;
5b0ae: 74ff moveq #-1,%d2
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
5b0b0: 2002 movel %d2,%d0
5b0b2: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
5b0b8: 4e5e unlk %fp <== NOT EXECUTED
0004b51a <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b51a: 4e56 ffdc linkw %fp,#-36
4b51e: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
4b522: 266e 0008 moveal %fp@(8),%a3
4b526: 286e 000c moveal %fp@(12),%a4
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
4b52a: 4ab9 0005 f03c tstl 5f03c <pipe_semaphore>
4b530: 6656 bnes 4b588 <fifo_open+0x6e>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4b532: 42a7 clrl %sp@-
4b534: 42a7 clrl %sp@-
4b536: 2f39 0005 f734 movel 5f734 <rtems_libio_semaphore>,%sp@-
4b53c: 4eb9 0004 7550 jsr 47550 <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
4b542: 4fef 000c lea %sp@(12),%sp
4b546: 4ab9 0005 f03c tstl 5f03c <pipe_semaphore>
4b54c: 6624 bnes 4b572 <fifo_open+0x58> <== NEVER TAKEN
sc = rtems_semaphore_create(
4b54e: 4879 0005 f03c pea 5f03c <pipe_semaphore>
4b554: 42a7 clrl %sp@-
4b556: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
4b55a: 4878 0001 pea 1 <ADD>
4b55e: 2f3c 5049 5045 movel #1346981957,%sp@-
4b564: 4eb9 0004 7314 jsr 47314 <rtems_semaphore_create>
4b56a: 4fef 0014 lea %sp@(20),%sp
4b56e: 2400 movel %d0,%d2
4b570: 6002 bras 4b574 <fifo_open+0x5a>
free(pipe);
}
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
4b572: 4282 clrl %d2 <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4b574: 2f39 0005 f734 movel 5f734 <rtems_libio_semaphore>,%sp@-
4b57a: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
4b580: 588f addql #4,%sp
4b582: 4a82 tstl %d2
4b584: 6600 0310 bnew 4b896 <fifo_open+0x37c>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4b588: 42a7 clrl %sp@-
4b58a: 42a7 clrl %sp@-
4b58c: 2f39 0005 f03c movel 5f03c <pipe_semaphore>,%sp@-
4b592: 4eb9 0004 7550 jsr 47550 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
4b598: 4fef 000c lea %sp@(12),%sp
4b59c: 4a80 tstl %d0
4b59e: 6600 02f6 bnew 4b896 <fifo_open+0x37c>
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
4b5a2: 2453 moveal %a3@,%a2
if (pipe == NULL) {
4b5a4: 4a8a tstl %a2
4b5a6: 6600 010a bnew 4b6b2 <fifo_open+0x198>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4b5aa: 4878 0034 pea 34 <OPER2+0x20>
4b5ae: 4bf9 0004 48c4 lea 448c4 <malloc>,%a5
4b5b4: 4e95 jsr %a5@
if (pipe == NULL)
4b5b6: 588f addql #4,%sp
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4b5b8: 2440 moveal %d0,%a2
if (pipe == NULL)
4b5ba: 4a80 tstl %d0
4b5bc: 6700 00f0 beqw 4b6ae <fifo_open+0x194>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
4b5c0: 4878 0034 pea 34 <OPER2+0x20>
4b5c4: 42a7 clrl %sp@-
4b5c6: 2f00 movel %d0,%sp@-
4b5c8: 4eb9 0004 e828 jsr 4e828 <memset>
pipe->Size = PIPE_BUF;
4b5ce: 203c 0000 0200 movel #512,%d0
4b5d4: 2540 0004 movel %d0,%a2@(4)
pipe->Buffer = malloc(pipe->Size);
4b5d8: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
4b5dc: 4e95 jsr %a5@
if (! pipe->Buffer)
4b5de: 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);
4b5e2: 2480 movel %d0,%a2@
if (! pipe->Buffer)
4b5e4: 6700 00be beqw 4b6a4 <fifo_open+0x18a>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b5e8: 486a 002c pea %a2@(44)
4b5ec: 4bf9 0004 c530 lea 4c530 <rtems_barrier_create>,%a5
rtems_build_name ('P', 'I', 'r', c),
4b5f2: 1039 0005 e178 moveb 5e178 <c.5636>,%d0
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b5f8: 42a7 clrl %sp@-
rtems_build_name ('P', 'I', 'r', c),
4b5fa: 49c0 extbl %d0
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4b5fc: 42a7 clrl %sp@-
4b5fe: 0080 5049 7200 oril #1346990592,%d0
4b604: 2f00 movel %d0,%sp@-
4b606: 4e95 jsr %a5@
4b608: 4fef 0010 lea %sp@(16),%sp
4b60c: 4a80 tstl %d0
4b60e: 6600 008a bnew 4b69a <fifo_open+0x180>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4b612: 486a 0030 pea %a2@(48)
rtems_build_name ('P', 'I', 'w', c),
4b616: 1039 0005 e178 moveb 5e178 <c.5636>,%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(
4b61c: 42a7 clrl %sp@-
rtems_build_name ('P', 'I', 'w', c),
4b61e: 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(
4b620: 42a7 clrl %sp@-
4b622: 0080 5049 7700 oril #1346991872,%d0
4b628: 2f00 movel %d0,%sp@-
4b62a: 4e95 jsr %a5@
4b62c: 4fef 0010 lea %sp@(16),%sp
4b630: 4a80 tstl %d0
4b632: 665a bnes 4b68e <fifo_open+0x174>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4b634: 486a 0028 pea %a2@(40)
rtems_build_name ('P', 'I', 's', c), 1,
4b638: 1039 0005 e178 moveb 5e178 <c.5636>,%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(
4b63e: 42a7 clrl %sp@-
4b640: 4878 0010 pea 10 <INVALID_OPERATION>
rtems_build_name ('P', 'I', 's', c), 1,
4b644: 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(
4b646: 4878 0001 pea 1 <ADD>
4b64a: 0080 5049 7300 oril #1346990848,%d0
4b650: 2f00 movel %d0,%sp@-
4b652: 4eb9 0004 7314 jsr 47314 <rtems_semaphore_create>
4b658: 4fef 0014 lea %sp@(20),%sp
4b65c: 4a80 tstl %d0
4b65e: 6622 bnes 4b682 <fifo_open+0x168>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4b660: 1039 0005 e178 moveb 5e178 <c.5636>,%d0
4b666: 49c0 extbl %d0
4b668: 2200 movel %d0,%d1
4b66a: 5281 addql #1,%d1
4b66c: 13c1 0005 e178 moveb %d1,5e178 <c.5636>
4b672: 727a moveq #122,%d1
4b674: b280 cmpl %d0,%d1
4b676: 663a bnes 4b6b2 <fifo_open+0x198>
c = 'a';
4b678: 7061 moveq #97,%d0
4b67a: 13c0 0005 e178 moveb %d0,5e178 <c.5636>
4b680: 6030 bras 4b6b2 <fifo_open+0x198>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
4b682: 2f2a 0030 movel %a2@(48),%sp@-
4b686: 4eb9 0004 c5ec jsr 4c5ec <rtems_barrier_delete>
4b68c: 588f addql #4,%sp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
4b68e: 2f2a 002c movel %a2@(44),%sp@-
4b692: 4eb9 0004 c5ec jsr 4c5ec <rtems_barrier_delete>
4b698: 588f addql #4,%sp
err_rbar:
free(pipe->Buffer);
4b69a: 2f12 movel %a2@,%sp@-
4b69c: 4eb9 0004 41e8 jsr 441e8 <free>
4b6a2: 588f addql #4,%sp
err_buf:
free(pipe);
4b6a4: 2f0a movel %a2,%sp@-
4b6a6: 4eb9 0004 41e8 jsr 441e8 <free>
4b6ac: 588f addql #4,%sp
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4b6ae: 74f4 moveq #-12,%d2
4b6b0: 6030 bras 4b6e2 <fifo_open+0x1c8>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4b6b2: 42a7 clrl %sp@-
4b6b4: 42a7 clrl %sp@-
4b6b6: 2f2a 0028 movel %a2@(40),%sp@-
4b6ba: 4eb9 0004 7550 jsr 47550 <rtems_semaphore_obtain>
4b6c0: 4fef 000c lea %sp@(12),%sp
4b6c4: 4a80 tstl %d0
4b6c6: 6604 bnes 4b6cc <fifo_open+0x1b2> <== NEVER TAKEN
4b6c8: 4282 clrl %d2
4b6ca: 6002 bras 4b6ce <fifo_open+0x1b4>
err = -EINTR;
4b6cc: 74fc moveq #-4,%d2 <== NOT EXECUTED
if (*pipep == NULL) {
4b6ce: 4a93 tstl %a3@
4b6d0: 6610 bnes 4b6e2 <fifo_open+0x1c8>
if (err)
4b6d2: 4a82 tstl %d2
4b6d4: 670a beqs 4b6e0 <fifo_open+0x1c6> <== ALWAYS TAKEN
pipe_free(pipe);
4b6d6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4b6d8: 4eba fd66 jsr %pc@(4b440 <pipe_free>) <== NOT EXECUTED
4b6dc: 588f addql #4,%sp <== NOT EXECUTED
4b6de: 6002 bras 4b6e2 <fifo_open+0x1c8> <== NOT EXECUTED
else
*pipep = pipe;
4b6e0: 268a movel %a2,%a3@
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
4b6e2: 2f39 0005 f03c movel 5f03c <pipe_semaphore>,%sp@-
4b6e8: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
4b6ee: 588f addql #4,%sp
4b6f0: 4a82 tstl %d2
4b6f2: 6600 01a4 bnew 4b898 <fifo_open+0x37e>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
4b6f6: 7006 moveq #6,%d0
4b6f8: 7204 moveq #4,%d1
4b6fa: c0ac 0014 andl %a4@(20),%d0
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
4b6fe: 2453 moveal %a3@,%a2
switch (LIBIO_ACCMODE(iop)) {
4b700: b280 cmpl %d0,%d1
4b702: 6700 009c beqw 4b7a0 <fifo_open+0x286>
4b706: 123c 0006 moveb #6,%d1
4b70a: b280 cmpl %d0,%d1
4b70c: 6700 0122 beqw 4b830 <fifo_open+0x316>
4b710: 123c 0002 moveb #2,%d1
4b714: b280 cmpl %d0,%d1
4b716: 6600 0160 bnew 4b878 <fifo_open+0x35e>
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
4b71a: 202a 0010 movel %a2@(16),%d0
4b71e: 2040 moveal %d0,%a0
4b720: 5288 addql #1,%a0
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4b722: 52aa 0020 addql #1,%a2@(32)
if (pipe->Readers ++ == 0)
4b726: 2548 0010 movel %a0,%a2@(16)
4b72a: 4a80 tstl %d0
4b72c: 6610 bnes 4b73e <fifo_open+0x224> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
4b72e: 486e fffc pea %fp@(-4)
4b732: 2f2a 0030 movel %a2@(48),%sp@-
4b736: 4eb9 0004 c688 jsr 4c688 <rtems_barrier_release>
4b73c: 508f addql #8,%sp
if (pipe->Writers == 0) {
4b73e: 4aaa 0014 tstl %a2@(20)
4b742: 6600 0134 bnew 4b878 <fifo_open+0x35e>
/* Not an error */
if (LIBIO_NODELAY(iop))
4b746: 7001 moveq #1,%d0
4b748: c0ac 0014 andl %a4@(20),%d0
4b74c: 6600 012a bnew 4b878 <fifo_open+0x35e>
break;
prevCounter = pipe->writerCounter;
4b750: 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))
4b754: 4bf9 0004 7550 lea 47550 <rtems_semaphore_obtain>,%a5
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4b75a: 283c 0004 765c movel #292444,%d4
if (! PIPE_READWAIT(pipe))
4b760: 263c 0004 c6ec movel #313068,%d3
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4b766: 2f2a 0028 movel %a2@(40),%sp@-
4b76a: 2044 moveal %d4,%a0
4b76c: 4e90 jsr %a0@
if (! PIPE_READWAIT(pipe))
4b76e: 2043 moveal %d3,%a0
4b770: 42a7 clrl %sp@-
4b772: 2f2a 002c movel %a2@(44),%sp@-
4b776: 4e90 jsr %a0@
4b778: 4fef 000c lea %sp@(12),%sp
4b77c: 4a80 tstl %d0
4b77e: 6600 0106 bnew 4b886 <fifo_open+0x36c>
goto out_error;
if (! PIPE_LOCK(pipe))
4b782: 42a7 clrl %sp@-
4b784: 42a7 clrl %sp@-
4b786: 2f2a 0028 movel %a2@(40),%sp@-
4b78a: 4e95 jsr %a5@
4b78c: 4fef 000c lea %sp@(12),%sp
4b790: 4a80 tstl %d0
4b792: 6600 00f2 bnew 4b886 <fifo_open+0x36c>
goto out_error;
} while (prevCounter == pipe->writerCounter);
4b796: baaa 0024 cmpl %a2@(36),%d5
4b79a: 67ca beqs 4b766 <fifo_open+0x24c> <== NEVER TAKEN
4b79c: 6000 00da braw 4b878 <fifo_open+0x35e>
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4b7a0: 202a 0014 movel %a2@(20),%d0
4b7a4: 2200 movel %d0,%d1
4b7a6: 5281 addql #1,%d1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4b7a8: 52aa 0024 addql #1,%a2@(36)
if (pipe->Writers ++ == 0)
4b7ac: 2541 0014 movel %d1,%a2@(20)
4b7b0: 4a80 tstl %d0
4b7b2: 6610 bnes 4b7c4 <fifo_open+0x2aa> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4b7b4: 486e fffc pea %fp@(-4)
4b7b8: 2f2a 002c movel %a2@(44),%sp@-
4b7bc: 4eb9 0004 c688 jsr 4c688 <rtems_barrier_release>
4b7c2: 508f addql #8,%sp
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4b7c4: 4aaa 0010 tstl %a2@(16)
4b7c8: 6600 00ae bnew 4b878 <fifo_open+0x35e>
4b7cc: 7001 moveq #1,%d0
4b7ce: c0ac 0014 andl %a4@(20),%d0
4b7d2: 6712 beqs 4b7e6 <fifo_open+0x2cc>
PIPE_UNLOCK(pipe);
4b7d4: 2f2a 0028 movel %a2@(40),%sp@-
err = -ENXIO;
4b7d8: 74fa moveq #-6,%d2
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
4b7da: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
4b7e0: 588f addql #4,%sp
4b7e2: 6000 00a4 braw 4b888 <fifo_open+0x36e>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
4b7e6: 2a2a 0020 movel %a2@(32),%d5
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
4b7ea: 4bf9 0004 7550 lea 47550 <rtems_semaphore_obtain>,%a5
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4b7f0: 283c 0004 765c movel #292444,%d4
if (! PIPE_WRITEWAIT(pipe))
4b7f6: 263c 0004 c6ec movel #313068,%d3
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4b7fc: 2f2a 0028 movel %a2@(40),%sp@-
4b800: 2044 moveal %d4,%a0
4b802: 4e90 jsr %a0@
if (! PIPE_WRITEWAIT(pipe))
4b804: 2043 moveal %d3,%a0
4b806: 42a7 clrl %sp@-
4b808: 2f2a 0030 movel %a2@(48),%sp@-
4b80c: 4e90 jsr %a0@
4b80e: 4fef 000c lea %sp@(12),%sp
4b812: 4a80 tstl %d0
4b814: 6670 bnes 4b886 <fifo_open+0x36c> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
4b816: 42a7 clrl %sp@-
4b818: 42a7 clrl %sp@-
4b81a: 2f2a 0028 movel %a2@(40),%sp@-
4b81e: 4e95 jsr %a5@
4b820: 4fef 000c lea %sp@(12),%sp
4b824: 4a80 tstl %d0
4b826: 665e bnes 4b886 <fifo_open+0x36c> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
4b828: baaa 0020 cmpl %a2@(32),%d5
4b82c: 67ce beqs 4b7fc <fifo_open+0x2e2> <== NEVER TAKEN
4b82e: 6048 bras 4b878 <fifo_open+0x35e>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
4b830: 202a 0010 movel %a2@(16),%d0
4b834: 2200 movel %d0,%d1
4b836: 5281 addql #1,%d1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4b838: 52aa 0020 addql #1,%a2@(32)
if (pipe->Readers ++ == 0)
4b83c: 2541 0010 movel %d1,%a2@(16)
4b840: 4a80 tstl %d0
4b842: 6610 bnes 4b854 <fifo_open+0x33a> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
4b844: 486e fffc pea %fp@(-4)
4b848: 2f2a 0030 movel %a2@(48),%sp@-
4b84c: 4eb9 0004 c688 jsr 4c688 <rtems_barrier_release>
4b852: 508f addql #8,%sp
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4b854: 202a 0014 movel %a2@(20),%d0
4b858: 2040 moveal %d0,%a0
4b85a: 5288 addql #1,%a0
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
4b85c: 52aa 0024 addql #1,%a2@(36)
if (pipe->Writers ++ == 0)
4b860: 2548 0014 movel %a0,%a2@(20)
4b864: 4a80 tstl %d0
4b866: 6610 bnes 4b878 <fifo_open+0x35e> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4b868: 486e fffc pea %fp@(-4)
4b86c: 2f2a 002c movel %a2@(44),%sp@-
4b870: 4eb9 0004 c688 jsr 4c688 <rtems_barrier_release>
4b876: 508f addql #8,%sp
break;
}
PIPE_UNLOCK(pipe);
4b878: 2f2a 0028 movel %a2@(40),%sp@-
4b87c: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
return 0;
4b882: 588f addql #4,%sp
4b884: 6012 bras 4b898 <fifo_open+0x37e>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
4b886: 74fc moveq #-4,%d2 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
4b888: 2f0c movel %a4,%sp@-
4b88a: 2f0b movel %a3,%sp@-
4b88c: 4eb9 0004 b488 jsr 4b488 <pipe_release>
return err;
4b892: 508f addql #8,%sp
4b894: 6002 bras 4b898 <fifo_open+0x37e>
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
if (sc == RTEMS_SUCCESSFUL) {
4b896: 74f4 moveq #-12,%d2
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
4b898: 2002 movel %d2,%d0
4b89a: 4cee 3c3c ffdc moveml %fp@(-36),%d2-%d5/%a2-%a5
4b8a0: 4e5e unlk %fp <== NOT EXECUTED
000434a4 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
434a4: 4e56 0000 linkw %fp,#0
434a8: 202e 0008 movel %fp@(8),%d0
434ac: 222e 000c movel %fp@(12),%d1
434b0: 2f02 movel %d2,%sp@-
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
434b2: b0b9 0005 d822 cmpl 5d822 <rtems_libio_number_iops>,%d0
434b8: 641c bccs 434d6 <fpathconf+0x32>
iop = rtems_libio_iop(fd);
434ba: 2400 movel %d0,%d2
434bc: ed88 lsll #6,%d0
434be: e78a lsll #3,%d2
434c0: 2079 0005 ef08 moveal 5ef08 <rtems_libio_iops>,%a0
434c6: 9082 subl %d2,%d0
434c8: d1c0 addal %d0,%a0
rtems_libio_check_is_open(iop);
434ca: 2028 0014 movel %a0@(20),%d0
434ce: 0280 0000 0100 andil #256,%d0
434d4: 6610 bnes 434e6 <fpathconf+0x42> <== ALWAYS TAKEN
434d6: 4eb9 0004 cdac jsr 4cdac <__errno>
434dc: 7209 moveq #9,%d1
434de: 2040 moveal %d0,%a0
434e0: 2081 movel %d1,%a0@
434e2: 6000 0082 braw 43566 <fpathconf+0xc2>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
434e6: 2068 0028 moveal %a0@(40),%a0
switch ( name ) {
434ea: 700b moveq #11,%d0
434ec: b081 cmpl %d1,%d0
434ee: 656a bcss 4355a <fpathconf+0xb6>
434f0: 303b 1a08 movew %pc@(434fa <fpathconf+0x56>,%d1:l:2),%d0
434f4: 48c0 extl %d0
434f6: 4efb 0802 jmp %pc@(434fa <fpathconf+0x56>,%d0:l)
434fa: 0018 .short 0x0018 <== NOT EXECUTED
434fc: 001e .short 0x001e <== NOT EXECUTED
434fe: 0024 .short 0x0024 <== NOT EXECUTED
43500: 002a .short 0x002a <== NOT EXECUTED
43502: 0030 .short 0x0030 <== NOT EXECUTED
43504: 0036 .short 0x0036 <== NOT EXECUTED
43506: 003c .short 0x003c <== NOT EXECUTED
43508: 0042 .short 0x0042 <== NOT EXECUTED
4350a: 0048 .short 0x0048 <== NOT EXECUTED
4350c: 004e .short 0x004e <== NOT EXECUTED
4350e: 0054 .short 0x0054 <== NOT EXECUTED
43510: 005a .short 0x005a <== NOT EXECUTED
case _PC_LINK_MAX:
return_value = the_limits->link_max;
43512: 2028 0038 movel %a0@(56),%d0
break;
43516: 6050 bras 43568 <fpathconf+0xc4>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
43518: 2028 003c movel %a0@(60),%d0
break;
4351c: 604a bras 43568 <fpathconf+0xc4>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
4351e: 2028 0040 movel %a0@(64),%d0
break;
43522: 6044 bras 43568 <fpathconf+0xc4>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
43524: 2028 0044 movel %a0@(68),%d0
break;
43528: 603e bras 43568 <fpathconf+0xc4>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
4352a: 2028 0048 movel %a0@(72),%d0
break;
4352e: 6038 bras 43568 <fpathconf+0xc4>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
43530: 2028 004c movel %a0@(76),%d0
break;
43534: 6032 bras 43568 <fpathconf+0xc4>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
43536: 2028 0054 movel %a0@(84),%d0
break;
4353a: 602c bras 43568 <fpathconf+0xc4>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
4353c: 2028 0058 movel %a0@(88),%d0
break;
43540: 6026 bras 43568 <fpathconf+0xc4>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
43542: 2028 0064 movel %a0@(100),%d0
break;
43546: 6020 bras 43568 <fpathconf+0xc4>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
43548: 2028 0050 movel %a0@(80),%d0
break;
4354c: 601a bras 43568 <fpathconf+0xc4>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
4354e: 2028 005c movel %a0@(92),%d0
break;
43552: 6014 bras 43568 <fpathconf+0xc4>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
43554: 2028 0060 movel %a0@(96),%d0
break;
43558: 600e bras 43568 <fpathconf+0xc4>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
4355a: 4eb9 0004 cdac jsr 4cdac <__errno>
43560: 2040 moveal %d0,%a0
43562: 7016 moveq #22,%d0
43564: 2080 movel %d0,%a0@
43566: 70ff moveq #-1,%d0
break;
}
return return_value;
}
43568: 242e fffc movel %fp@(-4),%d2
4356c: 4e5e unlk %fp <== NOT EXECUTED
00042b68 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
42b68: 4e56 0000 linkw %fp,#0
MSBUMP(free_calls, 1);
42b6c: 52b9 0005 d6fc addql #1,5d6fc <rtems_malloc_statistics+0xc>
#include <stdlib.h>
void free(
void *ptr
)
{
42b72: 2f02 movel %d2,%sp@-
42b74: 242e 0008 movel %fp@(8),%d2
MSBUMP(free_calls, 1);
if ( !ptr )
42b78: 676c beqs 42be6 <free+0x7e>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
42b7a: 7003 moveq #3,%d0
42b7c: b0b9 0005 d968 cmpl 5d968 <_System_state_Current>,%d0
42b82: 661a bnes 42b9e <free+0x36> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
42b84: 4eb9 0004 2d0c jsr 42d0c <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
42b8a: 4a00 tstb %d0
42b8c: 6610 bnes 42b9e <free+0x36>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
42b8e: 2d42 0008 movel %d2,%fp@(8)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
42b92: 242e fffc movel %fp@(-4),%d2
42b96: 4e5e unlk %fp
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
42b98: 4ef9 0004 2d80 jmp 42d80 <malloc_deferred_free>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
42b9e: 2079 0005 c6a8 moveal 5c6a8 <rtems_malloc_statistics_helpers>,%a0
42ba4: 4a88 tstl %a0
42ba6: 670a beqs 42bb2 <free+0x4a>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
42ba8: 2f02 movel %d2,%sp@-
42baa: 2068 0008 moveal %a0@(8),%a0
42bae: 4e90 jsr %a0@
42bb0: 588f addql #4,%sp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
42bb2: 2f02 movel %d2,%sp@-
42bb4: 2f39 0005 bfaa movel 5bfaa <RTEMS_Malloc_Heap>,%sp@-
42bba: 4eb9 0004 7360 jsr 47360 <_Protected_heap_Free>
42bc0: 508f addql #8,%sp
42bc2: 4a00 tstb %d0
42bc4: 6620 bnes 42be6 <free+0x7e>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
42bc6: 2079 0005 bfaa moveal 5bfaa <RTEMS_Malloc_Heap>,%a0
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
42bcc: 2f28 001c movel %a0@(28),%sp@-
42bd0: 2f28 0018 movel %a0@(24),%sp@-
42bd4: 2f02 movel %d2,%sp@-
42bd6: 4879 0005 b114 pea 5b114 <rtems_status_assoc+0x168>
42bdc: 4eb9 0004 3828 jsr 43828 <printk>
42be2: 4fef 0010 lea %sp@(16),%sp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
42be6: 242e fffc movel %fp@(-4),%d2
42bea: 4e5e unlk %fp
...
00045be0 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
45be0: 4e56 0000 linkw %fp,#0
45be4: 2f0b movel %a3,%sp@-
45be6: 2f0a movel %a2,%sp@-
45be8: 246e 0008 moveal %fp@(8),%a2
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
45bec: b5fc 0006 0348 cmpal #394056,%a2
45bf2: 6728 beqs 45c1c <free_user_env+0x3c> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
45bf4: 486a 0004 pea %a2@(4)
45bf8: 47f9 0004 4bc0 lea 44bc0 <rtems_filesystem_freenode>,%a3
45bfe: 4e93 jsr %a3@
rtems_filesystem_freenode( &env->root_directory);
45c00: 486a 0018 pea %a2@(24)
45c04: 4e93 jsr %a3@
free(env);
}
}
45c06: 266e fffc moveal %fp@(-4),%a3
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
45c0a: 508f addql #8,%sp
45c0c: 2d4a 0008 movel %a2,%fp@(8)
}
}
45c10: 246e fff8 moveal %fp@(-8),%a2
45c14: 4e5e unlk %fp
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
45c16: 4ef9 0004 4bd4 jmp 44bd4 <free>
}
}
45c1c: 246e fff8 moveal %fp@(-8),%a2 <== NOT EXECUTED
45c20: 266e fffc moveal %fp@(-4),%a3 <== NOT EXECUTED
45c24: 4e5e unlk %fp <== NOT EXECUTED
000436b8 <fsync>:
#include <rtems/seterr.h>
int fsync(
int fd
)
{
436b8: 4e56 0000 linkw %fp,#0
436bc: 202e 0008 movel %fp@(8),%d0
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
436c0: b0b9 0005 d822 cmpl 5d822 <rtems_libio_number_iops>,%d0
436c6: 641c bccs 436e4 <fsync+0x2c>
iop = rtems_libio_iop( fd );
436c8: 2200 movel %d0,%d1
436ca: ed88 lsll #6,%d0
436cc: e789 lsll #3,%d1
436ce: 2079 0005 ef08 moveal 5ef08 <rtems_libio_iops>,%a0
436d4: 9081 subl %d1,%d0
436d6: d1c0 addal %d0,%a0
rtems_libio_check_is_open(iop);
436d8: 2028 0014 movel %a0@(20),%d0
436dc: 0280 0000 0100 andil #256,%d0
436e2: 6612 bnes 436f6 <fsync+0x3e>
436e4: 4eb9 0004 cdac jsr 4cdac <__errno>
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
}
436ea: 4e5e unlk %fp
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
436ec: 2040 moveal %d0,%a0
436ee: 7009 moveq #9,%d0
436f0: 2080 movel %d0,%a0@
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
}
436f2: 70ff moveq #-1,%d0
436f4: 4e75 rts
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
436f6: 2268 0020 moveal %a0@(32),%a1
436fa: 2d48 0008 movel %a0,%fp@(8)
}
436fe: 4e5e unlk %fp
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
43700: 2269 0028 moveal %a1@(40),%a1
43704: 4ed1 jmp %a1@
...
00049bf4 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
49bf4: 4e56 ffec linkw %fp,#-20
49bf8: 202e 0008 movel %fp@(8),%d0
49bfc: 2f0a movel %a2,%sp@-
49bfe: 2f02 movel %d2,%sp@-
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
49c00: b0b9 0005 bff2 cmpl 5bff2 <rtems_libio_number_iops>,%d0
49c06: 641a bccs 49c22 <ftruncate+0x2e> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
49c08: 2200 movel %d0,%d1
49c0a: ed88 lsll #6,%d0
49c0c: e789 lsll #3,%d1
49c0e: 2479 0005 d6d8 moveal 5d6d8 <rtems_libio_iops>,%a2
49c14: 9081 subl %d1,%d0
49c16: d5c0 addal %d0,%a2
rtems_libio_check_is_open(iop);
49c18: 202a 0014 movel %a2@(20),%d0
49c1c: 0800 0008 btst #8,%d0
49c20: 660e bnes 49c30 <ftruncate+0x3c>
49c22: 4eb9 0004 c034 jsr 4c034 <__errno>
49c28: 7409 moveq #9,%d2
49c2a: 2040 moveal %d0,%a0
49c2c: 2082 movel %d2,%a0@
49c2e: 604c bras 49c7c <ftruncate+0x88>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
49c30: 44c0 movew %d0,%ccr
49c32: 670e beqs 49c42 <ftruncate+0x4e>
49c34: 4eb9 0004 c034 jsr 4c034 <__errno>
49c3a: 7216 moveq #22,%d1
49c3c: 2040 moveal %d0,%a0
49c3e: 2081 movel %d1,%a0@
49c40: 603a bras 49c7c <ftruncate+0x88>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
49c42: 4878 0014 pea 14 <OPER2>
49c46: 240e movel %fp,%d2
49c48: 486a 0018 pea %a2@(24)
49c4c: 0682 ffff ffec addil #-20,%d2
49c52: 2f02 movel %d2,%sp@-
49c54: 4eb9 0004 c854 jsr 4c854 <memcpy>
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
49c5a: 206e fff8 moveal %fp@(-8),%a0
49c5e: 2f02 movel %d2,%sp@-
49c60: 2068 0010 moveal %a0@(16),%a0
49c64: 4e90 jsr %a0@
49c66: 4fef 0010 lea %sp@(16),%sp
49c6a: 7201 moveq #1,%d1
49c6c: b280 cmpl %d0,%d1
49c6e: 6610 bnes 49c80 <ftruncate+0x8c>
rtems_set_errno_and_return_minus_one( EISDIR );
49c70: 4eb9 0004 c034 jsr 4c034 <__errno>
49c76: 2040 moveal %d0,%a0
49c78: 7015 moveq #21,%d0
49c7a: 2080 movel %d0,%a0@
49c7c: 70ff moveq #-1,%d0
49c7e: 6018 bras 49c98 <ftruncate+0xa4>
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
49c80: 206a 0020 moveal %a2@(32),%a0
49c84: 2f2e 0010 movel %fp@(16),%sp@-
49c88: 2f2e 000c movel %fp@(12),%sp@-
49c8c: 2f0a movel %a2,%sp@-
49c8e: 2068 0020 moveal %a0@(32),%a0
49c92: 4e90 jsr %a0@
49c94: 4fef 000c lea %sp@(12),%sp
}
49c98: 242e ffe4 movel %fp@(-28),%d2
49c9c: 246e ffe8 moveal %fp@(-24),%a2
49ca0: 4e5e unlk %fp <== NOT EXECUTED
00042430 <get_disk_entry>:
}
}
static rtems_disk_device *
get_disk_entry(dev_t dev, bool lookup_only)
{
42430: 4e56 0000 linkw %fp,#0
42434: 202e 000c movel %fp@(12),%d0
42438: 2f03 movel %d3,%sp@-
4243a: 162e 0013 moveb %fp@(19),%d3
4243e: 2f02 movel %d2,%sp@-
42440: 242e 0008 movel %fp@(8),%d2
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major < disktab_size && disktab != NULL) {
42444: b4b9 0006 025e cmpl 6025e <disktab_size>,%d2
4244a: 6432 bccs 4247e <get_disk_entry+0x4e> <== NEVER TAKEN
4244c: 2239 0006 0262 movel 60262 <disktab>,%d1
42452: 672a beqs 4247e <get_disk_entry+0x4e> <== NEVER TAKEN
rtems_disk_device_table *dtab = disktab + major;
42454: 2041 moveal %d1,%a0
42456: e78a lsll #3,%d2
42458: d1c2 addal %d2,%a0
if (minor < dtab->size && dtab->minor != NULL) {
4245a: b0a8 0004 cmpl %a0@(4),%d0
4245e: 641e bccs 4247e <get_disk_entry+0x4e> <== NEVER TAKEN
42460: 2050 moveal %a0@,%a0
42462: 4a88 tstl %a0
42464: 6718 beqs 4247e <get_disk_entry+0x4e> <== NEVER TAKEN
rtems_disk_device *dd = dtab->minor [minor];
42466: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
if (dd != NULL && !lookup_only) {
4246a: 4a88 tstl %a0
4246c: 6712 beqs 42480 <get_disk_entry+0x50>
4246e: 4a03 tstb %d3
42470: 660e bnes 42480 <get_disk_entry+0x50>
if (!dd->deleted) {
42472: 4a28 0030 tstb %a0@(48)
42476: 6606 bnes 4247e <get_disk_entry+0x4e>
++dd->uses;
42478: 52a8 0014 addql #1,%a0@(20)
4247c: 6002 bras 42480 <get_disk_entry+0x50>
} else {
dd = NULL;
4247e: 91c8 subal %a0,%a0
return dd;
}
}
return NULL;
}
42480: 241f movel %sp@+,%d2
42482: 2008 movel %a0,%d0
42484: 261f movel %sp@+,%d3
42486: 4e5e unlk %fp <== NOT EXECUTED
0005b1a0 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
5b1a0: 4e56 ffec linkw %fp,#-20
5b1a4: 202e 0008 movel %fp@(8),%d0
5b1a8: 2f0a movel %a2,%sp@-
5b1aa: 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 );
5b1ac: b0b9 0005 d9b2 cmpl 5d9b2 <rtems_libio_number_iops>,%d0
5b1b2: 6412 bccs 5b1c6 <getdents+0x26> <== NEVER TAKEN
5b1b4: 2200 movel %d0,%d1
5b1b6: ed88 lsll #6,%d0
5b1b8: e789 lsll #3,%d1
5b1ba: 2479 0005 f118 moveal 5f118 <rtems_libio_iops>,%a2
5b1c0: 9081 subl %d1,%d0
5b1c2: d5c0 addal %d0,%a2
5b1c4: 6002 bras 5b1c8 <getdents+0x28>
5b1c6: 95ca subal %a2,%a2 <== NOT EXECUTED
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
5b1c8: 4878 0014 pea 14 <OPER2>
5b1cc: 240e movel %fp,%d2
5b1ce: 486a 0018 pea %a2@(24)
5b1d2: 0682 ffff ffec addil #-20,%d2
5b1d8: 2f02 movel %d2,%sp@-
5b1da: 4eb9 0004 d988 jsr 4d988 <memcpy>
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
5b1e0: 206e fff8 moveal %fp@(-8),%a0
5b1e4: 2f02 movel %d2,%sp@-
5b1e6: 2068 0010 moveal %a0@(16),%a0
5b1ea: 4e90 jsr %a0@
5b1ec: 4fef 0010 lea %sp@(16),%sp
5b1f0: 7201 moveq #1,%d1
5b1f2: b280 cmpl %d0,%d1
5b1f4: 6710 beqs 5b206 <getdents+0x66>
rtems_set_errno_and_return_minus_one( ENOTDIR );
5b1f6: 4eb9 0004 cc98 jsr 4cc98 <__errno>
5b1fc: 2040 moveal %d0,%a0
5b1fe: 7014 moveq #20,%d0
5b200: 2080 movel %d0,%a0@
5b202: 70ff moveq #-1,%d0
5b204: 6018 bras 5b21e <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 );
5b206: 206a 0020 moveal %a2@(32),%a0
5b20a: 2f2e 0010 movel %fp@(16),%sp@-
5b20e: 2f2e 000c movel %fp@(12),%sp@-
5b212: 2f0a movel %a2,%sp@-
5b214: 2068 0008 moveal %a0@(8),%a0
5b218: 4e90 jsr %a0@
5b21a: 4fef 000c lea %sp@(12),%sp
}
5b21e: 242e ffe4 movel %fp@(-28),%d2
5b222: 246e ffe8 moveal %fp@(-24),%a2
5b226: 4e5e unlk %fp
...
000433e8 <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
433e8: 4e56 ffe0 linkw %fp,#-32
433ec: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@
433f0: 262e 0008 movel %fp@(8),%d3
433f4: 282e 000c movel %fp@(12),%d4
433f8: 246e 0010 moveal %fp@(16),%a2
433fc: 2a2e 0014 movel %fp@(20),%d5
43400: 2c2e 0018 movel %fp@(24),%d6
FILE *fp;
int match;
init_etc_passwd_group();
43404: 4eb9 0004 3308 jsr 43308 <init_etc_passwd_group>
if ((fp = fopen("/etc/group", "r")) == NULL)
4340a: 4879 0005 cedb pea 5cedb <_global_impure_ptr+0xc7>
43410: 4879 0005 c830 pea 5c830 <rtems_status_assoc+0x21a>
43416: 4eb9 0004 d3e6 jsr 4d3e6 <fopen>
4341c: 508f addql #8,%sp
4341e: 2400 movel %d0,%d2
43420: 660e bnes 43430 <getgr_r+0x48>
rtems_set_errno_and_return_minus_one( EINVAL );
43422: 4eb9 0004 cbf0 jsr 4cbf0 <__errno>
43428: 7216 moveq #22,%d1
4342a: 2040 moveal %d0,%a0
4342c: 2081 movel %d1,%a0@
4342e: 6068 bras 43498 <getgr_r+0xb0>
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
43430: 49fa fcf4 lea %pc@(43126 <scangr>),%a4
goto error_einval;
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
43434: 47f9 0004 ead4 lea 4ead4 <strcmp>,%a3
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
4343a: 2f06 movel %d6,%sp@-
4343c: 2f05 movel %d5,%sp@-
4343e: 2f0a movel %a2,%sp@-
43440: 2f02 movel %d2,%sp@-
43442: 4e94 jsr %a4@
43444: 4fef 0010 lea %sp@(16),%sp
43448: 4a80 tstl %d0
4344a: 6736 beqs 43482 <getgr_r+0x9a>
goto error_einval;
if (name) {
4344c: 4a83 tstl %d3
4344e: 670e beqs 4345e <getgr_r+0x76>
match = (strcmp(grp->gr_name, name) == 0);
43450: 2f03 movel %d3,%sp@-
43452: 2f12 movel %a2@,%sp@-
43454: 4e93 jsr %a3@
43456: 508f addql #8,%sp
43458: 4a80 tstl %d0
4345a: 57c0 seq %d0
4345c: 600a bras 43468 <getgr_r+0x80>
} else {
match = (grp->gr_gid == gid);
4345e: 4280 clrl %d0
43460: 302a 0008 movew %a2@(8),%d0
43464: b880 cmpl %d0,%d4
43466: 57c0 seq %d0
43468: 49c0 extbl %d0
4346a: 4480 negl %d0
}
if (match) {
4346c: 67cc beqs 4343a <getgr_r+0x52> <== NEVER TAKEN
fclose(fp);
4346e: 2f02 movel %d2,%sp@-
43470: 4eb9 0004 cd24 jsr 4cd24 <fclose>
*result = grp;
43476: 206e 001c moveal %fp@(28),%a0
return 0;
4347a: 588f addql #4,%sp
4347c: 4280 clrl %d0
match = (grp->gr_gid == gid);
}
if (match) {
fclose(fp);
*result = grp;
4347e: 208a movel %a2,%a0@
return 0;
43480: 6018 bras 4349a <getgr_r+0xb2>
}
}
error_einval:
fclose(fp);
43482: 2f02 movel %d2,%sp@-
43484: 4eb9 0004 cd24 jsr 4cd24 <fclose>
rtems_set_errno_and_return_minus_one( EINVAL );
4348a: 4eb9 0004 cbf0 jsr 4cbf0 <__errno>
43490: 588f addql #4,%sp
43492: 2040 moveal %d0,%a0
43494: 7016 moveq #22,%d0
43496: 2080 movel %d0,%a0@
43498: 70ff moveq #-1,%d0
}
4349a: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
434a0: 4e5e unlk %fp <== NOT EXECUTED
00042bf0 <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
42bf0: 4e56 fff8 linkw %fp,#-8
42bf4: 2f0a movel %a2,%sp@-
42bf6: 246e 0008 moveal %fp@(8),%a2
42bfa: 2f02 movel %d2,%sp@-
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
42bfc: 4a8a tstl %a2
42bfe: 6610 bnes 42c10 <gettimeofday+0x20> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
42c00: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
42c06: 2040 moveal %d0,%a0 <== NOT EXECUTED
42c08: 700e moveq #14,%d0 <== NOT EXECUTED
42c0a: 2080 movel %d0,%a0@ <== NOT EXECUTED
42c0c: 70ff moveq #-1,%d0 <== NOT EXECUTED
42c0e: 6032 bras 42c42 <gettimeofday+0x52> <== NOT EXECUTED
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
42c10: 203c 0000 0700 movel #1792,%d0
42c16: 40c2 movew %sr,%d2
42c18: 8082 orl %d2,%d0
42c1a: 46c0 movew %d0,%sr
_TOD_Get( &now );
42c1c: 486e fff8 pea %fp@(-8)
42c20: 4eb9 0004 674c jsr 4674c <_TOD_Get>
_ISR_Enable(level);
42c26: 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;
42c28: 243c 0000 03e8 movel #1000,%d2
* Timezone information ignored by the OS proper. Per email
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
42c2e: 588f addql #4,%sp
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
42c30: 202e fffc movel %fp@(-4),%d0
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
42c34: 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;
42c38: 24ae fff8 movel %fp@(-8),%a2@
time->tv_usec = useconds;
42c3c: 2540 0004 movel %d0,%a2@(4)
42c40: 4280 clrl %d0
}
42c42: 242e fff0 movel %fp@(-16),%d2
42c46: 246e fff4 moveal %fp@(-12),%a2
42c4a: 4e5e unlk %fp <== NOT EXECUTED
0004b8f0 <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 )
4b8f0: 7001 moveq #1,%d0
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
4b8f2: 4e56 0000 linkw %fp,#0
4b8f6: 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 )
4b8fa: 2268 0018 moveal %a0@(24),%a1
4b8fe: b0a9 0048 cmpl %a1@(72),%d0
4b902: 6610 bnes 4b914 <imfs_dir_open+0x24> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
4b904: 4280 clrl %d0
4b906: 4281 clrl %d1
4b908: 2140 000c movel %d0,%a0@(12)
4b90c: 2141 0010 movel %d1,%a0@(16)
return 0;
4b910: 4280 clrl %d0
4b912: 6002 bras 4b916 <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 */
4b914: 70ff moveq #-1,%d0 <== NOT EXECUTED
iop->offset = 0;
return 0;
}
4b916: 4e5e unlk %fp <== NOT EXECUTED
0004bb2e <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
4bb2e: 4e56 0000 linkw %fp,#0
4bb32: 206e 000c moveal %fp@(12),%a0
4bb36: 2f0a movel %a2,%sp@-
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
4bb38: 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 );
4bb3a: 200a movel %a2,%d0
4bb3c: 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 ) )
4bb42: b0aa 004c cmpl %a2@(76),%d0
4bb46: 670e beqs 4bb56 <imfs_dir_rmnod+0x28>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
4bb48: 4eb9 0004 c034 jsr 4c034 <__errno>
4bb4e: 2040 moveal %d0,%a0
4bb50: 705a moveq #90,%d0
4bb52: 2080 movel %d0,%a0@
4bb54: 6016 bras 4bb6c <imfs_dir_rmnod+0x3e>
4bb56: 2068 0010 moveal %a0@(16),%a0
/*
* You cannot remove the file system root node.
*/
if ( rtems_filesystem_is_root_location(pathloc) )
4bb5a: b5e8 001c cmpal %a0@(28),%a2
4bb5e: 6610 bnes 4bb70 <imfs_dir_rmnod+0x42>
rtems_set_errno_and_return_minus_one( EBUSY );
4bb60: 4eb9 0004 c034 jsr 4c034 <__errno>
4bb66: 7210 moveq #16,%d1
4bb68: 2040 moveal %d0,%a0
4bb6a: 2081 movel %d1,%a0@
4bb6c: 70ff moveq #-1,%d0
4bb6e: 601a bras 4bb8a <imfs_dir_rmnod+0x5c>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
4bb70: 4aaa 0058 tstl %a2@(88)
4bb74: 66ea bnes 4bb60 <imfs_dir_rmnod+0x32> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
4bb76: 2f0a movel %a2,%sp@-
4bb78: 4eb9 0004 98d4 jsr 498d4 <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
4bb7e: 2f0a movel %a2,%sp@-
4bb80: 4eb9 0004 9918 jsr 49918 <IMFS_check_node_remove>
return 0;
4bb86: 508f addql #8,%sp
4bb88: 4280 clrl %d0
}
4bb8a: 246e fffc moveal %fp@(-4),%a2
4bb8e: 4e5e unlk %fp
...
00043308 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
43308: 4e56 0000 linkw %fp,#0
4330c: 2f0a movel %a2,%sp@-
4330e: 2f02 movel %d2,%sp@-
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
43310: 4a39 0005 e5f4 tstb 5e5f4 <etc_passwd_initted.6386>
43316: 6600 00c4 bnew 433dc <init_etc_passwd_group+0xd4>
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
4331a: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
4331e: 45f9 0004 d3e6 lea 4d3e6 <fopen>,%a2
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
43324: 4879 0005 c7b6 pea 5c7b6 <rtems_status_assoc+0x1a0>
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
4332a: 7001 moveq #1,%d0
4332c: 13c0 0005 e5f4 moveb %d0,5e5f4 <etc_passwd_initted.6386>
mkdir("/etc", 0777);
43332: 4eb9 0004 3b1c jsr 43b1c <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
43338: 4879 0005 cedb pea 5cedb <_global_impure_ptr+0xc7>
4333e: 4879 0005 c7bb pea 5c7bb <rtems_status_assoc+0x1a5>
43344: 4e92 jsr %a2@
43346: 4fef 0010 lea %sp@(16),%sp
4334a: 4a80 tstl %d0
4334c: 670c beqs 4335a <init_etc_passwd_group+0x52>
fclose(fp);
4334e: 2f00 movel %d0,%sp@-
43350: 4eb9 0004 cd24 jsr 4cd24 <fclose>
43356: 588f addql #4,%sp
43358: 602e bras 43388 <init_etc_passwd_group+0x80>
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
4335a: 4879 0005 c7c7 pea 5c7c7 <rtems_status_assoc+0x1b1>
43360: 4879 0005 c7bb pea 5c7bb <rtems_status_assoc+0x1a5>
43366: 4e92 jsr %a2@
43368: 508f addql #8,%sp
4336a: 2400 movel %d0,%d2
4336c: 671a beqs 43388 <init_etc_passwd_group+0x80> <== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
4336e: 2f00 movel %d0,%sp@-
43370: 4879 0005 c7c9 pea 5c7c9 <rtems_status_assoc+0x1b3>
43376: 4eb9 0004 d4c8 jsr 4d4c8 <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
4337c: 2f02 movel %d2,%sp@-
4337e: 4eb9 0004 cd24 jsr 4cd24 <fclose>
43384: 4fef 000c lea %sp@(12),%sp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
43388: 4879 0005 cedb pea 5cedb <_global_impure_ptr+0xc7>
4338e: 45f9 0004 d3e6 lea 4d3e6 <fopen>,%a2
43394: 4879 0005 c830 pea 5c830 <rtems_status_assoc+0x21a>
4339a: 4e92 jsr %a2@
4339c: 508f addql #8,%sp
4339e: 4a80 tstl %d0
433a0: 670c beqs 433ae <init_etc_passwd_group+0xa6>
fclose(fp);
433a2: 2f00 movel %d0,%sp@-
433a4: 4eb9 0004 cd24 jsr 4cd24 <fclose>
433aa: 588f addql #4,%sp
433ac: 602e bras 433dc <init_etc_passwd_group+0xd4>
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
433ae: 4879 0005 c7c7 pea 5c7c7 <rtems_status_assoc+0x1b1>
433b4: 4879 0005 c830 pea 5c830 <rtems_status_assoc+0x21a>
433ba: 4e92 jsr %a2@
433bc: 508f addql #8,%sp
433be: 2400 movel %d0,%d2
433c0: 671a beqs 433dc <init_etc_passwd_group+0xd4> <== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
433c2: 2f00 movel %d0,%sp@-
433c4: 4879 0005 c83b pea 5c83b <rtems_status_assoc+0x225>
433ca: 4eb9 0004 d4c8 jsr 4d4c8 <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
433d0: 2f02 movel %d2,%sp@-
433d2: 4eb9 0004 cd24 jsr 4cd24 <fclose>
433d8: 4fef 000c lea %sp@(12),%sp
}
}
433dc: 242e fff8 movel %fp@(-8),%d2
433e0: 246e fffc moveal %fp@(-4),%a2
433e4: 4e5e unlk %fp <== NOT EXECUTED
0004467a <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
4467a: 4e56 fff4 linkw %fp,#-12
4467e: 222e 0008 movel %fp@(8),%d1
44682: 48d7 040c moveml %d2-%d3/%a2,%sp@
44686: 246e 000c moveal %fp@(12),%a2
if (tty->termios.c_iflag & ISTRIP)
4468a: 202a 0030 movel %a2@(48),%d0
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
4468e: 1401 moveb %d1,%d2
if (tty->termios.c_iflag & ISTRIP)
44690: 0800 0005 btst #5,%d0
44694: 6704 beqs 4469a <iproc+0x20> <== ALWAYS TAKEN
c &= 0x7f;
44696: 747f moveq #127,%d2 <== NOT EXECUTED
44698: c481 andl %d1,%d2 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
4469a: 0800 0009 btst #9,%d0
4469e: 6724 beqs 446c4 <iproc+0x4a>
c = tolower (c);
446a0: 2079 0005 c1b0 moveal 5c1b0 <__ctype_ptr__>,%a0
446a6: 7603 moveq #3,%d3
446a8: 0282 0000 00ff andil #255,%d2
446ae: 1230 2801 moveb %a0@(00000001,%d2:l),%d1
446b2: 49c1 extbl %d1
446b4: c283 andl %d3,%d1
446b6: 163c 0001 moveb #1,%d3
446ba: b681 cmpl %d1,%d3
446bc: 6606 bnes 446c4 <iproc+0x4a>
446be: 0682 0000 0020 addil #32,%d2
if (c == '\r') {
446c4: 4281 clrl %d1
446c6: 1202 moveb %d2,%d1
446c8: 760d moveq #13,%d3
446ca: b681 cmpl %d1,%d3
446cc: 6610 bnes 446de <iproc+0x64>
if (tty->termios.c_iflag & IGNCR)
446ce: 4a00 tstb %d0
446d0: 6d00 0104 bltw 447d6 <iproc+0x15c>
return 0;
if (tty->termios.c_iflag & ICRNL)
446d4: 0800 0008 btst #8,%d0
446d8: 671a beqs 446f4 <iproc+0x7a> <== NEVER TAKEN
c = '\n';
446da: 740a moveq #10,%d2
446dc: 6016 bras 446f4 <iproc+0x7a>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
446de: 760a moveq #10,%d3
446e0: b681 cmpl %d1,%d3
446e2: 660a bnes 446ee <iproc+0x74>
446e4: 0800 0006 btst #6,%d0
446e8: 670a beqs 446f4 <iproc+0x7a> <== ALWAYS TAKEN
c = '\r';
446ea: 740d moveq #13,%d2 <== NOT EXECUTED
446ec: 6006 bras 446f4 <iproc+0x7a> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
446ee: 4a02 tstb %d2
446f0: 6700 00a8 beqw 4479a <iproc+0x120>
446f4: 222a 003c movel %a2@(60),%d1
446f8: 0801 0001 btst #1,%d1
446fc: 6700 009c beqw 4479a <iproc+0x120>
if (c == tty->termios.c_cc[VERASE]) {
44700: 4283 clrl %d3
44702: 162a 0043 moveb %a2@(67),%d3
44706: 4280 clrl %d0
44708: 1002 moveb %d2,%d0
4470a: b680 cmpl %d0,%d3
4470c: 6604 bnes 44712 <iproc+0x98>
erase (tty, 0);
4470e: 42a7 clrl %sp@-
44710: 600e bras 44720 <iproc+0xa6>
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
44712: 4283 clrl %d3
44714: 162a 0044 moveb %a2@(68),%d3
44718: b680 cmpl %d0,%d3
4471a: 6610 bnes 4472c <iproc+0xb2>
erase (tty, 1);
4471c: 4878 0001 pea 1 <ADD>
44720: 2f0a movel %a2,%sp@-
44722: 4eba fdc4 jsr %pc@(444e8 <erase>)
return 0;
44726: 508f addql #8,%sp
44728: 6000 00ac braw 447d6 <iproc+0x15c>
}
else if (c == tty->termios.c_cc[VEOF]) {
4472c: 4283 clrl %d3
4472e: 162a 0045 moveb %a2@(69),%d3
44732: b680 cmpl %d0,%d3
44734: 6700 009c beqw 447d2 <iproc+0x158>
return 1;
} else if (c == '\n') {
44738: 760a moveq #10,%d3
4473a: b680 cmpl %d0,%d3
4473c: 6622 bnes 44760 <iproc+0xe6>
if (tty->termios.c_lflag & (ECHO | ECHONL))
4473e: 7048 moveq #72,%d0
44740: c280 andl %d0,%d1
44742: 670c beqs 44750 <iproc+0xd6> <== NEVER TAKEN
echo (c, tty);
44744: 2f0a movel %a2,%sp@-
44746: 4878 000a pea a <LASTO>
4474a: 4eba fd14 jsr %pc@(44460 <echo>)
4474e: 508f addql #8,%sp
tty->cbuf[tty->ccount++] = c;
44750: 202a 0020 movel %a2@(32),%d0
44754: 206a 001c moveal %a2@(28),%a0
44758: 720a moveq #10,%d1
4475a: 1181 0800 moveb %d1,%a0@(00000000,%d0:l)
4475e: 6032 bras 44792 <iproc+0x118>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
44760: 4283 clrl %d3
44762: 162a 004c moveb %a2@(76),%d3
44766: b680 cmpl %d0,%d3
44768: 670a beqs 44774 <iproc+0xfa> <== NEVER TAKEN
4476a: 4283 clrl %d3
4476c: 162a 0051 moveb %a2@(81),%d3
44770: b680 cmpl %d0,%d3
44772: 6626 bnes 4479a <iproc+0x120> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
44774: 44c1 movew %d1,%ccr <== NOT EXECUTED
44776: 6a0e bpls 44786 <iproc+0x10c> <== NOT EXECUTED
echo (c, tty);
44778: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4477a: 4280 clrl %d0 <== NOT EXECUTED
4477c: 1002 moveb %d2,%d0 <== NOT EXECUTED
4477e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
44780: 4eba fcde jsr %pc@(44460 <echo>) <== NOT EXECUTED
44784: 508f addql #8,%sp <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
44786: 202a 0020 movel %a2@(32),%d0 <== NOT EXECUTED
4478a: 206a 001c moveal %a2@(28),%a0 <== NOT EXECUTED
4478e: 1182 0800 moveb %d2,%a0@(00000000,%d0:l) <== NOT EXECUTED
44792: 5280 addql #1,%d0
44794: 2540 0020 movel %d0,%a2@(32)
44798: 6038 bras 447d2 <iproc+0x158>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
4479a: 2039 0005 c128 movel 5c128 <rtems_termios_cbufsize>,%d0
447a0: 5380 subql #1,%d0
447a2: b0aa 0020 cmpl %a2@(32),%d0
447a6: 6f2e bles 447d6 <iproc+0x15c> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
447a8: 7008 moveq #8,%d0
447aa: c0aa 003c andl %a2@(60),%d0
447ae: 670e beqs 447be <iproc+0x144> <== NEVER TAKEN
echo (c, tty);
447b0: 2f0a movel %a2,%sp@-
447b2: 4280 clrl %d0
447b4: 1002 moveb %d2,%d0
447b6: 2f00 movel %d0,%sp@-
447b8: 4eba fca6 jsr %pc@(44460 <echo>)
447bc: 508f addql #8,%sp
tty->cbuf[tty->ccount++] = c;
447be: 202a 0020 movel %a2@(32),%d0
447c2: 206a 001c moveal %a2@(28),%a0
447c6: 1182 0800 moveb %d2,%a0@(00000000,%d0:l)
447ca: 5280 addql #1,%d0
447cc: 2540 0020 movel %d0,%a2@(32)
447d0: 6004 bras 447d6 <iproc+0x15c>
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
447d2: 7001 moveq #1,%d0
447d4: 6002 bras 447d8 <iproc+0x15e>
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
447d6: 4280 clrl %d0
}
447d8: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
447de: 4e5e unlk %fp <== NOT EXECUTED
00059b64 <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
59b64: 4280 clrl %d0 <== NOT EXECUTED
* These are directly supported (and completely correct) in the posix api.
*/
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
59b66: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return 0;
}
59b6a: 4e5e unlk %fp <== NOT EXECUTED
000432d0 <libc_wrapup>:
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
432d0: 7003 moveq #3,%d0
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
432d2: 4e56 0000 linkw %fp,#0
432d6: 2f0a movel %a2,%sp@-
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
432d8: b0b9 0005 d968 cmpl 5d968 <_System_state_Current>,%d0
432de: 664c bnes 4332c <libc_wrapup+0x5c> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
432e0: 2479 0005 b6fa moveal 5b6fa <_global_impure_ptr>,%a2
432e6: b5f9 0005 c1b4 cmpal 5c1b4 <_impure_ptr>,%a2
432ec: 6710 beqs 432fe <libc_wrapup+0x2e>
_wrapup_reent(_global_impure_ptr);
432ee: 2f0a movel %a2,%sp@-
432f0: 4eb9 0004 ca9e jsr 4ca9e <_wrapup_reent>
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
432f6: 588f addql #4,%sp
432f8: 23ca 0005 c1b4 movel %a2,5c1b4 <_impure_ptr>
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
432fe: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
43304: 45f9 0004 c168 lea 4c168 <fclose>,%a2
4330a: 2f28 0004 movel %a0@(4),%sp@-
4330e: 4e92 jsr %a2@
fclose (stdout);
43310: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
43316: 2f28 0008 movel %a0@(8),%sp@-
4331a: 4e92 jsr %a2@
fclose (stderr);
4331c: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
43322: 2f28 000c movel %a0@(12),%sp@-
43326: 4e92 jsr %a2@
43328: 4fef 000c lea %sp@(12),%sp
}
4332c: 246e fffc moveal %fp@(-4),%a2
43330: 4e5e unlk %fp <== NOT EXECUTED
00044b78 <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
44b78: 4e56 ffdc linkw %fp,#-36
44b7c: 48d7 001c moveml %d2-%d4,%sp@
44b80: 282e 0008 movel %fp@(8),%d4
44b84: 262e 000c movel %fp@(12),%d3
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
44b88: 660e bnes 44b98 <lstat+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
44b8a: 4eb9 0004 e3fc jsr 4e3fc <__errno>
44b90: 2040 moveal %d0,%a0
44b92: 700e moveq #14,%d0
44b94: 2080 movel %d0,%a0@
44b96: 605a bras 44bf2 <lstat+0x7a>
status = rtems_filesystem_evaluate_path( path, strlen( path ),
44b98: 2f04 movel %d4,%sp@-
44b9a: 240e movel %fp,%d2
44b9c: 0682 ffff ffec addil #-20,%d2
44ba2: 4eb9 0004 f8e4 jsr 4f8e4 <strlen>
44ba8: 4297 clrl %sp@
44baa: 2f02 movel %d2,%sp@-
44bac: 42a7 clrl %sp@-
44bae: 2f00 movel %d0,%sp@-
44bb0: 2f04 movel %d4,%sp@-
44bb2: 4eb9 0004 44c0 jsr 444c0 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
44bb8: 4fef 0014 lea %sp@(20),%sp
44bbc: 4a80 tstl %d0
44bbe: 6632 bnes 44bf2 <lstat+0x7a> <== NEVER TAKEN
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
44bc0: 4878 0046 pea 46 <DBL_MANT_DIG+0x11>
44bc4: 42a7 clrl %sp@-
44bc6: 2f03 movel %d3,%sp@-
44bc8: 4eb9 0004 ec8c jsr 4ec8c <memset>
status = (*loc.handlers->fstat_h)( &loc, buf );
44bce: 206e fff4 moveal %fp@(-12),%a0
44bd2: 2f03 movel %d3,%sp@-
44bd4: 2f02 movel %d2,%sp@-
44bd6: 2068 0018 moveal %a0@(24),%a0
44bda: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
44bdc: 2f02 movel %d2,%sp@-
44bde: 2d40 ffe8 movel %d0,%fp@(-24)
44be2: 4eb9 0004 468c jsr 4468c <rtems_filesystem_freenode>
return status;
44be8: 202e ffe8 movel %fp@(-24),%d0
44bec: 4fef 0018 lea %sp@(24),%sp
44bf0: 6002 bras 44bf4 <lstat+0x7c>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
return -1;
44bf2: 70ff moveq #-1,%d0
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
44bf4: 4cee 001c ffdc moveml %fp@(-36),%d2-%d4
44bfa: 4e5e unlk %fp <== NOT EXECUTED
00042e54 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
42e54: 4e56 0000 linkw %fp,#0
void *return_this;
MSBUMP(malloc_calls, 1);
42e58: 52b9 0005 d6f4 addql #1,5d6f4 <rtems_malloc_statistics+0x4>
#include "malloc_p.h"
void *malloc(
size_t size
)
{
42e5e: 2f03 movel %d3,%sp@-
42e60: 2f02 movel %d2,%sp@-
42e62: 242e 0008 movel %fp@(8),%d2
MSBUMP(malloc_calls, 1);
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
42e66: 4eb9 0004 2d4a jsr 42d4a <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
42e6c: 4a82 tstl %d2
42e6e: 677e beqs 42eee <malloc+0x9a>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
42e70: 7003 moveq #3,%d0
42e72: b0b9 0005 d968 cmpl 5d968 <_System_state_Current>,%d0
42e78: 660a bnes 42e84 <malloc+0x30>
!malloc_is_system_state_OK() )
42e7a: 4eb9 0004 2d0c jsr 42d0c <malloc_is_system_state_OK>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
42e80: 4a00 tstb %d0
42e82: 676a beqs 42eee <malloc+0x9a> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
42e84: 42a7 clrl %sp@-
42e86: 42a7 clrl %sp@-
42e88: 2f02 movel %d2,%sp@-
42e8a: 2f39 0005 bfaa movel 5bfaa <RTEMS_Malloc_Heap>,%sp@-
42e90: 4eb9 0004 7320 jsr 47320 <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
42e96: 4fef 0010 lea %sp@(16),%sp
42e9a: 4a80 tstl %d0
42e9c: 6626 bnes 42ec4 <malloc+0x70>
if (rtems_malloc_sbrk_helpers)
42e9e: 2079 0005 c6a4 moveal 5c6a4 <rtems_malloc_sbrk_helpers>,%a0
42ea4: 4a88 tstl %a0
42ea6: 670e beqs 42eb6 <malloc+0x62>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
42ea8: 2f02 movel %d2,%sp@-
42eaa: 2068 0004 moveal %a0@(4),%a0
42eae: 4e90 jsr %a0@
if ( !return_this ) {
42eb0: 588f addql #4,%sp
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
42eb2: 2600 movel %d0,%d3
if ( !return_this ) {
42eb4: 6610 bnes 42ec6 <malloc+0x72>
errno = ENOMEM;
42eb6: 4eb9 0004 c034 jsr 4c034 <__errno>
42ebc: 2040 moveal %d0,%a0
42ebe: 700c moveq #12,%d0
42ec0: 2080 movel %d0,%a0@
42ec2: 602a bras 42eee <malloc+0x9a>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
42ec4: 2600 movel %d0,%d3
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
42ec6: 2079 0005 c6a0 moveal 5c6a0 <rtems_malloc_dirty_helper>,%a0
42ecc: 4a88 tstl %a0
42ece: 6708 beqs 42ed8 <malloc+0x84>
(*rtems_malloc_dirty_helper)( return_this, size );
42ed0: 2f02 movel %d2,%sp@-
42ed2: 2f03 movel %d3,%sp@-
42ed4: 4e90 jsr %a0@
42ed6: 508f addql #8,%sp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
42ed8: 2079 0005 c6a8 moveal 5c6a8 <rtems_malloc_statistics_helpers>,%a0
42ede: 4a88 tstl %a0
42ee0: 670e beqs 42ef0 <malloc+0x9c>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
42ee2: 2f03 movel %d3,%sp@-
42ee4: 2068 0004 moveal %a0@(4),%a0
42ee8: 4e90 jsr %a0@
42eea: 588f addql #4,%sp
42eec: 6002 bras 42ef0 <malloc+0x9c>
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
return NULL;
42eee: 4283 clrl %d3
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
return return_this;
}
42ef0: 2003 movel %d3,%d0
42ef2: 242e fff8 movel %fp@(-8),%d2
42ef6: 262e fffc movel %fp@(-4),%d3
42efa: 4e5e unlk %fp
...
00042be0 <malloc_get_statistics>:
#include "malloc_p.h"
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
42be0: 4e56 0000 linkw %fp,#0
42be4: 2f02 movel %d2,%sp@-
42be6: 242e 0008 movel %fp@(8),%d2
if ( !stats )
42bea: 6732 beqs 42c1e <malloc_get_statistics+0x3e> <== NEVER TAKEN
return -1;
_RTEMS_Lock_allocator();
42bec: 2f39 0005 d598 movel 5d598 <_RTEMS_Allocator_Mutex>,%sp@-
42bf2: 4eb9 0004 6104 jsr 46104 <_API_Mutex_Lock>
*stats = rtems_malloc_statistics;
42bf8: 4878 002c pea 2c <OPER2+0x18>
42bfc: 4879 0005 d3c0 pea 5d3c0 <rtems_malloc_statistics>
42c02: 2f02 movel %d2,%sp@-
42c04: 4eb9 0004 c620 jsr 4c620 <memcpy>
_RTEMS_Unlock_allocator();
42c0a: 2f39 0005 d598 movel 5d598 <_RTEMS_Allocator_Mutex>,%sp@-
42c10: 4eb9 0004 6164 jsr 46164 <_API_Mutex_Unlock>
return 0;
42c16: 4fef 0014 lea %sp@(20),%sp
42c1a: 4280 clrl %d0
42c1c: 6002 bras 42c20 <malloc_get_statistics+0x40>
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
if ( !stats )
return -1;
42c1e: 70ff moveq #-1,%d0
_RTEMS_Lock_allocator();
*stats = rtems_malloc_statistics;
_RTEMS_Unlock_allocator();
return 0;
}
42c20: 242e fffc movel %fp@(-4),%d2
42c24: 4e5e unlk %fp <== NOT EXECUTED
00042ed4 <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
42ed4: 4e56 fff4 linkw %fp,#-12
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
42ed8: 2039 0005 d9f4 movel 5d9f4 <RTEMS_Malloc_Sbrk_amount>,%d0
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
42ede: 48d7 040c moveml %d2-%d3/%a2,%sp@
42ee2: 262e 0008 movel %fp@(8),%d3
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
42ee6: 4a80 tstl %d0
42ee8: 676a beqs 42f54 <malloc_sbrk_extend_and_allocate+0x80><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
42eea: 2403 movel %d3,%d2
42eec: d480 addl %d0,%d2
starting_address = (void *) sbrk(the_size);
42eee: 45f9 0004 072e lea 4072e <sbrk>,%a2
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
42ef4: 4c40 2002 remul %d0,%d2,%d2
42ef8: 4c00 2800 mulsl %d0,%d2
starting_address = (void *) sbrk(the_size);
42efc: 2f02 movel %d2,%sp@-
42efe: 4e92 jsr %a2@
if ( starting_address == (void*) -1 )
42f00: 588f addql #4,%sp
42f02: 72ff moveq #-1,%d1
42f04: b280 cmpl %d0,%d1
42f06: 674c beqs 42f54 <malloc_sbrk_extend_and_allocate+0x80>
return (void *) 0;
if ( !_Protected_heap_Extend(
42f08: 2f02 movel %d2,%sp@-
42f0a: 2f00 movel %d0,%sp@-
42f0c: 2f39 0005 c13a movel 5c13a <RTEMS_Malloc_Heap>,%sp@-
42f12: 4eb9 0004 7354 jsr 47354 <_Protected_heap_Extend>
42f18: 4fef 000c lea %sp@(12),%sp
42f1c: 4a00 tstb %d0
42f1e: 6616 bnes 42f36 <malloc_sbrk_extend_and_allocate+0x62>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
42f20: 4482 negl %d2
42f22: 2f02 movel %d2,%sp@-
42f24: 4e92 jsr %a2@
errno = ENOMEM;
42f26: 4eb9 0004 c274 jsr 4c274 <__errno>
return (void *) 0;
42f2c: 588f addql #4,%sp
return (void *) 0;
if ( !_Protected_heap_Extend(
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
errno = ENOMEM;
42f2e: 2040 moveal %d0,%a0
42f30: 700c moveq #12,%d0
42f32: 2080 movel %d0,%a0@
42f34: 601e bras 42f54 <malloc_sbrk_extend_and_allocate+0x80>
42f36: 42a7 clrl %sp@-
return (void *) 0;
}
MSBUMP(space_available, the_size);
42f38: d5b9 0005 d9c8 addl %d2,5d9c8 <rtems_malloc_statistics>
42f3e: 42a7 clrl %sp@-
42f40: 2f03 movel %d3,%sp@-
42f42: 2f39 0005 c13a movel 5c13a <RTEMS_Malloc_Heap>,%sp@-
42f48: 4eb9 0004 7314 jsr 47314 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
42f4e: 4fef 0010 lea %sp@(16),%sp
42f52: 6002 bras 42f56 <malloc_sbrk_extend_and_allocate+0x82>
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
starting_address = (void *) sbrk(the_size);
if ( starting_address == (void*) -1 )
return (void *) 0;
42f54: 4280 clrl %d0
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
42f56: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
42f5c: 4e5e unlk %fp <== NOT EXECUTED
00042f60 <malloc_sbrk_initialize>:
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
42f60: 4e56 0000 linkw %fp,#0
42f64: 222e 000c movel %fp@(12),%d1
42f68: 202e 0008 movel %fp@(8),%d0
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
42f6c: 23c1 0005 d9f4 movel %d1,5d9f4 <RTEMS_Malloc_Sbrk_amount>
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
42f72: 4a80 tstl %d0
42f74: 6626 bnes 42f9c <malloc_sbrk_initialize+0x3c>
uaddress = (uintptr_t)sbrk(length);
42f76: 2f01 movel %d1,%sp@-
42f78: 4eb9 0004 072e jsr 4072e <sbrk>
if (uaddress == (uintptr_t) -1) {
42f7e: 588f addql #4,%sp
42f80: 72ff moveq #-1,%d1
42f82: b280 cmpl %d0,%d1
42f84: 660a bnes 42f90 <malloc_sbrk_initialize+0x30> <== NEVER TAKEN
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
42f86: 4878 001a pea 1a <OPER2+0x6>
42f8a: 4eb9 0004 6108 jsr 46108 <rtems_fatal_error_occurred>
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
42f90: 7203 moveq #3,%d1 <== NOT EXECUTED
42f92: c280 andl %d0,%d1 <== NOT EXECUTED
42f94: 6706 beqs 42f9c <malloc_sbrk_initialize+0x3c> <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
42f96: 5880 addql #4,%d0 <== NOT EXECUTED
42f98: 72fc moveq #-4,%d1 <== NOT EXECUTED
42f9a: c081 andl %d1,%d0 <== NOT EXECUTED
}
starting_address = (void *)uaddress;
}
return starting_address;
}
42f9c: 4e5e unlk %fp <== NOT EXECUTED
0004b60e <memfile_lseek>:
{
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
4b60e: 7006 moveq #6,%d0
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
4b610: 4e56 fff0 linkw %fp,#-16
4b614: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4b618: 246e 0008 moveal %fp@(8),%a2
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4b61c: 266a 0018 moveal %a2@(24),%a3
if (the_jnode->type == IMFS_LINEAR_FILE) {
4b620: b0ab 0048 cmpl %a3@(72),%d0
4b624: 6620 bnes 4b646 <memfile_lseek+0x38>
if (iop->offset > the_jnode->info.linearfile.size)
4b626: 202b 004c movel %a3@(76),%d0
4b62a: 222b 0050 movel %a3@(80),%d1
4b62e: 242a 000c movel %a2@(12),%d2
4b632: 262a 0010 movel %a2@(16),%d3
4b636: 9681 subl %d1,%d3
4b638: 9580 subxl %d0,%d2
4b63a: 6f44 bles 4b680 <memfile_lseek+0x72> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
4b63c: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
4b640: 2541 0010 movel %d1,%a2@(16) <== NOT EXECUTED
4b644: 603a bras 4b680 <memfile_lseek+0x72> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
4b646: 2f2a 0010 movel %a2@(16),%sp@-
4b64a: 2f2a 000c movel %a2@(12),%sp@-
4b64e: 2f0b movel %a3,%sp@-
4b650: 4eb9 0004 b24c jsr 4b24c <IMFS_memfile_extend>
4b656: 4fef 000c lea %sp@(12),%sp
4b65a: 4a80 tstl %d0
4b65c: 6712 beqs 4b670 <memfile_lseek+0x62>
rtems_set_errno_and_return_minus_one( ENOSPC );
4b65e: 4eb9 0004 c034 jsr 4c034 <__errno>
4b664: 761c moveq #28,%d3
4b666: 2040 moveal %d0,%a0
4b668: 2083 movel %d3,%a0@
4b66a: 70ff moveq #-1,%d0
4b66c: 72ff moveq #-1,%d1
4b66e: 6018 bras 4b688 <memfile_lseek+0x7a>
iop->size = the_jnode->info.file.size;
4b670: 202b 004c movel %a3@(76),%d0
4b674: 222b 0050 movel %a3@(80),%d1
4b678: 2540 0004 movel %d0,%a2@(4)
4b67c: 2541 0008 movel %d1,%a2@(8)
}
return iop->offset;
4b680: 202a 000c movel %a2@(12),%d0
4b684: 222a 0010 movel %a2@(16),%d1
}
4b688: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4b68e: 4e5e unlk %fp
...
0004b502 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
4b502: 4e56 fff0 linkw %fp,#-16
4b506: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4b50a: 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))
4b50e: 202b 0014 movel %a3@(20),%d0
4b512: 0280 0000 0204 andil #516,%d0
uint32_t mode
)
{
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4b518: 246b 0018 moveal %a3@(24),%a2
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
4b51c: 674c beqs 4b56a <memfile_open+0x68>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
4b51e: 7006 moveq #6,%d0
4b520: b0aa 0048 cmpl %a2@(72),%d0
4b524: 6644 bnes 4b56a <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;
4b526: 7405 moveq #5,%d2 <== NOT EXECUTED
4b528: 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;
4b52c: 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;
4b530: 4282 clrl %d2 <== NOT EXECUTED
4b532: 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;
4b534: 222a 0054 movel %a2@(84),%d1 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
4b538: 2542 004c movel %d2,%a2@(76) <== NOT EXECUTED
4b53c: 2543 0050 movel %d3,%a2@(80) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
4b540: 42aa 0054 clrl %a2@(84) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
4b544: 42aa 0058 clrl %a2@(88) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
4b548: 42aa 005c clrl %a2@(92) <== NOT EXECUTED
if ((count != 0)
4b54c: 4a80 tstl %d0 <== NOT EXECUTED
4b54e: 671a beqs 4b56a <memfile_open+0x68> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
4b550: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b552: 76ff moveq #-1,%d3 <== NOT EXECUTED
4b554: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4b556: 42a7 clrl %sp@- <== NOT EXECUTED
4b558: 42a7 clrl %sp@- <== NOT EXECUTED
4b55a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4b55c: 4eb9 0004 b35c jsr 4b35c <IMFS_memfile_write> <== NOT EXECUTED
4b562: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4b566: b680 cmpl %d0,%d3 <== NOT EXECUTED
4b568: 6730 beqs 4b59a <memfile_open+0x98> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
4b56a: 202b 0014 movel %a3@(20),%d0
4b56e: 0280 0000 0200 andil #512,%d0
4b574: 6710 beqs 4b586 <memfile_open+0x84>
iop->offset = the_jnode->info.file.size;
4b576: 202a 004c movel %a2@(76),%d0
4b57a: 222a 0050 movel %a2@(80),%d1
4b57e: 2740 000c movel %d0,%a3@(12)
4b582: 2741 0010 movel %d1,%a3@(16)
iop->size = the_jnode->info.file.size;
return 0;
4b586: 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;
4b588: 222a 004c movel %a2@(76),%d1
4b58c: 242a 0050 movel %a2@(80),%d2
4b590: 2741 0004 movel %d1,%a3@(4)
4b594: 2742 0008 movel %d2,%a3@(8)
return 0;
4b598: 6002 bras 4b59c <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;
4b59a: 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;
}
4b59c: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4b5a2: 4e5e unlk %fp <== NOT EXECUTED
00042f20 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
42f20: 4e56 ffd4 linkw %fp,#-44
42f24: 48d7 001c moveml %d2-%d4,%sp@
42f28: 262e 000c movel %fp@(12),%d3
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
42f2c: 2003 movel %d3,%d0
42f2e: 0280 0000 f000 andil #61440,%d0
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
42f34: 282e 0008 movel %fp@(8),%d4
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
42f38: 0c80 0000 4000 cmpil #16384,%d0
42f3e: 6732 beqs 42f72 <mknod+0x52>
42f40: 6212 bhis 42f54 <mknod+0x34>
42f42: 0c80 0000 1000 cmpil #4096,%d0
42f48: 6728 beqs 42f72 <mknod+0x52>
42f4a: 0c80 0000 2000 cmpil #8192,%d0
42f50: 6612 bnes 42f64 <mknod+0x44>
42f52: 601e bras 42f72 <mknod+0x52>
42f54: 0c80 0000 6000 cmpil #24576,%d0
42f5a: 6716 beqs 42f72 <mknod+0x52>
42f5c: 0c80 0000 8000 cmpil #32768,%d0
42f62: 670e beqs 42f72 <mknod+0x52> <== ALWAYS TAKEN
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
42f64: 4eb9 0004 c034 jsr 4c034 <__errno>
42f6a: 2040 moveal %d0,%a0
42f6c: 7016 moveq #22,%d0
42f6e: 2080 movel %d0,%a0@
42f70: 6064 bras 42fd6 <mknod+0xb6>
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
42f72: 240e movel %fp,%d2
42f74: 0682 ffff ffe4 addil #-28,%d2
42f7a: 2f02 movel %d2,%sp@-
42f7c: 486e fff8 pea %fp@(-8)
42f80: 2f04 movel %d4,%sp@-
42f82: 4eb9 0004 3840 jsr 43840 <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
42f88: 486e fffc pea %fp@(-4)
42f8c: d8ae fff8 addl %fp@(-8),%d4
42f90: 2f02 movel %d2,%sp@-
42f92: 206e fff0 moveal %fp@(-16),%a0
42f96: 2f04 movel %d4,%sp@-
42f98: 2068 0004 moveal %a0@(4),%a0
42f9c: 4e90 jsr %a0@
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
42f9e: 4fef 0018 lea %sp@(24),%sp
42fa2: 4a80 tstl %d0
42fa4: 6630 bnes 42fd6 <mknod+0xb6>
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
42fa6: 2f02 movel %d2,%sp@-
42fa8: 2f2e 0014 movel %fp@(20),%sp@-
42fac: 2f2e 0010 movel %fp@(16),%sp@-
42fb0: 206e fff0 moveal %fp@(-16),%a0
42fb4: 2f03 movel %d3,%sp@-
42fb6: 2f2e fffc movel %fp@(-4),%sp@-
42fba: 2068 0014 moveal %a0@(20),%a0
42fbe: 4e90 jsr %a0@
rtems_filesystem_freenode( &temp_loc );
42fc0: 2f02 movel %d2,%sp@-
42fc2: 2d40 ffe0 movel %d0,%fp@(-32)
42fc6: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
return result;
42fcc: 202e ffe0 movel %fp@(-32),%d0
42fd0: 4fef 0018 lea %sp@(24),%sp
42fd4: 6002 bras 42fd8 <mknod+0xb8>
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
return -1;
42fd6: 70ff moveq #-1,%d0
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
42fd8: 4cee 001c ffd4 moveml %fp@(-44),%d2-%d4
42fde: 4e5e unlk %fp
...
00043066 <mount>:
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
43066: 7001 moveq #1,%d0
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
43068: 4e56 ffbc linkw %fp,#-68
4306c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
43070: 2a2e 0008 movel %fp@(8),%d5
43074: 262e 000c movel %fp@(12),%d3
43078: 266e 0010 moveal %fp@(16),%a3
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
4307c: b0ae 0014 cmpl %fp@(20),%d0
43080: 6510 bcss 43092 <mount+0x2c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
43082: 2f0b movel %a3,%sp@-
43084: 4eb9 0004 9fb4 jsr 49fb4 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
4308a: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
4308c: 2a40 moveal %d0,%a5
if ( !mount_h )
4308e: 4a80 tstl %d0
43090: 6610 bnes 430a2 <mount+0x3c>
rtems_set_errno_and_return_minus_one( EINVAL );
43092: 4eb9 0004 c034 jsr 4c034 <__errno>
43098: 7816 moveq #22,%d4
4309a: 2040 moveal %d0,%a0
4309c: 2084 movel %d4,%a0@
4309e: 6000 0222 braw 432c2 <mount+0x25c>
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
430a2: 4a83 tstl %d3
430a4: 56c2 sne %d2
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
430a6: 283c 0005 ac98 movel #371864,%d4
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
430ac: 4482 negl %d2
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
430ae: 4a02 tstb %d2
430b0: 6702 beqs 430b4 <mount+0x4e>
430b2: 2803 movel %d3,%d4
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
430b4: 2f0b movel %a3,%sp@-
430b6: 45f9 0004 d3a0 lea 4d3a0 <strlen>,%a2
430bc: 4e92 jsr %a2@
430be: 588f addql #4,%sp
430c0: 2c00 movel %d0,%d6
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
430c2: 4a85 tstl %d5
430c4: 670c beqs 430d2 <mount+0x6c>
430c6: 2f05 movel %d5,%sp@-
430c8: 4e92 jsr %a2@
430ca: 588f addql #4,%sp
430cc: 2840 moveal %d0,%a4
430ce: 528c addql #1,%a4
430d0: 6002 bras 430d4 <mount+0x6e>
430d2: 99cc subal %a4,%a4
size_t target_size = strlen( target ) + 1;
430d4: 2f04 movel %d4,%sp@-
430d6: 4eb9 0004 d3a0 jsr 4d3a0 <strlen>
430dc: 588f addql #4,%sp
430de: 2200 movel %d0,%d1
430e0: 5281 addql #1,%d1
430e2: 2e00 movel %d0,%d7
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
430e4: 41f4 6875 lea %a4@(00000075,%d6:l),%a0
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
430e8: 2d41 ffe8 movel %d1,%fp@(-24)
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
430ec: 4870 1800 pea %a0@(00000000,%d1:l)
430f0: 4878 0001 pea 1 <ADD>
430f4: 4eb9 0004 27cc jsr 427cc <calloc>
if ( mt_entry != NULL ) {
430fa: 508f addql #8,%sp
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
430fc: 2440 moveal %d0,%a2
if ( mt_entry != NULL ) {
430fe: 4a80 tstl %d0
43100: 6770 beqs 43172 <mount+0x10c> <== NEVER TAKEN
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
43102: 2206 movel %d6,%d1
43104: 5281 addql #1,%d1
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
43106: 2c00 movel %d0,%d6
43108: 0686 0000 0074 addil #116,%d6
memcpy( str, filesystemtype, filesystemtype_size );
4310e: 2f01 movel %d1,%sp@-
43110: 2f0b movel %a3,%sp@-
43112: 47f9 0004 c854 lea 4c854 <memcpy>,%a3
43118: 2f06 movel %d6,%sp@-
4311a: 2d41 ffe4 movel %d1,%fp@(-28)
4311e: 4e93 jsr %a3@
mt_entry->type = str;
str += filesystemtype_size;
43120: 222e ffe4 movel %fp@(-28),%d1
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
43124: 2546 006c movel %d6,%a2@(108)
str += filesystemtype_size;
43128: dc81 addl %d1,%d6
memcpy( str, source_or_null, source_size );
4312a: 2f0c movel %a4,%sp@-
4312c: 2f05 movel %d5,%sp@-
4312e: 2f06 movel %d6,%sp@-
43130: 4e93 jsr %a3@
mt_entry->dev = str;
43132: 2546 0070 movel %d6,%a2@(112)
str += source_size;
memcpy( str, target, target_size );
43136: 2f2e ffe8 movel %fp@(-24),%sp@-
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
4313a: dc8c addl %a4,%d6
memcpy( str, target, target_size );
4313c: 2f04 movel %d4,%sp@-
4313e: 2f06 movel %d6,%sp@-
43140: 4e93 jsr %a3@
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
43142: 206e 0014 moveal %fp@(20),%a0
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
43146: 4fef 0024 lea %sp@(36),%sp
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
4314a: 2546 0068 movel %d6,%a2@(104)
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
4314e: 254a 002c movel %a2,%a2@(44)
mt_entry->options = options;
43152: 2548 0030 movel %a0,%a2@(48)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
43156: 4878 0030 pea 30 <OPER2+0x1c>
4315a: 4879 0005 b14c pea 5b14c <rtems_filesystem_default_pathconf>
43160: 486a 0038 pea %a2@(56)
43164: 4e93 jsr %a3@
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
43166: 4fef 000c lea %sp@(12),%sp
4316a: 4a02 tstb %d2
4316c: 6700 00b2 beqw 43220 <mount+0x1ba>
43170: 6010 bras 43182 <mount+0x11c>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
43172: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
43178: 760c moveq #12,%d3 <== NOT EXECUTED
4317a: 2040 moveal %d0,%a0 <== NOT EXECUTED
4317c: 2083 movel %d3,%a0@ <== NOT EXECUTED
4317e: 6000 0142 braw 432c2 <mount+0x25c> <== NOT EXECUTED
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
43182: 4878 0001 pea 1 <ADD>
43186: 280e movel %fp,%d4
43188: 0684 ffff ffec addil #-20,%d4
4318e: 2f04 movel %d4,%sp@-
43190: 4878 0007 pea 7 <TRUNCDFSF>
43194: 2f07 movel %d7,%sp@-
43196: 2f03 movel %d3,%sp@-
43198: 4eb9 0004 2a88 jsr 42a88 <rtems_filesystem_evaluate_path>
4319e: 4fef 0014 lea %sp@(20),%sp
431a2: 72ff moveq #-1,%d1
431a4: b280 cmpl %d0,%d1
431a6: 6700 00fa beqw 432a2 <mount+0x23c>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
431aa: 206e fff8 moveal %fp@(-8),%a0
431ae: 2f04 movel %d4,%sp@-
431b0: 2068 0010 moveal %a0@(16),%a0
431b4: 4e90 jsr %a0@
431b6: 588f addql #4,%sp
431b8: 7201 moveq #1,%d1
431ba: b280 cmpl %d0,%d1
431bc: 670e beqs 431cc <mount+0x166>
errno = ENOTDIR;
431be: 4eb9 0004 c034 jsr 4c034 <__errno>
431c4: 7414 moveq #20,%d2
431c6: 2040 moveal %d0,%a0
431c8: 2082 movel %d2,%a0@
431ca: 6020 bras 431ec <mount+0x186>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
431cc: 2f2e ffec movel %fp@(-20),%sp@-
431d0: 487a fe12 pea %pc@(42fe4 <is_node_fs_root>)
431d4: 4eb9 0004 3018 jsr 43018 <rtems_filesystem_mount_iterate>
431da: 508f addql #8,%sp
431dc: 4a00 tstb %d0
431de: 6712 beqs 431f2 <mount+0x18c>
errno = EBUSY;
431e0: 4eb9 0004 c034 jsr 4c034 <__errno>
431e6: 7210 moveq #16,%d1
431e8: 2040 moveal %d0,%a0
431ea: 2081 movel %d1,%a0@
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
target, target_length, RTEMS_LIBIO_PERMS_RWX, &loc, true ) == -1 )
goto cleanup_and_bail;
loc_to_free = &loc;
431ec: 2604 movel %d4,%d3
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
errno = EBUSY;
goto cleanup_and_bail;
431ee: 6000 00b4 braw 432a4 <mount+0x23e>
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
431f2: 206e fff8 moveal %fp@(-8),%a0
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
target, target_length, RTEMS_LIBIO_PERMS_RWX, &loc, true ) == -1 )
goto cleanup_and_bail;
loc_to_free = &loc;
431f6: 2604 movel %d4,%d3
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
431f8: 256e ffec 0008 movel %fp@(-20),%a2@(8)
mt_entry->mt_point_node.handlers = loc.handlers;
431fe: 256e fff4 0010 movel %fp@(-12),%a2@(16)
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
43204: 256e fffc 0018 movel %fp@(-4),%a2@(24)
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
4320a: 2548 0014 movel %a0,%a2@(20)
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
4320e: 2f0a movel %a2,%sp@-
43210: 2068 0020 moveal %a0@(32),%a0
43214: 4e90 jsr %a0@
43216: 588f addql #4,%sp
43218: 4a80 tstl %d0
4321a: 6600 0088 bnew 432a4 <mount+0x23e>
4321e: 601e bras 4323e <mount+0x1d8>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
43220: 203c 0005 c018 movel #376856,%d0
43226: b0b9 0005 c014 cmpl 5c014 <mount_chain>,%d0
4322c: 670e beqs 4323c <mount+0x1d6> <== ALWAYS TAKEN
errno = EINVAL;
4322e: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
43234: 2040 moveal %d0,%a0 <== NOT EXECUTED
43236: 7016 moveq #22,%d0 <== NOT EXECUTED
43238: 2080 movel %d0,%a0@ <== NOT EXECUTED
4323a: 6066 bras 432a2 <mount+0x23c> <== NOT EXECUTED
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
4323c: 4283 clrl %d3
* mt_point_node.node_access will be left to null to indicate that this
* is the root of the entire file system.
*/
}
if ( (*mount_h)( mt_entry, data ) ) {
4323e: 2f2e 0018 movel %fp@(24),%sp@-
43242: 2f0a movel %a2,%sp@-
43244: 4e95 jsr %a5@
43246: 508f addql #8,%sp
43248: 4a80 tstl %d0
4324a: 6710 beqs 4325c <mount+0x1f6>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
4324c: 206e fff8 moveal %fp@(-8),%a0
43250: 2f0a movel %a2,%sp@-
43252: 2068 0028 moveal %a0@(40),%a0
43256: 4e90 jsr %a0@
goto cleanup_and_bail;
43258: 588f addql #4,%sp
4325a: 6048 bras 432a4 <mount+0x23e>
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
4325c: 4eba fd9e jsr %pc@(42ffc <rtems_libio_lock>)
43260: 2f0a movel %a2,%sp@-
43262: 4879 0005 c014 pea 5c014 <mount_chain>
43268: 4eb9 0004 635c jsr 4635c <_Chain_Append>
4326e: 2f39 0005 d6e0 movel 5d6e0 <rtems_libio_semaphore>,%sp@-
43274: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
4327a: 4fef 000c lea %sp@(12),%sp
4327e: 4a02 tstb %d2
43280: 663c bnes 432be <mount+0x258>
rtems_filesystem_root = mt_entry->mt_fs_root;
43282: 4878 0014 pea 14 <OPER2>
43286: 486a 001c pea %a2@(28)
4328a: 2079 0005 c130 moveal 5c130 <rtems_current_user_env>,%a0
43290: 41e8 0018 lea %a0@(24),%a0
43294: 2f08 movel %a0,%sp@-
43296: 4eb9 0004 c854 jsr 4c854 <memcpy>
4329c: 4fef 000c lea %sp@(12),%sp
432a0: 601c bras 432be <mount+0x258>
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
432a2: 4283 clrl %d3 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
432a4: 2f0a movel %a2,%sp@-
432a6: 4eb9 0004 2b68 jsr 42b68 <free>
if ( loc_to_free )
432ac: 588f addql #4,%sp
432ae: 4a83 tstl %d3
432b0: 6710 beqs 432c2 <mount+0x25c> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
432b2: 2f03 movel %d3,%sp@-
432b4: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
432ba: 588f addql #4,%sp
432bc: 6004 bras 432c2 <mount+0x25c>
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
432be: 4280 clrl %d0
432c0: 6002 bras 432c4 <mount+0x25e>
free( mt_entry );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
432c2: 70ff moveq #-1,%d0
}
432c4: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
432ca: 4e5e unlk %fp
...
00043454 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
43454: 4e56 ffec linkw %fp,#-20
43458: 48d7 007c moveml %d2-%d6,%sp@
4345c: 262e 0008 movel %fp@(8),%d3
43460: 242e 000c movel %fp@(12),%d2
43464: 282e 0010 movel %fp@(16),%d4
43468: 2a2e 0014 movel %fp@(20),%d5
4346c: 2c2e 0018 movel %fp@(24),%d6
int rv = -1;
if (target != NULL) {
43470: 4a82 tstl %d2
43472: 6734 beqs 434a8 <mount_and_make_target_path+0x54>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
43474: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
43478: 2f02 movel %d2,%sp@-
4347a: 4eb9 0004 3d1c jsr 43d1c <rtems_mkdir>
if (rv == 0) {
43480: 508f addql #8,%sp
43482: 4a80 tstl %d0
43484: 6630 bnes 434b6 <mount_and_make_target_path+0x62><== NEVER TAKEN
rv = mount(
43486: 2d46 0018 movel %d6,%fp@(24)
4348a: 2d45 0014 movel %d5,%fp@(20)
4348e: 2d44 0010 movel %d4,%fp@(16)
43492: 2d42 000c movel %d2,%fp@(12)
43496: 2d43 0008 movel %d3,%fp@(8)
} else {
errno = EINVAL;
}
return rv;
}
4349a: 4cee 007c ffec moveml %fp@(-20),%d2-%d6
434a0: 4e5e unlk %fp
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
434a2: 4ef9 0004 3542 jmp 43542 <mount>
options,
data
);
}
} else {
errno = EINVAL;
434a8: 4eb9 0004 c4bc jsr 4c4bc <__errno>
434ae: 2040 moveal %d0,%a0
434b0: 7016 moveq #22,%d0
434b2: 2080 movel %d0,%a0@
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
434b4: 70ff moveq #-1,%d0
} else {
errno = EINVAL;
}
return rv;
}
434b6: 4cee 007c ffec moveml %fp@(-20),%d2-%d6
434bc: 4e5e unlk %fp <== NOT EXECUTED
00054084 <msdos_creat_node>:
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
54084: 72ff moveq #-1,%d1
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
54086: 4e56 ff40 linkw %fp,#-192
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
time_t time_ret = 0;
uint16_t time_val = 0;
5408a: 4240 clrw %d0
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
5408c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
54090: 246e 0008 moveal %fp@(8),%a2
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
54094: 47ee ffa8 lea %fp@(-88),%a3
54098: 2a3c 0005 8848 movel #362568,%d5
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
5409e: 206a 0010 moveal %a2@(16),%a0
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
540a2: 2612 movel %a2@,%d3
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
540a4: 2868 0034 moveal %a0@(52),%a4
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
540a8: 4878 0020 pea 20 <OPER2+0xc>
540ac: 2045 moveal %d5,%a0
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
540ae: 242e 0010 movel %fp@(16),%d2
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
540b2: 42a7 clrl %sp@-
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
540b4: 2c2e 0014 movel %fp@(20),%d6
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
540b8: 2f0b movel %a3,%sp@-
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
540ba: 2a6e 000c moveal %fp@(12),%a5
540be: 2d41 fff0 movel %d1,%fp@(-16)
540c2: 282e 001c movel %fp@(28),%d4
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
540c6: 2d41 fff4 movel %d1,%fp@(-12)
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
time_t time_ret = 0;
uint16_t time_val = 0;
540ca: 3d40 fffc movew %d0,%fp@(-4)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
540ce: 42ae fff8 clrl %fp@(-8)
time_t time_ret = 0;
uint16_t time_val = 0;
uint16_t date = 0;
540d2: 3d40 fffe movew %d0,%fp@(-2)
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
540d6: 42ae ffe8 clrl %fp@(-24)
dir_pos->sname.ofs = 0;
540da: 42ae ffec clrl %fp@(-20)
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
540de: 4e90 jsr %a0@
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
540e0: 4878 0040 pea 40 <DBL_MANT_DIG+0xb>
540e4: 2045 moveal %d5,%a0
540e6: 42a7 clrl %sp@-
540e8: 486e ff68 pea %fp@(-152)
540ec: 4e90 jsr %a0@
name_type = msdos_long_to_short (name, name_len,
540ee: 4878 000b pea b <LASTO+0x1>
540f2: 2f0b movel %a3,%sp@-
540f4: 2f06 movel %d6,%sp@-
540f6: 2f02 movel %d2,%sp@-
540f8: 4eb9 0005 4fe8 jsr 54fe8 <msdos_long_to_short>
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
540fe: 4fef 0024 lea %sp@(36),%sp
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
name_type = msdos_long_to_short (name, name_len,
54102: 2e00 movel %d0,%d7
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
54104: 4200 clrb %d0
/* set up last write date and time */
time_ret = time(NULL);
54106: 4297 clrl %sp@
name_type = msdos_long_to_short (name, name_len,
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
54108: 1d40 ffb4 moveb %d0,%fp@(-76)
/* set up last write date and time */
time_ret = time(NULL);
5410c: 4eb9 0005 bc80 jsr 5bc80 <time>
if ( time_ret == -1 )
54112: 588f addql #4,%sp
54114: 72ff moveq #-1,%d1
54116: b280 cmpl %d0,%d1
54118: 6700 02c2 beqw 543dc <msdos_creat_node+0x358>
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
5411c: 486e fffc pea %fp@(-4)
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
54120: 4285 clrl %d5
/* set up last write date and time */
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
54122: 486e fffe pea %fp@(-2)
54126: 2f00 movel %d0,%sp@-
54128: 4eb9 0005 7318 jsr 57318 <msdos_date_unix2dos>
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
5412e: 4fef 000c lea %sp@(12),%sp
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
54132: 4280 clrl %d0
54134: 302e fffc movew %fp@(-4),%d0
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
54138: 3a2e fffe movew %fp@(-2),%d5
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
5413c: 42ae ffc4 clrl %fp@(-60)
static inline uint16_t m68k_swap_u16(
uint16_t value
)
{
return (((value & 0xff) << 8) | ((value >> 8) & 0xff));
54140: 2200 movel %d0,%d1
54142: e088 lsrl #8,%d0
54144: e189 lsll #8,%d1
54146: 8280 orl %d0,%d1
54148: 2005 movel %d5,%d0
5414a: e08d lsrl #8,%d5
5414c: e188 lsll #8,%d0
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
5414e: 3d41 ffb6 movew %d1,%fp@(-74)
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
54152: 3d41 ffbe movew %d1,%fp@(-66)
54156: 8085 orl %d5,%d0
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
54158: 7a01 moveq #1,%d5
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
5415a: 3d40 ffb8 movew %d0,%fp@(-72)
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
5415e: 3d40 ffc0 movew %d0,%fp@(-64)
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
54162: 3d40 ffba movew %d0,%fp@(-70)
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
54166: ba8d cmpl %a5,%d5
54168: 660a bnes 54174 <msdos_creat_node+0xf0>
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
5416a: 7210 moveq #16,%d1
5416c: 102b 000b moveb %a3@(11),%d0
54170: 6000 009c braw 5420e <msdos_creat_node+0x18a>
}
else if (type == MSDOS_HARD_LINK) {
54174: 7a03 moveq #3,%d5
54176: ba8d cmpl %a5,%d5
54178: 6600 0098 bnew 54212 <msdos_creat_node+0x18e>
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
5417c: 2044 moveal %d4,%a0 <== NOT EXECUTED
5417e: 226a 0010 moveal %a2@(16),%a1 <== NOT EXECUTED
54182: 2028 0020 movel %a0@(32),%d0 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
54186: 2069 0034 moveal %a1@(52),%a0 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
5418a: 6610 bnes 5419c <msdos_creat_node+0x118> <== NOT EXECUTED
5418c: 4281 clrl %d1 <== NOT EXECUTED
5418e: 1228 000a moveb %a0@(10),%d1 <== NOT EXECUTED
54192: c285 andl %d5,%d1 <== NOT EXECUTED
54194: 6706 beqs 5419c <msdos_creat_node+0x118> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
54196: 2028 001a movel %a0@(26),%d0 <== NOT EXECUTED
5419a: 600e bras 541aa <msdos_creat_node+0x126> <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
5419c: 4281 clrl %d1 <== NOT EXECUTED
5419e: 1228 0005 moveb %a0@(5),%d1 <== NOT EXECUTED
541a2: 5580 subql #2,%d0 <== NOT EXECUTED
541a4: e3a8 lsll %d1,%d0 <== NOT EXECUTED
541a6: d0a8 002c addl %a0@(44),%d0 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
541aa: 2044 moveal %d4,%a0 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
541ac: 47ee ffc8 lea %fp@(-56),%a3 <== NOT EXECUTED
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
541b0: 4284 clrl %d4 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
541b2: 2228 0024 movel %a0@(36),%d1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
541b6: 2040 moveal %d0,%a0 <== NOT EXECUTED
541b8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
541ba: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
541be: 3814 movew %a4@,%d4 <== NOT EXECUTED
541c0: 5384 subql #1,%d4 <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
541c2: c881 andl %d1,%d4 <== NOT EXECUTED
541c4: 2f04 movel %d4,%sp@- <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
541c6: 4284 clrl %d4 <== NOT EXECUTED
541c8: 182c 0002 moveb %a4@(2),%d4 <== NOT EXECUTED
541cc: e8a9 lsrl %d4,%d1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
541ce: 4870 1800 pea %a0@(00000000,%d1:l) <== NOT EXECUTED
541d2: 2f09 movel %a1,%sp@- <== NOT EXECUTED
541d4: 4eb9 0005 07c2 jsr 507c2 <_fat_block_read> <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
541da: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
541de: 4a80 tstl %d0 <== NOT EXECUTED
541e0: 6d00 01fa bltw 543dc <msdos_creat_node+0x358> <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
541e4: 7220 moveq #32,%d1 <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
541e6: 102e ffd3 moveb %fp@(-45),%d0 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
541ea: 1d6e ffd5 ffb5 moveb %fp@(-43),%fp@(-75) <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
541f0: 3d6e ffd6 ffb6 movew %fp@(-42),%fp@(-74) <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
541f6: 3d6e ffd8 ffb8 movew %fp@(-40),%fp@(-72) <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
541fc: 3d6e ffe2 ffc2 movew %fp@(-30),%fp@(-62) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
54202: 3d6e ffdc ffbc movew %fp@(-36),%fp@(-68) <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
54208: 2d6e ffe4 ffc4 movel %fp@(-28),%fp@(-60) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
5420e: 8081 orl %d1,%d0
54210: 6008 bras 5421a <msdos_creat_node+0x196>
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
54212: 7a20 moveq #32,%d5
54214: 102b 000b moveb %a3@(11),%d0
54218: 8085 orl %d5,%d0
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
name_type, &dir_pos, short_node);
5421a: 280e movel %fp,%d4
5421c: 0684 ffff ffa8 addil #-88,%d4
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
54222: 2a0e movel %fp,%d5
54224: 0685 ffff ffe8 addil #-24,%d5
5422a: 2f04 movel %d4,%sp@-
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
5422c: 1d40 ffb3 moveb %d0,%fp@(-77)
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
54230: 2f05 movel %d5,%sp@-
54232: 2f07 movel %d7,%sp@-
54234: 2f06 movel %d6,%sp@-
54236: 2f02 movel %d2,%sp@-
54238: 4878 0001 pea 1 <ADD>
5423c: 2f0a movel %a2,%sp@-
5423e: 4eb9 0005 617a jsr 5617a <msdos_get_name_node>
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
54244: 4fef 001c lea %sp@(28),%sp
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
54248: 2400 movel %d0,%d2
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
5424a: 6600 0192 bnew 543de <msdos_creat_node+0x35a>
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
5424e: 7001 moveq #1,%d0
54250: b08d cmpl %a5,%d0
54252: 6600 018a bnew 543de <msdos_creat_node+0x35a>
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
54256: 486e fff8 pea %fp@(-8)
5425a: 2f05 movel %d5,%sp@-
5425c: 2f2a 0010 movel %a2@(16),%sp@-
54260: 4eb9 0004 fa28 jsr 4fa28 <fat_file_open>
if (rc != RC_OK)
54266: 4fef 000c lea %sp@(12),%sp
* to do
*/
if (type == MSDOS_DIRECTORY)
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
5426a: 2400 movel %d0,%d2
if (rc != RC_OK)
5426c: 6600 0156 bnew 543c4 <msdos_creat_node+0x340>
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
54270: 266e fff8 moveal %fp@(-8),%a3
fat_fd->fat_file_type = FAT_DIRECTORY;
54274: 7201 moveq #1,%d1
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
54276: 4bf9 0005 87d8 lea 587d8 <memcpy>,%a5
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
5427c: 240e movel %fp,%d2
5427e: 0682 ffff ff88 addil #-120,%d2
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
54284: 7a20 moveq #32,%d5
54286: 4845 swap %d5
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
54288: 2741 0010 movel %d1,%a3@(16)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
5428c: 2745 0014 movel %d5,%a3@(20)
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
54290: 2a0e movel %fp,%d5
54292: 0685 ffff ff68 addil #-152,%d5
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
54298: 42ab 0018 clrl %a3@(24)
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
5429c: 4878 0020 pea 20 <OPER2+0xc>
542a0: 2f04 movel %d4,%sp@-
542a2: 2f05 movel %d5,%sp@-
542a4: 4e95 jsr %a5@
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
542a6: 4878 0020 pea 20 <OPER2+0xc>
542aa: 2f04 movel %d4,%sp@-
542ac: 2f02 movel %d2,%sp@-
542ae: 4e95 jsr %a5@
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
542b0: 4878 000b pea b <LASTO+0x1>
542b4: 2f39 0006 7c24 movel 67c24 <MSDOS_DOT_NAME>,%sp@-
542ba: 2f05 movel %d5,%sp@-
542bc: 4e95 jsr %a5@
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
542be: 4fef 0024 lea %sp@(36),%sp
542c2: 4878 000b pea b <LASTO+0x1>
542c6: 2f39 0006 7c20 movel 67c20 <MSDOS_DOTDOT_NAME>,%sp@-
542cc: 2f02 movel %d2,%sp@-
542ce: 4e95 jsr %a5@
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
542d0: 4fef 000c lea %sp@(12),%sp
542d4: 7001 moveq #1,%d0
542d6: 2043 moveal %d3,%a0
542d8: b0a8 0020 cmpl %a0@(32),%d0
542dc: 6618 bnes 542f6 <msdos_creat_node+0x272>
542de: 4aa8 0024 tstl %a0@(36)
542e2: 6612 bnes 542f6 <msdos_creat_node+0x272> <== NEVER TAKEN
(fs_info->fat.vol.type & FAT_FAT32))
542e4: 4280 clrl %d0
542e6: 102c 000a moveb %a4@(10),%d0
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
542ea: 44c0 movew %d0,%ccr
542ec: 6608 bnes 542f6 <msdos_creat_node+0x272> <== ALWAYS TAKEN
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
542ee: 4240 clrw %d0 <== NOT EXECUTED
542f0: 3d40 ffa2 movew %d0,%fp@(-94) <== NOT EXECUTED
542f4: 6022 bras 54318 <msdos_creat_node+0x294> <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
542f6: 2043 moveal %d3,%a0
542f8: 4282 clrl %d2
542fa: 2228 001c movel %a0@(28),%d1
542fe: 3401 movew %d1,%d2
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
54300: 4241 clrw %d1
54302: 4841 swap %d1
54304: 2002 movel %d2,%d0
54306: e08a lsrl #8,%d2
54308: e188 lsll #8,%d0
5430a: 8082 orl %d2,%d0
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
5430c: 3d40 ffa2 movew %d0,%fp@(-94)
54310: 2001 movel %d1,%d0
54312: e089 lsrl #8,%d1
54314: e188 lsll #8,%d0
54316: 8081 orl %d1,%d0
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
54318: 240e movel %fp,%d2
5431a: 0682 ffff ff68 addil #-152,%d2
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54320: 2f02 movel %d2,%sp@-
54322: 4878 0040 pea 40 <DBL_MANT_DIG+0xb>
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
54326: 3d40 ff9c movew %d0,%fp@(-100)
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
5432a: 42a7 clrl %sp@-
5432c: 2f0b movel %a3,%sp@-
5432e: 2f2a 0010 movel %a2@(16),%sp@-
54332: 47f9 0005 00b2 lea 500b2 <fat_file_write>,%a3
54338: 4e93 jsr %a3@
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
5433a: 4fef 0014 lea %sp@(20),%sp
5433e: 4a80 tstl %d0
54340: 6d70 blts 543b2 <msdos_creat_node+0x32e> <== NEVER TAKEN
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
54342: 206e fff8 moveal %fp@(-8),%a0
54346: 4280 clrl %d0
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
54348: 4283 clrl %d3
5434a: 2228 001c movel %a0@(28),%d1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
5434e: 302c 0006 movew %a4@(6),%d0
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
54352: 3601 movew %d1,%d3
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
54354: 4241 clrw %d1
54356: 4841 swap %d1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
54358: d1a8 0018 addl %d0,%a0@(24)
5435c: 2003 movel %d3,%d0
5435e: e08b lsrl #8,%d3
54360: e188 lsll #8,%d0
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54362: 2f02 movel %d2,%sp@-
54364: 4878 0020 pea 20 <OPER2+0xc>
54368: 8083 orl %d3,%d0
5436a: 42a7 clrl %sp@-
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
5436c: 3d40 ff82 movew %d0,%fp@(-126)
54370: 2001 movel %d1,%d0
54372: e089 lsrl #8,%d1
54374: e188 lsll #8,%d0
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54376: 2f08 movel %a0,%sp@-
54378: 2f2a 0010 movel %a2@(16),%sp@-
5437c: 8081 orl %d1,%d0
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
5437e: 3d40 ff7c movew %d0,%fp@(-132)
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
54382: 4e93 jsr %a3@
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
54384: 4fef 0014 lea %sp@(20),%sp
54388: 4a80 tstl %d0
5438a: 6d26 blts 543b2 <msdos_creat_node+0x32e> <== NEVER TAKEN
rc = -1;
goto error;
}
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
5438c: 2f2e fff8 movel %fp@(-8),%sp@-
54390: 2f2a 0010 movel %a2@(16),%sp@-
54394: 4eb9 0005 52f4 jsr 552f4 <msdos_set_first_cluster_num>
if (rc != RC_OK)
5439a: 508f addql #8,%sp
rc = -1;
goto error;
}
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
5439c: 2400 movel %d0,%d2
if (rc != RC_OK)
5439e: 6614 bnes 543b4 <msdos_creat_node+0x330> <== NEVER TAKEN
goto error;
fat_file_close(parent_loc->mt_entry, fat_fd);
543a0: 2f2e fff8 movel %fp@(-8),%sp@-
543a4: 2f2a 0010 movel %a2@(16),%sp@-
543a8: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close>
543ae: 508f addql #8,%sp
543b0: 602c bras 543de <msdos_creat_node+0x35a>
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
{
rc = -1;
543b2: 74ff moveq #-1,%d2 <== NOT EXECUTED
fat_file_close(parent_loc->mt_entry, fat_fd);
}
return RC_OK;
error:
fat_file_close(parent_loc->mt_entry, fat_fd);
543b4: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
543b8: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
543bc: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
543c2: 508f addql #8,%sp <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
543c4: 4878 00e5 pea e5 <DBL_MANT_DIG+0xb0> <== NOT EXECUTED
543c8: 486e ffe8 pea %fp@(-24) <== NOT EXECUTED
543cc: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
543d0: 4eb9 0005 5416 jsr 55416 <msdos_set_first_char4file_name> <== NOT EXECUTED
return rc;
543d6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
543da: 6002 bras 543de <msdos_creat_node+0x35a> <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
return -1;
543dc: 74ff moveq #-1,%d2 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
543de: 2002 movel %d2,%d0
543e0: 4cee 3cfc ff40 moveml %fp@(-192),%d2-%d7/%a2-%a5
543e6: 4e5e unlk %fp
...
00057412 <msdos_date_dos2unix>:
* called from the stat(), and fstat() system calls and so probably need
* not be too efficient.
*/
unsigned int
msdos_date_dos2unix(unsigned int dd, unsigned int dt)
{
57412: 4e56 ffec linkw %fp,#-20
57416: 222e 0008 movel %fp@(8),%d1
5741a: 48d7 043c moveml %d2-%d5/%a2,%sp@
5741e: 262e 000c movel %fp@(12),%d3
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
57422: 2003 movel %d3,%d0
57424: 740b moveq #11,%d2
57426: 2a3c 0000 0708 movel #1800,%d5
5742c: 0280 0000 f800 andil #63488,%d0
57432: e4a8 lsrl %d2,%d0
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
57434: 2403 movel %d3,%d2
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
57436: 4c05 0800 mulsl %d5,%d0
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
5743a: 0282 0000 07e0 andil #2016,%d2
57440: ea8a lsrl #5,%d2
57442: 2802 movel %d2,%d4
57444: eb8a lsll #5,%d2
57446: d884 addl %d4,%d4
57448: 9484 subl %d4,%d2
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
5744a: d082 addl %d2,%d0
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
5744c: 741f moveq #31,%d2
5744e: c682 andl %d2,%d3
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
57450: 4282 clrl %d2
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
57452: d083 addl %d3,%d0
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
57454: 3439 0006 991c movew 6991c <lastdosdate>,%d2
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
5745a: d080 addl %d0,%d0
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
5745c: b282 cmpl %d2,%d1
5745e: 6700 0088 beqw 574e8 <msdos_date_dos2unix+0xd6>
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
57462: 2601 movel %d1,%d3
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
57464: 91c8 subal %a0,%a0
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
57466: 4282 clrl %d2
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
57468: 0283 0000 fe00 andil #65024,%d3
5746e: 3a3c 0009 movew #9,%d5
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
57472: 33c1 0006 991c movew %d1,6991c <lastdosdate>
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
57478: eaab lsrl %d5,%d3
for (y = 0; y < year; y++)
5747a: 6012 bras 5748e <msdos_date_dos2unix+0x7c>
days += y & 0x03 ? 365 : 366;
5747c: 4a84 tstl %d4
5747e: 57c4 seq %d4
57480: 2a3c 0000 016d movel #365,%d5
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
57486: 5282 addql #1,%d2
days += y & 0x03 ? 365 : 366;
57488: 49c4 extbl %d4
5748a: 9a84 subl %d4,%d5
5748c: d1c5 addal %d5,%a0
5748e: 7803 moveq #3,%d4
57490: c882 andl %d2,%d4
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
57492: b682 cmpl %d2,%d3
57494: 66e6 bnes 5747c <msdos_date_dos2unix+0x6a>
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
57496: 45f9 0006 8a1c lea 68a1c <leapyear>,%a2
5749c: 4a84 tstl %d4
5749e: 6706 beqs 574a6 <msdos_date_dos2unix+0x94> <== ALWAYS TAKEN
574a0: 45f9 0006 8a04 lea 68a04 <regyear>,%a2 <== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
574a6: 2401 movel %d1,%d2
574a8: 0282 0000 01e0 andil #480,%d2
574ae: ea8a lsrl #5,%d2
if (month == 0) {
574b0: 6604 bnes 574b6 <msdos_date_dos2unix+0xa4> <== ALWAYS TAKEN
month = 1;
574b2: 143c 0001 moveb #1,%d2 <== NOT EXECUTED
}
for (m = 0; m < month - 1; m++)
574b6: 93c9 subal %a1,%a1
574b8: 5382 subql #1,%d2
574ba: 6008 bras 574c4 <msdos_date_dos2unix+0xb2>
days += months[m];
574bc: 4283 clrl %d3 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
574be: 5289 addql #1,%a1 <== NOT EXECUTED
days += months[m];
574c0: 361a movew %a2@+,%d3 <== NOT EXECUTED
574c2: d1c3 addal %d3,%a0 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
574c4: b489 cmpl %a1,%d2
574c6: 62f4 bhis 574bc <msdos_date_dos2unix+0xaa> <== NEVER TAKEN
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
574c8: 741f moveq #31,%d2
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
574ca: 2a3c 0001 5180 movel #86400,%d5
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
574d0: c282 andl %d2,%d1
574d2: 41f0 18ff lea %a0@(ffffffff,%d1:l),%a0
574d6: 2208 movel %a0,%d1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
574d8: 4c05 1800 mulsl %d5,%d1
574dc: 0681 12ce a600 addil #315532800,%d1
574e2: 23c1 0006 991e movel %d1,6991e <lastseconds>
}
return seconds + lastseconds;
}
574e8: d0b9 0006 991e addl 6991e <lastseconds>,%d0
574ee: 4cd7 043c moveml %sp@,%d2-%d5/%a2
574f2: 4e5e unlk %fp <== NOT EXECUTED
00057318 <msdos_date_unix2dos>:
* file timestamps. The passed in unix time is assumed to be in GMT.
*/
void
msdos_date_unix2dos(unsigned int t, uint16_t *ddp,
uint16_t *dtp)
{
57318: 4e56 fff0 linkw %fp,#-16
5731c: 202e 0008 movel %fp@(8),%d0
57320: 48d7 003c moveml %d2-%d5,%sp@
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
57324: b0b9 0006 9910 cmpl 69910 <lasttime>,%d0
5732a: 6700 00ca beqw 573f6 <msdos_date_unix2dos+0xde>
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
5732e: 723c moveq #60,%d1
57330: 2600 movel %d0,%d3
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
57332: 2a3c 0000 0e10 movel #3600,%d5
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
57338: 4c41 3004 remul %d1,%d4,%d3
5733c: 4c41 3003 remul %d1,%d3,%d3
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
57340: 23c0 0006 9910 movel %d0,69910 <lasttime>
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
57346: 4c41 3002 remul %d1,%d2,%d3
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
5734a: 2600 movel %d0,%d3
5734c: 4c45 3003 remul %d5,%d3,%d3
57350: 3a3c 0018 movew #24,%d5
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
57354: eb8a lsll #5,%d2
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
57356: 4c45 3001 remul %d5,%d1,%d3
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
5735a: 760b moveq #11,%d3
5735c: e7a9 lsll %d3,%d1
5735e: 2604 movel %d4,%d3
57360: e28b lsrl #1,%d3
57362: d481 addl %d1,%d2
57364: 2202 movel %d2,%d1
57366: d283 addl %d3,%d1
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
57368: 283c 0001 5180 movel #86400,%d4
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
5736e: 33c1 0006 9914 movew %d1,69914 <lastdtime>
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
57374: 4c44 0000 remul %d4,%d0,%d0
if (days != lastday) {
57378: b0b9 0006 9916 cmpl 69916 <lastday>,%d0
5737e: 6776 beqs 573f6 <msdos_date_unix2dos+0xde> <== NEVER TAKEN
lastday = days;
57380: 23c0 0006 9916 movel %d0,69916 <lastday>
for (year = 1970;; year++) {
57386: 223c 0000 07b2 movel #1970,%d1
inc = year & 0x03 ? 365 : 366;
5738c: 7603 moveq #3,%d3
5738e: 2a3c 0000 016d movel #365,%d5
57394: c681 andl %d1,%d3
57396: 57c2 seq %d2
57398: 49c2 extbl %d2
5739a: 9a82 subl %d2,%d5
if (days < inc)
5739c: ba80 cmpl %d0,%d5
5739e: 6206 bhis 573a6 <msdos_date_unix2dos+0x8e>
break;
days -= inc;
573a0: 9085 subl %d5,%d0
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
for (year = 1970;; year++) {
573a2: 5281 addql #1,%d1
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
}
573a4: 60e6 bras 5738c <msdos_date_unix2dos+0x74>
months = year & 0x03 ? regyear : leapyear;
573a6: 43f9 0006 8a1c lea 68a1c <leapyear>,%a1
573ac: 4a83 tstl %d3
573ae: 6706 beqs 573b6 <msdos_date_unix2dos+0x9e> <== ALWAYS TAKEN
573b0: 43f9 0006 8a04 lea 68a04 <regyear>,%a1 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
573b6: 91c8 subal %a0,%a0
if (days < months[month])
573b8: 4282 clrl %d2
573ba: 3419 movew %a1@+,%d2
573bc: b480 cmpl %d0,%d2
573be: 620a bhis 573ca <msdos_date_unix2dos+0xb2> <== ALWAYS TAKEN
break;
days -= months[month];
573c0: 9082 subl %d2,%d0 <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
573c2: 5288 addql #1,%a0 <== NOT EXECUTED
573c4: 740c moveq #12,%d2 <== NOT EXECUTED
573c6: b488 cmpl %a0,%d2 <== NOT EXECUTED
573c8: 66ee bnes 573b8 <msdos_date_unix2dos+0xa0> <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
573ca: 2408 movel %a0,%d2
573cc: 5282 addql #1,%d2
573ce: 2240 moveal %d0,%a1
573d0: eb8a lsll #5,%d2
573d2: 41f1 2801 lea %a1@(00000001,%d2:l),%a0
573d6: 33c8 0006 991a movew %a0,6991a <lastddate>
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
573dc: 0c81 0000 07bc cmpil #1980,%d1
573e2: 6312 blss 573f6 <msdos_date_unix2dos+0xde> <== NEVER TAKEN
lastddate += (year - 1980) <<
573e4: 0681 ffff f844 addil #-1980,%d1
573ea: 7009 moveq #9,%d0
573ec: e1a9 lsll %d0,%d1
573ee: d288 addl %a0,%d1
573f0: 33c1 0006 991a movew %d1,6991a <lastddate>
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
573f6: 206e 0010 moveal %fp@(16),%a0
573fa: 30b9 0006 9914 movew 69914 <lastdtime>,%a0@
*ddp = lastddate;
57400: 206e 000c moveal %fp@(12),%a0
}
57404: 4cd7 003c moveml %sp@,%d2-%d5
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
57408: 30b9 0006 991a movew 6991a <lastddate>,%a0@
}
5740e: 4e5e unlk %fp <== NOT EXECUTED
00057cde <msdos_dir_chmod>:
int
msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
57cde: 4280 clrl %d0 <== NOT EXECUTED
* RC_OK always
*/
int
msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
57ce0: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return RC_OK;
}
57ce4: 4e5e unlk %fp <== NOT EXECUTED
0005766e <msdos_dir_close>:
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
5766e: 4e56 fff4 linkw %fp,#-12
57672: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
57676: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
5767a: 206b 0028 moveal %a3@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
5767e: 242b 0018 movel %a3@(24),%d2
int
msdos_dir_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
57682: 2468 0034 moveal %a0@(52),%a2
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
57686: 42a7 clrl %sp@-
57688: 42a7 clrl %sp@-
5768a: 2f2a 0088 movel %a2@(136),%sp@-
5768e: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
57694: 4fef 000c lea %sp@(12),%sp
57698: 4a80 tstl %d0
5769a: 6710 beqs 576ac <msdos_dir_close+0x3e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
5769c: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
576a2: 74ff moveq #-1,%d2 <== NOT EXECUTED
576a4: 7205 moveq #5,%d1 <== NOT EXECUTED
576a6: 2040 moveal %d0,%a0 <== NOT EXECUTED
576a8: 2081 movel %d1,%a0@ <== NOT EXECUTED
576aa: 601e bras 576ca <msdos_dir_close+0x5c> <== NOT EXECUTED
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
576ac: 2f02 movel %d2,%sp@-
576ae: 2f2b 0028 movel %a3@(40),%sp@-
576b2: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close>
if (rc != RC_OK)
576b8: 508f addql #8,%sp
576ba: 41f9 0004 901c lea 4901c <rtems_semaphore_release>,%a0
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
576c0: 2400 movel %d0,%d2
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rtems_semaphore_release(fs_info->vol_sema);
576c2: 2f2a 0088 movel %a2@(136),%sp@-
576c6: 4e90 jsr %a0@
return RC_OK;
576c8: 588f addql #4,%sp
}
576ca: 2002 movel %d2,%d0
576cc: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
576d2: 4e5e unlk %fp <== NOT EXECUTED
00055530 <msdos_dir_is_empty>:
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
55530: 4e56 ffd4 linkw %fp,#-44 <== NOT EXECUTED
55534: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
55538: 2a2e 0008 movel %fp@(8),%d5 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
5553c: 2045 moveal %d5,%a0 <== NOT EXECUTED
uint32_t j = 0, i = 0;
5553e: 4283 clrl %d3 <== NOT EXECUTED
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
55540: 2c3c 0004 fb66 movel #326502,%d6 <== NOT EXECUTED
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
55546: 4bf9 0005 95d8 lea 595d8 <strncmp>,%a5 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
5554c: 286e 0010 moveal %fp@(16),%a4 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55550: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
55554: 2e2e 000c movel %fp@(12),%d7 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
55558: 4214 clrb %a4@ <== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
5555a: 6000 00a2 braw 555fe <msdos_dir_is_empty+0xce> <== NOT EXECUTED
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
5555e: 721f moveq #31,%d1 <== NOT EXECUTED
55560: b280 cmpl %d0,%d1 <== NOT EXECUTED
55562: 6c00 00c2 bgew 55626 <msdos_dir_is_empty+0xf6> <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
55566: 4281 clrl %d1 <== NOT EXECUTED
55568: 3212 movew %a2@,%d1 <== NOT EXECUTED
5556a: b280 cmpl %d0,%d1 <== NOT EXECUTED
5556c: 6700 0082 beqw 555f0 <msdos_dir_is_empty+0xc0> <== NOT EXECUTED
55570: 4879 0006 7b87 pea 67b87 <msdos_file_handlers+0x51> <== NOT EXECUTED
55576: 4879 0006 7c28 pea 67c28 <__FUNCTION__.7056> <== NOT EXECUTED
5557c: 4878 03b5 pea 3b5 <DBL_MANT_DIG+0x380> <== NOT EXECUTED
55580: 4879 0006 7ba3 pea 67ba3 <msdos_file_handlers+0x6d> <== NOT EXECUTED
55586: 4eb9 0005 20dc jsr 520dc <__assert_func> <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
5558c: 266a 008c moveal %a2@(140),%a3 <== NOT EXECUTED
55590: d7c2 addal %d2,%a3 <== NOT EXECUTED
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
55592: 4280 clrl %d0 <== NOT EXECUTED
55594: 1813 moveb %a3@,%d4 <== NOT EXECUTED
55596: 1004 moveb %d4,%d0 <== NOT EXECUTED
55598: 0c80 0000 00e5 cmpil #229,%d0 <== NOT EXECUTED
5559e: 673e beqs 555de <msdos_dir_is_empty+0xae> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
555a0: 4280 clrl %d0 <== NOT EXECUTED
555a2: 102b 000b moveb %a3@(11),%d0 <== NOT EXECUTED
555a6: 723f moveq #63,%d1 <== NOT EXECUTED
555a8: c081 andl %d1,%d0 <== NOT EXECUTED
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
555aa: 123c 000f moveb #15,%d1 <== NOT EXECUTED
555ae: b280 cmpl %d0,%d1 <== NOT EXECUTED
555b0: 672c beqs 555de <msdos_dir_is_empty+0xae> <== NOT EXECUTED
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
555b2: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
555b6: 4879 0006 7bed pea 67bed <msdos_file_handlers+0xb7> <== NOT EXECUTED
555bc: 2f0b movel %a3,%sp@- <== NOT EXECUTED
555be: 4e95 jsr %a5@ <== NOT EXECUTED
555c0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
555c4: 4a80 tstl %d0 <== NOT EXECUTED
555c6: 6716 beqs 555de <msdos_dir_is_empty+0xae> <== NOT EXECUTED
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
555c8: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
555cc: 4879 0006 7bf9 pea 67bf9 <msdos_file_handlers+0xc3> <== NOT EXECUTED
555d2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
555d4: 4e95 jsr %a5@ <== NOT EXECUTED
555d6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
555da: 4a80 tstl %d0 <== NOT EXECUTED
555dc: 6608 bnes 555e6 <msdos_dir_is_empty+0xb6> <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
555de: 0682 0000 0020 addil #32,%d2 <== NOT EXECUTED
555e4: 6010 bras 555f6 <msdos_dir_is_empty+0xc6> <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
555e6: 4a04 tstb %d4 <== NOT EXECUTED
555e8: 6640 bnes 5562a <msdos_dir_is_empty+0xfa> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
555ea: 18bc 0001 moveb #1,%a4@ <== NOT EXECUTED
555ee: 603a bras 5562a <msdos_dir_is_empty+0xfa> <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
555f0: 4282 clrl %d2 <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
555f2: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
555f6: b4ae fffc cmpl %fp@(-4),%d2 <== NOT EXECUTED
555fa: 6590 bcss 5558c <msdos_dir_is_empty+0x5c> <== NOT EXECUTED
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
555fc: 5283 addql #1,%d3 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
555fe: 4280 clrl %d0 <== NOT EXECUTED
55600: 2046 moveal %d6,%a0 <== NOT EXECUTED
55602: 3012 movew %a2@,%d0 <== NOT EXECUTED
55604: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED
55608: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5560a: 4c03 0800 mulsl %d3,%d0 <== NOT EXECUTED
5560e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
55610: 2f07 movel %d7,%sp@- <== NOT EXECUTED
55612: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55614: 4e90 jsr %a0@ <== NOT EXECUTED
55616: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
5561a: 4a80 tstl %d0 <== NOT EXECUTED
5561c: 6600 ff40 bnew 5555e <msdos_dir_is_empty+0x2e> <== NOT EXECUTED
*/
return RC_OK;
}
j++;
}
*ret_val = true;
55620: 18bc 0001 moveb #1,%a4@ <== NOT EXECUTED
return RC_OK;
55624: 6006 bras 5562c <msdos_dir_is_empty+0xfc> <== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
55626: 70ff moveq #-1,%d0 <== NOT EXECUTED
55628: 6002 bras 5562c <msdos_dir_is_empty+0xfc> <== NOT EXECUTED
}
/*
* Short file name entries mean not empty.
*/
return RC_OK;
5562a: 4280 clrl %d0 <== NOT EXECUTED
}
j++;
}
*ret_val = true;
return RC_OK;
}
5562c: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5 <== NOT EXECUTED
55632: 4e5e unlk %fp <== NOT EXECUTED
00057bac <msdos_dir_lseek>:
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
switch (whence)
57bac: 7001 moveq #1,%d0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
57bae: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
switch (whence)
57bb2: b0ae 0014 cmpl %fp@(20),%d0 <== NOT EXECUTED
57bb6: 6412 bccs 57bca <msdos_dir_lseek+0x1e> <== NOT EXECUTED
* Movement past the end of the directory via lseek is not a
* permitted operation
*/
case SEEK_END:
default:
rtems_set_errno_and_return_minus_one( EINVAL );
57bb8: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
57bbe: 2040 moveal %d0,%a0 <== NOT EXECUTED
57bc0: 7016 moveq #22,%d0 <== NOT EXECUTED
57bc2: 2080 movel %d0,%a0@ <== NOT EXECUTED
57bc4: 70ff moveq #-1,%d0 <== NOT EXECUTED
57bc6: 72ff moveq #-1,%d1 <== NOT EXECUTED
57bc8: 6004 bras 57bce <msdos_dir_lseek+0x22> <== NOT EXECUTED
break;
}
return RC_OK;
57bca: 4280 clrl %d0 <== NOT EXECUTED
57bcc: 4281 clrl %d1 <== NOT EXECUTED
}
57bce: 4e5e unlk %fp <== NOT EXECUTED
000575fc <msdos_dir_open>:
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
575fc: 4e56 fff4 linkw %fp,#-12
57600: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
57604: 266e 0008 moveal %fp@(8),%a3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
57608: 206b 0028 moveal %a3@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
5760c: 242b 0018 movel %a3@(24),%d2
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
57610: 2468 0034 moveal %a0@(52),%a2
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
57614: 42a7 clrl %sp@-
57616: 42a7 clrl %sp@-
57618: 2f2a 0088 movel %a2@(136),%sp@-
5761c: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
57622: 4fef 000c lea %sp@(12),%sp
57626: 4a80 tstl %d0
57628: 6710 beqs 5763a <msdos_dir_open+0x3e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
5762a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
57630: 74ff moveq #-1,%d2 <== NOT EXECUTED
57632: 2040 moveal %d0,%a0 <== NOT EXECUTED
57634: 7005 moveq #5,%d0 <== NOT EXECUTED
57636: 2080 movel %d0,%a0@ <== NOT EXECUTED
57638: 6028 bras 57662 <msdos_dir_open+0x66> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
5763a: 2f02 movel %d2,%sp@-
5763c: 4eb9 0004 fb54 jsr 4fb54 <fat_file_reopen>
if (rc != RC_OK)
57642: 588f addql #4,%sp
57644: 41f9 0004 901c lea 4901c <rtems_semaphore_release>,%a0
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_reopen(fat_fd);
5764a: 2400 movel %d0,%d2
if (rc != RC_OK)
5764c: 660c bnes 5765a <msdos_dir_open+0x5e> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
iop->offset = 0;
5764e: 4280 clrl %d0
57650: 4281 clrl %d1
57652: 2740 000c movel %d0,%a3@(12)
57656: 2741 0010 movel %d1,%a3@(16)
rtems_semaphore_release(fs_info->vol_sema);
5765a: 2f2a 0088 movel %a2@(136),%sp@-
5765e: 4e90 jsr %a0@
return RC_OK;
57660: 588f addql #4,%sp
}
57662: 2002 movel %d2,%d0
57664: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
5766a: 4e5e unlk %fp <== NOT EXECUTED
000576d6 <msdos_dir_read>:
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
576d6: 7001 moveq #1,%d0 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
576d8: 4e56 fe80 linkw %fp,#-384 <== NOT EXECUTED
576dc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
576e0: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
576e4: 206b 0028 moveal %a3@(40),%a0 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
576e8: 2c2e 0010 movel %fp@(16),%d6 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
576ec: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
576f0: 286b 0018 moveal %a3@(24),%a4 <== NOT EXECUTED
fat_file_fd_t *tmp_fat_fd = NULL;
576f4: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
576f8: 242b 000c movel %a3@(12),%d2 <== NOT EXECUTED
576fc: 262b 0010 movel %a3@(16),%d3 <== NOT EXECUTED
uint32_t start = 0;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t j = 0, i = 0;
uint32_t bts2rd = 0;
uint32_t cur_cln = 0;
57700: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
57704: b0ac 0020 cmpl %a4@(32),%d0 <== NOT EXECUTED
57708: 661c bnes 57726 <msdos_dir_read+0x50> <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
5770a: 4aac 0024 tstl %a4@(36) <== NOT EXECUTED
5770e: 6616 bnes 57726 <msdos_dir_read+0x50> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
57710: 4280 clrl %d0 <== NOT EXECUTED
57712: 102a 000a moveb %a2@(10),%d0 <== NOT EXECUTED
57716: 7203 moveq #3,%d1 <== NOT EXECUTED
57718: c081 andl %d1,%d0 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
5771a: 670a beqs 57726 <msdos_dir_read+0x50> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
5771c: 2a2c 0018 movel %a4@(24),%d5 <== NOT EXECUTED
57720: 2d45 fec2 movel %d5,%fp@(-318) <== NOT EXECUTED
57724: 600a bras 57730 <msdos_dir_read+0x5a> <== NOT EXECUTED
57726: 4287 clrl %d7 <== NOT EXECUTED
57728: 3e2a 0006 movew %a2@(6),%d7 <== NOT EXECUTED
5772c: 2d47 fec2 movel %d7,%fp@(-318) <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
57730: 42a7 clrl %sp@- <== NOT EXECUTED
57732: 42a7 clrl %sp@- <== NOT EXECUTED
57734: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
57738: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
5773e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57742: 4a80 tstl %d0 <== NOT EXECUTED
57744: 6648 bnes 5778e <msdos_dir_read+0xb8> <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
57746: 4878 0110 pea 110 <DBL_MANT_DIG+0xdb> <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
5774a: 4285 clrl %d5 <== NOT EXECUTED
5774c: 7eff moveq #-1,%d7 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
5774e: 42a7 clrl %sp@- <== NOT EXECUTED
57750: 2f03 movel %d3,%sp@- <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
57752: 4283 clrl %d3 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
57754: 2f02 movel %d2,%sp@- <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
57756: 4202 clrb %d2 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
57758: 4eb9 0006 47f4 jsr 647f4 <__divdi3> <== NOT EXECUTED
5775e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
57762: 41ee fed8 lea %fp@(-296),%a0 <== NOT EXECUTED
57766: 41e8 0010 lea %a0@(16),%a0 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
5776a: 2d41 fec8 movel %d1,%fp@(-312) <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
5776e: 223c 0000 0110 movel #272,%d1 <== NOT EXECUTED
57774: 4c41 6006 remul %d1,%d6,%d6 <== NOT EXECUTED
57778: 1d42 fec7 moveb %d2,%fp@(-313) <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
5777c: 2d48 fed0 movel %a0,%fp@(-304) <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
57780: 2006 movel %d6,%d0 <== NOT EXECUTED
57782: 4282 clrl %d2 <== NOT EXECUTED
57784: e988 lsll #4,%d0 <== NOT EXECUTED
57786: e18e lsll #8,%d6 <== NOT EXECUTED
57788: dc80 addl %d0,%d6 <== NOT EXECUTED
5778a: 6000 03b2 braw 57b3e <msdos_dir_read+0x468> <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
5778e: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
57794: 7605 moveq #5,%d3 <== NOT EXECUTED
57796: 2240 moveal %d0,%a1 <== NOT EXECUTED
57798: 2283 movel %d3,%a1@ <== NOT EXECUTED
5779a: 603e bras 577da <msdos_dir_read+0x104> <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
5779c: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED
577a0: 2f2e fec2 movel %fp@(-318),%sp@- <== NOT EXECUTED
577a4: 2f05 movel %d5,%sp@- <== NOT EXECUTED
577a6: 2f0c movel %a4,%sp@- <== NOT EXECUTED
577a8: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
577ac: 4eb9 0004 fb66 jsr 4fb66 <fat_file_read> <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
577b2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
577b6: 721f moveq #31,%d1 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
577b8: 2d40 feba movel %d0,%fp@(-326) <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
577bc: b280 cmpl %d0,%d1 <== NOT EXECUTED
577be: 6d00 0368 bltw 57b28 <msdos_dir_read+0x452> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
577c2: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
577c6: 7405 moveq #5,%d2 <== NOT EXECUTED
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
rtems_semaphore_release(fs_info->vol_sema);
577c8: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
577ce: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
577d4: 588f addql #4,%sp <== NOT EXECUTED
577d6: 2040 moveal %d0,%a0 <== NOT EXECUTED
577d8: 2082 movel %d2,%a0@ <== NOT EXECUTED
577da: 72ff moveq #-1,%d1 <== NOT EXECUTED
577dc: 6000 0374 braw 57b52 <msdos_dir_read+0x47c> <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
577e0: 2a6a 008c moveal %a2@(140),%a5 <== NOT EXECUTED
577e4: dbc4 addal %d4,%a5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
577e6: 1a15 moveb %a5@,%d5 <== NOT EXECUTED
577e8: 6700 035a beqw 57b44 <msdos_dir_read+0x46e> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
577ec: 4281 clrl %d1 <== NOT EXECUTED
577ee: 1205 moveb %d5,%d1 <== NOT EXECUTED
577f0: 0c81 0000 00e5 cmpil #229,%d1 <== NOT EXECUTED
577f6: 6700 0328 beqw 57b20 <msdos_dir_read+0x44a> <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
577fa: 4280 clrl %d0 <== NOT EXECUTED
577fc: 102d 000b moveb %a5@(11),%d0 <== NOT EXECUTED
57800: 2040 moveal %d0,%a0 <== NOT EXECUTED
57802: 703f moveq #63,%d0 <== NOT EXECUTED
57804: 2208 movel %a0,%d1 <== NOT EXECUTED
57806: c280 andl %d0,%d1 <== NOT EXECUTED
57808: 2008 movel %a0,%d0 <== NOT EXECUTED
5780a: 44c0 movew %d0,%ccr <== NOT EXECUTED
5780c: 6a08 bpls 57816 <msdos_dir_read+0x140> <== NOT EXECUTED
5780e: 700f moveq #15,%d0 <== NOT EXECUTED
57810: b081 cmpl %d1,%d0 <== NOT EXECUTED
57812: 6600 030c bnew 57b20 <msdos_dir_read+0x44a> <== NOT EXECUTED
/*
* Check the attribute to see if the entry is for a long file
* name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
57816: 700f moveq #15,%d0 <== NOT EXECUTED
57818: b081 cmpl %d1,%d0 <== NOT EXECUTED
5781a: 6600 00ae bnew 578ca <msdos_dir_read+0x1f4> <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
5781e: 72ff moveq #-1,%d1 <== NOT EXECUTED
57820: b287 cmpl %d7,%d1 <== NOT EXECUTED
57822: 6634 bnes 57858 <msdos_dir_read+0x182> <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
57824: 4280 clrl %d0 <== NOT EXECUTED
57826: 1005 moveb %d5,%d0 <== NOT EXECUTED
57828: 0800 0006 btst #6,%d0 <== NOT EXECUTED
5782c: 6700 02f2 beqw 57b20 <msdos_dir_read+0x44a> <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
57830: 2e2e feb2 movel %fp@(-334),%d7 <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
57834: 763f moveq #63,%d3 <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
57836: de84 addl %d4,%d7 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
57838: ea8f lsrl #5,%d7 <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
5783a: 1a2d 000d moveb %a5@(13),%d5 <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
5783e: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
57842: c680 andl %d0,%d3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
57844: 42a7 clrl %sp@- <== NOT EXECUTED
57846: 2f2e fed0 movel %fp@(-304),%sp@- <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
5784a: 1d45 fec7 moveb %d5,%fp@(-313) <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
5784e: 4eb9 0005 8848 jsr 58848 <memset> <== NOT EXECUTED
57854: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
57858: 4280 clrl %d0 <== NOT EXECUTED
5785a: 1015 moveb %a5@,%d0 <== NOT EXECUTED
5785c: 723f moveq #63,%d1 <== NOT EXECUTED
5785e: c081 andl %d1,%d0 <== NOT EXECUTED
57860: b083 cmpl %d3,%d0 <== NOT EXECUTED
57862: 6600 02ba bnew 57b1e <msdos_dir_read+0x448> <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
57866: 4281 clrl %d1 <== NOT EXECUTED
57868: 4280 clrl %d0 <== NOT EXECUTED
5786a: 122e fec7 moveb %fp@(-313),%d1 <== NOT EXECUTED
5786e: 102d 000d moveb %a5@(13),%d0 <== NOT EXECUTED
57872: b081 cmpl %d1,%d0 <== NOT EXECUTED
57874: 6600 02a8 bnew 57b1e <msdos_dir_read+0x448> <== NOT EXECUTED
* The DOS maximum length is 255 characters without the
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
57878: 5383 subql #1,%d3 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
5787a: 720d moveq #13,%d1 <== NOT EXECUTED
5787c: 4c03 1800 mulsl %d3,%d1 <== NOT EXECUTED
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
57880: 528d addql #1,%a5 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
57882: 4280 clrl %d0 <== NOT EXECUTED
57884: 2242 moveal %d2,%a1 <== NOT EXECUTED
57886: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
5788a: 0c81 0000 00fe cmpil #254,%d1 <== NOT EXECUTED
57890: 6200 0280 bhiw 57b12 <msdos_dir_read+0x43c> <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
57894: 206e fed0 moveal %fp@(-304),%a0 <== NOT EXECUTED
57898: 1195 1800 moveb %a5@,%a0@(00000000,%d1:l) <== NOT EXECUTED
5789c: 5281 addql #1,%d1 <== NOT EXECUTED
if (*p == '\0')
5789e: 4a15 tstb %a5@ <== NOT EXECUTED
578a0: 6700 0270 beqw 57b12 <msdos_dir_read+0x43c> <== NOT EXECUTED
break;
switch (q)
578a4: 7404 moveq #4,%d2 <== NOT EXECUTED
578a6: b480 cmpl %d0,%d2 <== NOT EXECUTED
578a8: 670a beqs 578b4 <msdos_dir_read+0x1de> <== NOT EXECUTED
578aa: 143c 000a moveb #10,%d2 <== NOT EXECUTED
578ae: b480 cmpl %d0,%d2 <== NOT EXECUTED
578b0: 660a bnes 578bc <msdos_dir_read+0x1e6> <== NOT EXECUTED
578b2: 6004 bras 578b8 <msdos_dir_read+0x1e2> <== NOT EXECUTED
{
case 4:
p += 5;
578b4: 5a8d addql #5,%a5 <== NOT EXECUTED
break;
578b6: 6006 bras 578be <msdos_dir_read+0x1e8> <== NOT EXECUTED
case 10:
p += 4;
578b8: 588d addql #4,%a5 <== NOT EXECUTED
break;
578ba: 6002 bras 578be <msdos_dir_read+0x1e8> <== NOT EXECUTED
default:
p += 2;
578bc: 548d addql #2,%a5 <== NOT EXECUTED
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
578be: 5280 addql #1,%d0 <== NOT EXECUTED
578c0: 740d moveq #13,%d2 <== NOT EXECUTED
578c2: b480 cmpl %d0,%d2 <== NOT EXECUTED
578c4: 66c4 bnes 5788a <msdos_dir_read+0x1b4> <== NOT EXECUTED
578c6: 6000 024a braw 57b12 <msdos_dir_read+0x43c> <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
578ca: 4aae fec8 tstl %fp@(-312) <== NOT EXECUTED
578ce: 6708 beqs 578d8 <msdos_dir_read+0x202> <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
578d0: 53ae fec8 subql #1,%fp@(-312) <== NOT EXECUTED
578d4: 6000 0248 braw 57b1e <msdos_dir_read+0x448> <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
578d8: 486e fffc pea %fp@(-4) <== NOT EXECUTED
578dc: 2f2e feb2 movel %fp@(-334),%sp@- <== NOT EXECUTED
578e0: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
578e4: 2f0c movel %a4,%sp@- <== NOT EXECUTED
578e6: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
578ea: 4eb9 0004 fe8c jsr 4fe8c <fat_file_ioctl> <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
578f0: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
578f4: 4a80 tstl %d0 <== NOT EXECUTED
578f6: 6600 0204 bnew 57afc <msdos_dir_read+0x426> <== NOT EXECUTED
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
578fa: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
578fe: 7aff moveq #-1,%d5 <== NOT EXECUTED
57900: 486e ffe8 pea %fp@(-24) <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
57904: 2d6e fffc ffe8 movel %fp@(-4),%fp@(-24) <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
5790a: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
5790e: 2d45 fff0 movel %d5,%fp@(-16) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
57912: 2d45 fff4 movel %d5,%fp@(-12) <== NOT EXECUTED
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
57916: 2d44 ffec movel %d4,%fp@(-20) <== NOT EXECUTED
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
5791a: 4eb9 0004 fa28 jsr 4fa28 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
57920: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57924: 4a80 tstl %d0 <== NOT EXECUTED
57926: 6600 01d4 bnew 57afc <msdos_dir_read+0x426> <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
5792a: 2d42 fee0 movel %d2,%fp@(-288) <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
5792e: 70ff moveq #-1,%d0 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
57930: 307c 0110 moveaw #272,%a0 <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
57934: 42ae fedc clrl %fp@(-292) <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
57938: 3d48 fee4 movew %a0,%fp@(-284) <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
5793c: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
57940: 2d68 000c fed8 movel %a0@(12),%fp@(-296) <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
57946: b087 cmpl %d7,%d0 <== NOT EXECUTED
57948: 6752 beqs 5799c <msdos_dir_read+0x2c6> <== NOT EXECUTED
5794a: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
5794e: 204d moveal %a5,%a0 <== NOT EXECUTED
57950: 700b moveq #11,%d0 <== NOT EXECUTED
57952: 4201 clrb %d1 <== NOT EXECUTED
57954: 2d42 fecc movel %d2,%fp@(-308) <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
57958: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
5795e: 2241 moveal %d1,%a1 <== NOT EXECUTED
57960: 0801 0000 btst #0,%d1 <== NOT EXECUTED
57964: 6704 beqs 5796a <msdos_dir_read+0x294> <== NOT EXECUTED
57966: 7280 moveq #-128,%d1 <== NOT EXECUTED
57968: 6002 bras 5796c <msdos_dir_read+0x296> <== NOT EXECUTED
5796a: 4201 clrb %d1 <== NOT EXECUTED
5796c: 2409 movel %a1,%d2 <== NOT EXECUTED
5796e: e28a lsrl #1,%d2 <== NOT EXECUTED
57970: 2242 moveal %d2,%a1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
57972: 5380 subql #1,%d0 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
57974: 1418 moveb %a0@+,%d2 <== NOT EXECUTED
57976: d3c2 addal %d2,%a1 <== NOT EXECUTED
57978: d289 addl %a1,%d1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
5797a: 4a80 tstl %d0 <== NOT EXECUTED
5797c: 66da bnes 57958 <msdos_dir_read+0x282> <== NOT EXECUTED
5797e: 242e fecc movel %fp@(-308),%d2 <== NOT EXECUTED
57982: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
57986: 4a83 tstl %d3 <== NOT EXECUTED
57988: 6612 bnes 5799c <msdos_dir_read+0x2c6> <== NOT EXECUTED
5798a: 4280 clrl %d0 <== NOT EXECUTED
5798c: 102e fec7 moveb %fp@(-313),%d0 <== NOT EXECUTED
57990: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
57996: b280 cmpl %d0,%d1 <== NOT EXECUTED
57998: 6700 01c4 beqw 57b5e <msdos_dir_read+0x488> <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
5799c: 41ed 0008 lea %a5@(8),%a0 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
579a0: 7008 moveq #8,%d0 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
579a2: 2d48 fed4 movel %a0,%fp@(-300) <== NOT EXECUTED
579a6: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
579aa: 6004 bras 579b0 <msdos_dir_read+0x2da> <== NOT EXECUTED
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
579ac: 5380 subql #1,%d0 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
579ae: 670a beqs 579ba <msdos_dir_read+0x2e4> <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
579b0: 7e20 moveq #32,%d7 <== NOT EXECUTED
579b2: 1220 moveb %a0@-,%d1 <== NOT EXECUTED
579b4: 49c1 extbl %d1 <== NOT EXECUTED
579b6: be81 cmpl %d1,%d7 <== NOT EXECUTED
579b8: 67f2 beqs 579ac <msdos_dir_read+0x2d6> <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
579ba: 2079 0006 8a34 moveal 68a34 <__ctype_ptr__>,%a0 <== NOT EXECUTED
579c0: 2200 movel %d0,%d1 <== NOT EXECUTED
579c2: 224d moveal %a5,%a1 <== NOT EXECUTED
579c4: 2d48 febe movel %a0,%fp@(-322) <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
579c8: 206e fed0 moveal %fp@(-304),%a0 <== NOT EXECUTED
579cc: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
579d0: 2d48 fecc movel %a0,%fp@(-308) <== NOT EXECUTED
579d4: 2d42 feae movel %d2,%fp@(-338) <== NOT EXECUTED
579d8: 2d40 feaa movel %d0,%fp@(-342) <== NOT EXECUTED
579dc: 602c bras 57a0a <msdos_dir_read+0x334> <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
579de: 4287 clrl %d7 <== NOT EXECUTED
579e0: 1e19 moveb %a1@+,%d7 <== NOT EXECUTED
579e2: 7403 moveq #3,%d2 <== NOT EXECUTED
579e4: 206e febe moveal %fp@(-322),%a0 <== NOT EXECUTED
579e8: 1030 7801 moveb %a0@(00000001,%d7:l),%d0 <== NOT EXECUTED
579ec: 49c0 extbl %d0 <== NOT EXECUTED
579ee: c082 andl %d2,%d0 <== NOT EXECUTED
579f0: 143c 0001 moveb #1,%d2 <== NOT EXECUTED
579f4: b480 cmpl %d0,%d2 <== NOT EXECUTED
579f6: 6606 bnes 579fe <msdos_dir_read+0x328> <== NOT EXECUTED
579f8: 0687 0000 0020 addil #32,%d7 <== NOT EXECUTED
579fe: 206e fecc moveal %fp@(-308),%a0 <== NOT EXECUTED
57a02: 5381 subql #1,%d1 <== NOT EXECUTED
57a04: 52ae fecc addql #1,%fp@(-308) <== NOT EXECUTED
57a08: 10c7 moveb %d7,%a0@+ <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
57a0a: 4a81 tstl %d1 <== NOT EXECUTED
57a0c: 6ed0 bgts 579de <msdos_dir_read+0x308> <== NOT EXECUTED
57a0e: 202e feaa movel %fp@(-342),%d0 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
57a12: 2e00 movel %d0,%d7 <== NOT EXECUTED
57a14: 4687 notl %d7 <== NOT EXECUTED
57a16: 41ee fee8 lea %fp@(-280),%a0 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
57a1a: 7220 moveq #32,%d1 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
57a1c: de87 addl %d7,%d7 <== NOT EXECUTED
57a1e: 9f87 subxl %d7,%d7 <== NOT EXECUTED
57a20: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
57a24: 242e feae movel %fp@(-338),%d2 <== NOT EXECUTED
57a28: ce80 andl %d0,%d7 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
57a2a: 1a2d 000a moveb %a5@(10),%d5 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
57a2e: 43f0 7800 lea %a0@(00000000,%d7:l),%a1 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
57a32: 49c5 extbl %d5 <== NOT EXECUTED
57a34: b285 cmpl %d5,%d1 <== NOT EXECUTED
57a36: 6600 013a bnew 57b72 <msdos_dir_read+0x49c> <== NOT EXECUTED
57a3a: 1a2d 0009 moveb %a5@(9),%d5 <== NOT EXECUTED
57a3e: 49c5 extbl %d5 <== NOT EXECUTED
57a40: b285 cmpl %d5,%d1 <== NOT EXECUTED
57a42: 6600 0132 bnew 57b76 <msdos_dir_read+0x4a0> <== NOT EXECUTED
57a46: 1a2d 0008 moveb %a5@(8),%d5 <== NOT EXECUTED
57a4a: 49c5 extbl %d5 <== NOT EXECUTED
57a4c: b285 cmpl %d5,%d1 <== NOT EXECUTED
57a4e: 6754 beqs 57aa4 <msdos_dir_read+0x3ce> <== NOT EXECUTED
57a50: 123c 0001 moveb #1,%d1 <== NOT EXECUTED
57a54: 6000 0122 braw 57b78 <msdos_dir_read+0x4a2> <== NOT EXECUTED
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
57a58: 226e fed4 moveal %fp@(-300),%a1 <== NOT EXECUTED
57a5c: 4287 clrl %d7 <== NOT EXECUTED
57a5e: 1e19 moveb %a1@+,%d7 <== NOT EXECUTED
57a60: 7203 moveq #3,%d1 <== NOT EXECUTED
57a62: 52ae fed4 addql #1,%fp@(-300) <== NOT EXECUTED
57a66: 226e febe moveal %fp@(-322),%a1 <== NOT EXECUTED
57a6a: 1031 7801 moveb %a1@(00000001,%d7:l),%d0 <== NOT EXECUTED
57a6e: 49c0 extbl %d0 <== NOT EXECUTED
57a70: c081 andl %d1,%d0 <== NOT EXECUTED
57a72: 123c 0001 moveb #1,%d1 <== NOT EXECUTED
57a76: b280 cmpl %d0,%d1 <== NOT EXECUTED
57a78: 6606 bnes 57a80 <msdos_dir_read+0x3aa> <== NOT EXECUTED
57a7a: 0687 0000 0020 addil #32,%d7 <== NOT EXECUTED
57a80: 5388 subql #1,%a0 <== NOT EXECUTED
57a82: 1ac7 moveb %d7,%a5@+ <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
57a84: 4a88 tstl %a0 <== NOT EXECUTED
57a86: 6ed0 bgts 57a58 <msdos_dir_read+0x382> <== NOT EXECUTED
57a88: 222e feae movel %fp@(-338),%d1 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
57a8c: 2001 movel %d1,%d0 <== NOT EXECUTED
57a8e: 4680 notl %d0 <== NOT EXECUTED
57a90: d080 addl %d0,%d0 <== NOT EXECUTED
57a92: 9180 subxl %d0,%d0 <== NOT EXECUTED
57a94: 226e feaa moveal %fp@(-342),%a1 <== NOT EXECUTED
57a98: c081 andl %d1,%d0 <== NOT EXECUTED
57a9a: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
57a9e: d3c0 addal %d0,%a1 <== NOT EXECUTED
57aa0: d0ae fecc addl %fp@(-308),%d0 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
57aa4: 7eff moveq #-1,%d7 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
57aa6: 4211 clrb %a1@ <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
57aa8: 3d40 fee6 movew %d0,%fp@(-282) <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
57aac: 4878 0110 pea 110 <DBL_MANT_DIG+0xdb> <== NOT EXECUTED
57ab0: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
57ab4: 486e fed8 pea %fp@(-296) <== NOT EXECUTED
57ab8: 4870 2800 pea %a0@(00000000,%d2:l) <== NOT EXECUTED
57abc: 4eb9 0005 87d8 jsr 587d8 <memcpy> <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
57ac2: 4280 clrl %d0 <== NOT EXECUTED
57ac4: 223c 0000 0110 movel #272,%d1 <== NOT EXECUTED
57aca: d3ab 0010 addl %d1,%a3@(16) <== NOT EXECUTED
57ace: 2a2b 000c movel %a3@(12),%d5 <== NOT EXECUTED
57ad2: db80 addxl %d0,%d5 <== NOT EXECUTED
57ad4: 2745 000c movel %d5,%a3@(12) <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
57ad8: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
57adc: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
57ae0: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
57ae6: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
57aea: 4a80 tstl %d0 <== NOT EXECUTED
57aec: 660e bnes 57afc <msdos_dir_read+0x426> <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
57aee: 0682 0000 0110 addil #272,%d2 <== NOT EXECUTED
count -= (sizeof(struct dirent));
57af4: 0686 ffff fef0 addil #-272,%d6 <== NOT EXECUTED
57afa: 601c bras 57b18 <msdos_dir_read+0x442> <== NOT EXECUTED
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
57afc: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
57b00: 2d40 feb6 movel %d0,%fp@(-330) <== NOT EXECUTED
57b04: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
57b0a: 222e feb6 movel %fp@(-330),%d1 <== NOT EXECUTED
57b0e: 588f addql #4,%sp <== NOT EXECUTED
57b10: 6040 bras 57b52 <msdos_dir_read+0x47c> <== NOT EXECUTED
57b12: 2409 movel %a1,%d2 <== NOT EXECUTED
57b14: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
}
}
if (count <= 0)
57b18: 4a86 tstl %d6 <== NOT EXECUTED
57b1a: 6604 bnes 57b20 <msdos_dir_read+0x44a> <== NOT EXECUTED
57b1c: 6018 bras 57b36 <msdos_dir_read+0x460> <== NOT EXECUTED
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
57b1e: 7eff moveq #-1,%d7 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
57b20: 0684 0000 0020 addil #32,%d4 <== NOT EXECUTED
57b26: 6006 bras 57b2e <msdos_dir_read+0x458> <== NOT EXECUTED
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
57b28: 4284 clrl %d4 <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
57b2a: 2d45 feb2 movel %d5,%fp@(-334) <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
57b2e: b8ae feba cmpl %fp@(-326),%d4 <== NOT EXECUTED
57b32: 6500 fcac bcsw 577e0 <msdos_dir_read+0x10a> <== NOT EXECUTED
57b36: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
57b3a: daae fec2 addl %fp@(-318),%d5 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
57b3e: 4a86 tstl %d6 <== NOT EXECUTED
57b40: 6600 fc5a bnew 5779c <msdos_dir_read+0xc6> <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
57b44: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
57b48: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return cmpltd;
57b4e: 588f addql #4,%sp <== NOT EXECUTED
57b50: 2202 movel %d2,%d1 <== NOT EXECUTED
}
57b52: 2001 movel %d1,%d0 <== NOT EXECUTED
57b54: 4cee 3cfc fe80 moveml %fp@(-384),%d2-%d7/%a2-%a5 <== NOT EXECUTED
57b5a: 4e5e unlk %fp <== NOT EXECUTED
57b5c: 4e75 rts <== NOT EXECUTED
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
tmp_dirent.d_name, entry); /* src text */
}
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
57b5e: 2f2e fed0 movel %fp@(-304),%sp@- <== NOT EXECUTED
57b62: 4eb9 0005 95bc jsr 595bc <strlen> <== NOT EXECUTED
57b68: 588f addql #4,%sp <== NOT EXECUTED
57b6a: 3d40 fee6 movew %d0,%fp@(-282) <== NOT EXECUTED
57b6e: 6000 ff3c braw 57aac <msdos_dir_read+0x3d6> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
57b72: 7203 moveq #3,%d1 <== NOT EXECUTED
57b74: 6002 bras 57b78 <msdos_dir_read+0x4a2> <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
57b76: 7202 moveq #2,%d1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
57b78: 41f6 7800 lea %fp@(00000000,%d7:l),%a0 <== NOT EXECUTED
57b7c: 5289 addql #1,%a1 <== NOT EXECUTED
57b7e: 2a49 moveal %a1,%a5 <== NOT EXECUTED
57b80: 7e2e moveq #46,%d7 <== NOT EXECUTED
57b82: 2d41 feae movel %d1,%fp@(-338) <== NOT EXECUTED
57b86: 2a2e feb2 movel %fp@(-334),%d5 <== NOT EXECUTED
57b8a: 1147 fee8 moveb %d7,%a0@(-280) <== NOT EXECUTED
len += i + 1; /* extension + dot */
57b8e: 2041 moveal %d1,%a0 <== NOT EXECUTED
57b90: 41f0 0801 lea %a0@(00000001,%d0:l),%a0 <== NOT EXECUTED
57b94: 2d49 feaa movel %a1,%fp@(-342) <== NOT EXECUTED
57b98: 2d48 fecc movel %a0,%fp@(-308) <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
57b9c: 2079 0006 8a34 moveal 68a34 <__ctype_ptr__>,%a0 <== NOT EXECUTED
57ba2: 2d48 febe movel %a0,%fp@(-322) <== NOT EXECUTED
57ba6: 2041 moveal %d1,%a0 <== NOT EXECUTED
57ba8: 6000 feda braw 57a84 <msdos_dir_read+0x3ae> <== NOT EXECUTED
00057ce8 <msdos_dir_rmnod>:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
57ce8: 4e56 ffec linkw %fp,#-20 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
57cec: 4200 clrb %d0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
57cee: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED
57cf2: 266e 000c moveal %fp@(12),%a3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
57cf6: 206b 0010 moveal %a3@(16),%a0 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
57cfa: 2853 moveal %a3@,%a4 <== NOT EXECUTED
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
57cfc: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
57d00: 42a7 clrl %sp@- <== NOT EXECUTED
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
57d02: 1d40 ffff moveb %d0,%fp@(-1) <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
57d06: 42a7 clrl %sp@- <== NOT EXECUTED
57d08: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
57d0c: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
57d12: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57d16: 4a80 tstl %d0 <== NOT EXECUTED
57d18: 670e beqs 57d28 <msdos_dir_rmnod+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
57d1a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
57d20: 7405 moveq #5,%d2 <== NOT EXECUTED
57d22: 2040 moveal %d0,%a0 <== NOT EXECUTED
57d24: 2082 movel %d2,%a0@ <== NOT EXECUTED
57d26: 6020 bras 57d48 <msdos_dir_rmnod+0x60> <== NOT EXECUTED
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
57d28: 7001 moveq #1,%d0 <== NOT EXECUTED
57d2a: b0ac 0008 cmpl %a4@(8),%d0 <== NOT EXECUTED
57d2e: 641e bccs 57d4e <msdos_dir_rmnod+0x66> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
57d30: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
57d34: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EBUSY);
57d3a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
57d40: 7210 moveq #16,%d1 <== NOT EXECUTED
57d42: 2040 moveal %d0,%a0 <== NOT EXECUTED
57d44: 2081 movel %d1,%a0@ <== NOT EXECUTED
57d46: 588f addql #4,%sp <== NOT EXECUTED
57d48: 74ff moveq #-1,%d2 <== NOT EXECUTED
57d4a: 6000 0084 braw 57dd0 <msdos_dir_rmnod+0xe8> <== NOT EXECUTED
}
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
57d4e: 486e ffff pea %fp@(-1) <== NOT EXECUTED
57d52: 2f0c movel %a4,%sp@- <== NOT EXECUTED
57d54: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
57d58: 4eb9 0005 5530 jsr 55530 <msdos_dir_is_empty> <== NOT EXECUTED
if (rc != RC_OK)
57d5e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
57d62: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
57d64: 6642 bnes 57da8 <msdos_dir_rmnod+0xc0> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (!is_empty)
57d66: 4a2e ffff tstb %fp@(-1) <== NOT EXECUTED
57d6a: 6618 bnes 57d84 <msdos_dir_rmnod+0x9c> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
57d6c: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
57d70: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
57d76: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
57d7c: 2040 moveal %d0,%a0 <== NOT EXECUTED
57d7e: 705a moveq #90,%d0 <== NOT EXECUTED
57d80: 2080 movel %d0,%a0@ <== NOT EXECUTED
57d82: 60c2 bras 57d46 <msdos_dir_rmnod+0x5e> <== NOT EXECUTED
57d84: 206b 0010 moveal %a3@(16),%a0 <== NOT EXECUTED
}
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_is_root_location(pathloc))
57d88: 2013 movel %a3@,%d0 <== NOT EXECUTED
57d8a: b0a8 001c cmpl %a0@(28),%d0 <== NOT EXECUTED
57d8e: 67a0 beqs 57d30 <msdos_dir_rmnod+0x48> <== NOT EXECUTED
* You cannot remove a mountpoint.
* not used - mount() not implemenetd yet.
*/
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
57d90: 4878 00e5 pea e5 <DBL_MANT_DIG+0xb0> <== NOT EXECUTED
57d94: 486c 0020 pea %a4@(32) <== NOT EXECUTED
57d98: 2f08 movel %a0,%sp@- <== NOT EXECUTED
57d9a: 4eb9 0005 5416 jsr 55416 <msdos_set_first_char4file_name> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
57da0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* You cannot remove a mountpoint.
* not used - mount() not implemenetd yet.
*/
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
57da4: 2400 movel %d0,%d2 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
57da6: 670e beqs 57db6 <msdos_dir_rmnod+0xce> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
57da8: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
57dac: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
57db2: 588f addql #4,%sp <== NOT EXECUTED
57db4: 601a bras 57dd0 <msdos_dir_rmnod+0xe8> <== NOT EXECUTED
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
57db6: 2f0c movel %a4,%sp@- <== NOT EXECUTED
57db8: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
57dbc: 4eb9 0005 026a jsr 5026a <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
57dc2: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
57dc6: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
57dcc: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
57dd0: 2002 movel %d2,%d0 <== NOT EXECUTED
57dd2: 4cee 1c04 ffec moveml %fp@(-20),%d2/%a2-%a4 <== NOT EXECUTED
57dd8: 4e5e unlk %fp <== NOT EXECUTED
00057bd2 <msdos_dir_stat>:
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
57bd2: 4e56 fff4 linkw %fp,#-12
57bd6: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
57bda: 2268 0010 moveal %a0@(16),%a1
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
57bde: 48d7 1c00 moveml %a2-%a4,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
57be2: 2669 0034 moveal %a1@(52),%a3
fat_file_fd_t *fat_fd = loc->node_access;
57be6: 2850 moveal %a0@,%a4
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
57be8: 42a7 clrl %sp@-
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
57bea: 246e 000c moveal %fp@(12),%a2
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
57bee: 42a7 clrl %sp@-
57bf0: 2f2b 0088 movel %a3@(136),%sp@-
57bf4: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
57bfa: 4fef 000c lea %sp@(12),%sp
57bfe: 4a80 tstl %d0
57c00: 6710 beqs 57c12 <msdos_dir_stat+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
57c02: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
57c08: 7205 moveq #5,%d1 <== NOT EXECUTED
57c0a: 2040 moveal %d0,%a0 <== NOT EXECUTED
57c0c: 70ff moveq #-1,%d0 <== NOT EXECUTED
57c0e: 2081 movel %d1,%a0@ <== NOT EXECUTED
57c10: 605a bras 57c6c <msdos_dir_stat+0x9a> <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
57c12: 202b 004a movel %a3@(74),%d0
57c16: 222b 004e movel %a3@(78),%d1
buf->st_ino = fat_fd->ino;
57c1a: 256c 000c 0008 movel %a4@(12),%a2@(8)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
57c20: 2480 movel %d0,%a2@
57c22: 2541 0004 movel %d1,%a2@(4)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
57c26: 223c 0000 41ff movel #16895,%d1
57c2c: 2541 000c movel %d1,%a2@(12)
buf->st_rdev = 0ll;
57c30: 4280 clrl %d0
57c32: 4281 clrl %d1
57c34: 2540 0016 movel %d0,%a2@(22)
57c38: 2541 001a movel %d1,%a2@(26)
buf->st_size = fat_fd->fat_file_size;
57c3c: 202c 0018 movel %a4@(24),%d0
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
57c40: 7209 moveq #9,%d1
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
57c42: 2540 0022 movel %d0,%a2@(34)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
57c46: e2a8 lsrl %d1,%d0
57c48: 2540 0042 movel %d0,%a2@(66)
buf->st_blksize = fs_info->fat.vol.bps;
57c4c: 4280 clrl %d0
57c4e: 3013 movew %a3@,%d0
buf->st_mtime = fat_fd->mtime;
57c50: 256c 003e 002e movel %a4@(62),%a2@(46)
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
57c56: 42aa 001e clrl %a2@(30)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
57c5a: 2540 003e movel %d0,%a2@(62)
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
57c5e: 2f2b 0088 movel %a3@(136),%sp@-
57c62: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return RC_OK;
57c68: 588f addql #4,%sp
57c6a: 4280 clrl %d0
}
57c6c: 4cee 1c00 fff4 moveml %fp@(-12),%a2-%a4
57c72: 4e5e unlk %fp <== NOT EXECUTED
00057c76 <msdos_dir_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
57c76: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
57c7a: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
57c7e: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
57c82: 206a 0028 moveal %a2@(40),%a0 <== NOT EXECUTED
int
msdos_dir_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
57c86: 242a 0018 movel %a2@(24),%d2 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
57c8a: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
57c8e: 42a7 clrl %sp@- <== NOT EXECUTED
57c90: 42a7 clrl %sp@- <== NOT EXECUTED
57c92: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
57c96: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
57c9c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57ca0: 4a80 tstl %d0 <== NOT EXECUTED
57ca2: 6712 beqs 57cb6 <msdos_dir_sync+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
57ca4: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
57caa: 7405 moveq #5,%d2 <== NOT EXECUTED
57cac: 2040 moveal %d0,%a0 <== NOT EXECUTED
57cae: 347c ffff moveaw #-1,%a2 <== NOT EXECUTED
57cb2: 2082 movel %d2,%a0@ <== NOT EXECUTED
57cb4: 601c bras 57cd2 <msdos_dir_sync+0x5c> <== NOT EXECUTED
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
57cb6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57cb8: 2f2a 0028 movel %a2@(40),%sp@- <== NOT EXECUTED
57cbc: 4eb9 0005 02c8 jsr 502c8 <fat_file_datasync> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
57cc2: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
57cc6: 2440 moveal %d0,%a2 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
57cc8: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
57cce: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
57cd2: 200a movel %a2,%d0 <== NOT EXECUTED
57cd4: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
57cda: 4e5e unlk %fp <== NOT EXECUTED
000545de <msdos_eval4make>:
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
545de: 4e56 ffbc linkw %fp,#-68
545e2: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
545e6: 246e 000c moveal %fp@(12),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
545ea: 206a 0010 moveal %a2@(16),%a0
545ee: 2868 0034 moveal %a0@(52),%a4
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
545f2: 42a7 clrl %sp@-
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
545f4: 2a6e 0008 moveal %fp@(8),%a5
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
545f8: 42a7 clrl %sp@-
545fa: 2f2c 0088 movel %a4@(136),%sp@-
545fe: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54604: 4fef 000c lea %sp@(12),%sp
54608: 4a80 tstl %d0
5460a: 6712 beqs 5461e <msdos_eval4make+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
5460c: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54612: 76ff moveq #-1,%d3 <== NOT EXECUTED
54614: 7205 moveq #5,%d1 <== NOT EXECUTED
54616: 2040 moveal %d0,%a0 <== NOT EXECUTED
54618: 2081 movel %d1,%a0@ <== NOT EXECUTED
5461a: 6000 01f4 braw 54810 <msdos_eval4make+0x232> <== NOT EXECUTED
if (!pathloc->node_access)
5461e: 2012 movel %a2@,%d0
54620: 6612 bnes 54634 <msdos_eval4make+0x56> <== ALWAYS TAKEN
{
errno = ENOENT;
54622: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
rc = -1;
54628: 76ff moveq #-1,%d3 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
{
errno = ENOENT;
5462a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5462c: 7002 moveq #2,%d0 <== NOT EXECUTED
5462e: 2080 movel %d0,%a0@ <== NOT EXECUTED
rc = -1;
goto err;
54630: 6000 01d2 braw 54804 <msdos_eval4make+0x226> <== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
54634: 2f00 movel %d0,%sp@-
54636: 4eb9 0004 fb54 jsr 4fb54 <fat_file_reopen>
if (rc != RC_OK)
5463c: 588f addql #4,%sp
goto err;
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
5463e: 2600 movel %d0,%d3
if (rc != RC_OK)
54640: 6600 01c2 bnew 54804 <msdos_eval4make+0x226>
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
54644: 2e0e movel %fp,%d7
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
54646: 4284 clrl %d4
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
54648: 5987 subql #4,%d7
5464a: 2c3c 0005 514c movel #348492,%d6
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
54650: 2a3c 0005 625e movel #352862,%d5
if (rc != RC_OK)
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
54656: 240d movel %a5,%d2
54658: d484 addl %d4,%d2
5465a: 2f02 movel %d2,%sp@-
5465c: 4eb9 0005 95bc jsr 595bc <strlen>
54662: 588f addql #4,%sp
54664: 2046 moveal %d6,%a0
54666: 486e fff8 pea %fp@(-8)
5466a: 2f07 movel %d7,%sp@-
5466c: 2f00 movel %d0,%sp@-
5466e: 2f02 movel %d2,%sp@-
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
54670: 7402 moveq #2,%d2
if (rc != RC_OK)
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
54672: 4e90 jsr %a0@
i += token_len;
54674: 222e fff8 movel %fp@(-8),%d1
fat_fd = pathloc->node_access;
switch (type)
54678: 4fef 0010 lea %sp@(16),%sp
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
i += token_len;
5467c: d881 addl %d1,%d4
fat_fd = pathloc->node_access;
5467e: 2652 moveal %a2@,%a3
switch (type)
54680: b480 cmpl %d0,%d2
54682: 671c beqs 546a0 <msdos_eval4make+0xc2>
54684: 6508 bcss 5468e <msdos_eval4make+0xb0>
54686: 4a80 tstl %d0
54688: 6700 00fa beqw 54784 <msdos_eval4make+0x1a6>
5468c: 60c8 bras 54656 <msdos_eval4make+0x78>
5468e: 7403 moveq #3,%d2
54690: b480 cmpl %d0,%d2
54692: 6700 00c8 beqw 5475c <msdos_eval4make+0x17e>
54696: 7204 moveq #4,%d1 <== NOT EXECUTED
54698: b280 cmpl %d0,%d1 <== NOT EXECUTED
5469a: 66ba bnes 54656 <msdos_eval4make+0x78> <== NOT EXECUTED
5469c: 6000 00f4 braw 54792 <msdos_eval4make+0x1b4> <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
546a0: 7401 moveq #1,%d2
546a2: b4ab 0010 cmpl %a3@(16),%d2
546a6: 6600 012c bnew 547d4 <msdos_eval4make+0x1f6>
546aa: 206a 0010 moveal %a2@(16),%a0
546ae: 2428 001c movel %a0@(28),%d2
}
/*
* Am I at the root of this mounted filesystem?
*/
if (rtems_filesystem_is_root_location(pathloc))
546b2: b7c2 cmpal %d2,%a3
546b4: 6672 bnes 54728 <msdos_eval4make+0x14a> <== NEVER TAKEN
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
546b6: 2279 0006 8950 moveal 68950 <rtems_current_user_env>,%a1
{
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
546bc: b4a9 0018 cmpl %a1@(24),%d2
546c0: 6794 beqs 54656 <msdos_eval4make+0x78> <== ALWAYS TAKEN
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
546c2: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
546c6: 260e movel %fp,%d3 <== NOT EXECUTED
546c8: 4868 0008 pea %a0@(8) <== NOT EXECUTED
546cc: 0683 ffff ffe4 addil #-28,%d3 <== NOT EXECUTED
546d2: 47f9 0005 87d8 lea 587d8 <memcpy>,%a3 <== NOT EXECUTED
546d8: 2f03 movel %d3,%sp@- <== NOT EXECUTED
546da: 4e93 jsr %a3@ <== NOT EXECUTED
*pathloc = newloc;
546dc: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
546e0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
546e2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
546e4: 4e93 jsr %a3@ <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
546e6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
546e8: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
546ec: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
546f2: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
546f6: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
546f8: 6600 010a bnew 54804 <msdos_eval4make+0x226> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
546fc: 2f2c 0088 movel %a4@(136),%sp@- <== NOT EXECUTED
54700: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(&path[i-token_len],
54706: 206a 000c moveal %a2@(12),%a0 <== NOT EXECUTED
5470a: 98ae fff8 subl %fp@(-8),%d4 <== NOT EXECUTED
5470e: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
54712: 2f0a movel %a2,%sp@- <== NOT EXECUTED
54714: 4875 4800 pea %a5@(00000000,%d4:l) <== NOT EXECUTED
54718: 2068 0004 moveal %a0@(4),%a0 <== NOT EXECUTED
5471c: 4e90 jsr %a0@ <== NOT EXECUTED
5471e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
54722: 2600 movel %d0,%d3 <== NOT EXECUTED
54724: 6000 00ea braw 54810 <msdos_eval4make+0x232> <== NOT EXECUTED
pathloc, name);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
54728: 2f01 movel %d1,%sp@- <== NOT EXECUTED
5472a: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
5472e: 2045 moveal %d5,%a0 <== NOT EXECUTED
54730: 2f0a movel %a2,%sp@- <== NOT EXECUTED
54732: 4e90 jsr %a0@ <== NOT EXECUTED
if (rc != RC_OK)
54734: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
54738: 4a80 tstl %d0 <== NOT EXECUTED
5473a: 6700 ff1a beqw 54656 <msdos_eval4make+0x78> <== NOT EXECUTED
5473e: 2400 movel %d0,%d2 <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
54740: 0c80 0000 7d01 cmpil #32001,%d0 <== NOT EXECUTED
54746: 6600 00ac bnew 547f4 <msdos_eval4make+0x216> <== NOT EXECUTED
{
errno = ENOENT;
5474a: 4eb9 0005 7e64 jsr 57e64 <__errno>
54750: 7e02 moveq #2,%d7
54752: 2040 moveal %d0,%a0
54754: 2087 movel %d7,%a0@
rc = -1;
54756: 74ff moveq #-1,%d2
54758: 6000 009a braw 547f4 <msdos_eval4make+0x216>
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
5475c: 7001 moveq #1,%d0
5475e: b0ab 0010 cmpl %a3@(16),%d0
54762: 6670 bnes 547d4 <msdos_eval4make+0x1f6>
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
54764: 2f01 movel %d1,%sp@-
54766: 2f2e fffc movel %fp@(-4),%sp@-
5476a: 2045 moveal %d5,%a0
5476c: 2f0a movel %a2,%sp@-
5476e: 4e90 jsr %a0@
if (rc)
54770: 4fef 000c lea %sp@(12),%sp
54774: 4a80 tstl %d0
54776: 6700 fede beqw 54656 <msdos_eval4make+0x78>
{
if (rc != MSDOS_NAME_NOT_FOUND_ERR)
5477a: 0c80 0000 7d01 cmpil #32001,%d0
54780: 671e beqs 547a0 <msdos_eval4make+0x1c2> <== ALWAYS TAKEN
54782: 60c6 bras 5474a <msdos_eval4make+0x16c> <== NOT EXECUTED
done = true;
}
break;
case MSDOS_NO_MORE_PATH:
errno = EEXIST;
54784: 4eb9 0005 7e64 jsr 57e64 <__errno>
5478a: 7c11 moveq #17,%d6
5478c: 2040 moveal %d0,%a0
5478e: 2086 movel %d6,%a0@
54790: 60c4 bras 54756 <msdos_eval4make+0x178>
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
54792: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54798: 7a5b moveq #91,%d5 <== NOT EXECUTED
5479a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5479c: 2085 movel %d5,%a0@ <== NOT EXECUTED
5479e: 60b6 bras 54756 <msdos_eval4make+0x178> <== NOT EXECUTED
break;
}
}
*name = &path[i - token_len];
547a0: 2004 movel %d4,%d0
547a2: 90ae fff8 subl %fp@(-8),%d0
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
{
if (!msdos_is_separator(path[i]))
547a6: 243c 0004 6a68 movel #289384,%d2
break;
}
}
*name = &path[i - token_len];
547ac: d08d addl %a5,%d0
* RETURNS:
* RC_OK, filled pathloc for parent directory and name of new node on
* success, or -1 if error occured (errno set appropriately)
*/
int
msdos_eval4make(
547ae: dbc4 addal %d4,%a5
break;
}
}
*name = &path[i - token_len];
547b0: 206e 0010 moveal %fp@(16),%a0
547b4: 2080 movel %d0,%a0@
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
547b6: 600e bras 547c6 <msdos_eval4make+0x1e8>
{
if (!msdos_is_separator(path[i]))
547b8: 49c0 extbl %d0
547ba: 2042 moveal %d2,%a0
547bc: 2f00 movel %d0,%sp@-
547be: 4e90 jsr %a0@
547c0: 588f addql #4,%sp
547c2: 4a80 tstl %d0
547c4: 6784 beqs 5474a <msdos_eval4make+0x16c>
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
547c6: 101d moveb %a5@+,%d0
547c8: 66ee bnes 547b8 <msdos_eval4make+0x1da>
rc = -1;
goto error;
}
}
fat_fd = pathloc->node_access;
547ca: 2652 moveal %a2@,%a3
if (fat_fd->fat_file_type != FAT_DIRECTORY)
547cc: 7001 moveq #1,%d0
547ce: b0ab 0010 cmpl %a3@(16),%d0
547d2: 6710 beqs 547e4 <msdos_eval4make+0x206> <== ALWAYS TAKEN
{
errno = ENOTDIR;
547d4: 4eb9 0005 7e64 jsr 57e64 <__errno>
547da: 7814 moveq #20,%d4
547dc: 2040 moveal %d0,%a0
547de: 2084 movel %d4,%a0@
547e0: 6000 ff74 braw 54756 <msdos_eval4make+0x178>
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
547e4: 206a 0010 moveal %a2@(16),%a0
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
547e8: 2068 0034 moveal %a0@(52),%a0
547ec: 2568 0080 0008 movel %a0@(128),%a2@(8)
547f2: 6010 bras 54804 <msdos_eval4make+0x226>
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
547f4: 2f0b movel %a3,%sp@-
547f6: 2f2a 0010 movel %a2@(16),%sp@-
547fa: 2602 movel %d2,%d3
547fc: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close>
54802: 508f addql #8,%sp
err:
rtems_semaphore_release(fs_info->vol_sema);
54804: 2f2c 0088 movel %a4@(136),%sp@-
54808: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
5480e: 588f addql #4,%sp
}
54810: 2003 movel %d3,%d0
54812: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
54818: 4e5e unlk %fp <== NOT EXECUTED
000543ec <msdos_eval_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
543ec: 4e56 ffbc linkw %fp,#-68
543f0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
543f4: 246e 0014 moveal %fp@(20),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
543f8: 206a 0010 moveal %a2@(16),%a0
543fc: 2668 0034 moveal %a0@(52),%a3
int i = 0;
int token_len = 0;
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54400: 42a7 clrl %sp@-
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
54402: 2a2e 0008 movel %fp@(8),%d5
int i = 0;
int token_len = 0;
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54406: 42a7 clrl %sp@-
54408: 2f2b 0088 movel %a3@(136),%sp@-
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
5440c: 2a6e 000c moveal %fp@(12),%a5
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
rtems_filesystem_location_info_t newloc;
int i = 0;
int token_len = 0;
54410: 42ae fff8 clrl %fp@(-8)
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54414: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
5441a: 4fef 000c lea %sp@(12),%sp
5441e: 4a80 tstl %d0
54420: 6712 beqs 54434 <msdos_eval_path+0x48> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
54422: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54428: 7605 moveq #5,%d3 <== NOT EXECUTED
5442a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5442c: 2083 movel %d3,%a0@ <== NOT EXECUTED
5442e: 76ff moveq #-1,%d3 <== NOT EXECUTED
54430: 6000 01a0 braw 545d2 <msdos_eval_path+0x1e6> <== NOT EXECUTED
if (!pathloc->node_access)
54434: 2012 movel %a2@,%d0
54436: 6612 bnes 5444a <msdos_eval_path+0x5e> <== ALWAYS TAKEN
{
errno = ENOENT;
54438: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
5443e: 7402 moveq #2,%d2 <== NOT EXECUTED
rc = -1;
54440: 76ff moveq #-1,%d3 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
{
errno = ENOENT;
54442: 2040 moveal %d0,%a0 <== NOT EXECUTED
54444: 2082 movel %d2,%a0@ <== NOT EXECUTED
rc = -1;
goto err;
54446: 6000 017e braw 545c6 <msdos_eval_path+0x1da> <== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
5444a: 2f00 movel %d0,%sp@-
5444c: 4eb9 0004 fb54 jsr 4fb54 <fat_file_reopen>
if (rc != RC_OK)
54452: 588f addql #4,%sp
goto err;
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
54454: 2600 movel %d0,%d3
if (rc != RC_OK)
54456: 6600 016e bnew 545c6 <msdos_eval_path+0x1da>
5445a: 4284 clrl %d4
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
5445c: 2e3c 0005 514c movel #348492,%d7
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
54462: 2c3c 0005 625e movel #352862,%d6
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
54468: 486e fff8 pea %fp@(-8)
5446c: 2045 moveal %d5,%a0
5446e: 486e fffc pea %fp@(-4)
pathnamelen -= token_len;
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
54472: 7403 moveq #3,%d2
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
54474: 2f0d movel %a5,%sp@-
54476: 4870 4800 pea %a0@(00000000,%d4:l)
5447a: 2047 moveal %d7,%a0
5447c: 4e90 jsr %a0@
pathnamelen -= token_len;
5447e: 222e fff8 movel %fp@(-8),%d1
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
54482: 4fef 0010 lea %sp@(16),%sp
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
pathnamelen -= token_len;
54486: 9bc1 subal %d1,%a5
i += token_len;
54488: d881 addl %d1,%d4
fat_fd = pathloc->node_access;
5448a: 2852 moveal %a2@,%a4
switch (type)
5448c: b480 cmpl %d0,%d2
5448e: 6700 00d2 beqw 54562 <msdos_eval_path+0x176>
54492: 143c 0004 moveb #4,%d2
54496: b480 cmpl %d0,%d2
54498: 6700 00e0 beqw 5457a <msdos_eval_path+0x18e>
5449c: 143c 0002 moveb #2,%d2
544a0: b480 cmpl %d0,%d2
544a2: 6600 00e4 bnew 54588 <msdos_eval_path+0x19c>
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
544a6: 7001 moveq #1,%d0
544a8: b0ac 0010 cmpl %a4@(16),%d0
544ac: 6600 00bc bnew 5456a <msdos_eval_path+0x17e>
544b0: 206a 0010 moveal %a2@(16),%a0
544b4: 2428 001c movel %a0@(28),%d2
}
/*
* Am I at the root of this mounted filesystem?
*/
if (rtems_filesystem_is_root_location(pathloc))
544b8: b9c2 cmpal %d2,%a4
544ba: 6678 bnes 54534 <msdos_eval_path+0x148> <== ALWAYS TAKEN
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
544bc: 2279 0006 8950 moveal 68950 <rtems_current_user_env>,%a1 <== NOT EXECUTED
{
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
544c2: b4a9 0018 cmpl %a1@(24),%d2 <== NOT EXECUTED
544c6: 67a0 beqs 54468 <msdos_eval_path+0x7c> <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
544c8: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
544cc: 260e movel %fp,%d3 <== NOT EXECUTED
544ce: 4868 0008 pea %a0@(8) <== NOT EXECUTED
544d2: 0683 ffff ffe4 addil #-28,%d3 <== NOT EXECUTED
544d8: 49f9 0005 87d8 lea 587d8 <memcpy>,%a4 <== NOT EXECUTED
544de: 2f03 movel %d3,%sp@- <== NOT EXECUTED
544e0: 4e94 jsr %a4@ <== NOT EXECUTED
*pathloc = newloc;
544e2: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
544e6: 2f03 movel %d3,%sp@- <== NOT EXECUTED
544e8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
544ea: 4e94 jsr %a4@ <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
544ec: 2f02 movel %d2,%sp@- <== NOT EXECUTED
544ee: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
544f2: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
544f8: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
544fc: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
544fe: 6600 00c6 bnew 545c6 <msdos_eval_path+0x1da> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
54502: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54506: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(&(pathname[i-token_len]),
5450c: 226a 000c moveal %a2@(12),%a1 <== NOT EXECUTED
54510: 2f0a movel %a2,%sp@- <== NOT EXECUTED
54512: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
54516: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
5451a: 4875 8800 pea %a5@(00000000,%a0:l) <== NOT EXECUTED
5451e: 9888 subl %a0,%d4 <== NOT EXECUTED
54520: 2045 moveal %d5,%a0 <== NOT EXECUTED
54522: 4870 4800 pea %a0@(00000000,%d4:l) <== NOT EXECUTED
54526: 2051 moveal %a1@,%a0 <== NOT EXECUTED
54528: 4e90 jsr %a0@ <== NOT EXECUTED
5452a: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
5452e: 2600 movel %d0,%d3 <== NOT EXECUTED
54530: 6000 00a0 braw 545d2 <msdos_eval_path+0x1e6> <== NOT EXECUTED
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
54534: 2f01 movel %d1,%sp@-
54536: 2f2e fffc movel %fp@(-4),%sp@-
5453a: 2046 moveal %d6,%a0
5453c: 2f0a movel %a2,%sp@-
5453e: 4e90 jsr %a0@
if (rc != RC_OK)
54540: 4fef 000c lea %sp@(12),%sp
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
54544: 2400 movel %d0,%d2
if (rc != RC_OK)
54546: 6700 ff20 beqw 54468 <msdos_eval_path+0x7c>
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
5454a: 0c80 0000 7d01 cmpil #32001,%d0
54550: 6664 bnes 545b6 <msdos_eval_path+0x1ca>
{
errno = ENOENT;
54552: 4eb9 0005 7e64 jsr 57e64 <__errno>
54558: 7202 moveq #2,%d1
5455a: 2040 moveal %d0,%a0
5455c: 2081 movel %d1,%a0@
rc = -1;
5455e: 74ff moveq #-1,%d2
54560: 6054 bras 545b6 <msdos_eval_path+0x1ca>
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
54562: 7001 moveq #1,%d0
54564: b0ac 0010 cmpl %a4@(16),%d0
54568: 67ca beqs 54534 <msdos_eval_path+0x148>
{
errno = ENOTSUP;
5456a: 4eb9 0005 7e64 jsr 57e64 <__errno>
54570: 2040 moveal %d0,%a0
54572: 20bc 0000 0086 movel #134,%a0@
54578: 60e4 bras 5455e <msdos_eval_path+0x172>
case MSDOS_NO_MORE_PATH:
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
5457a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54580: 2040 moveal %d0,%a0 <== NOT EXECUTED
54582: 705b moveq #91,%d0 <== NOT EXECUTED
54584: 2080 movel %d0,%a0@ <== NOT EXECUTED
54586: 60d6 bras 5455e <msdos_eval_path+0x172> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
54588: 4a80 tstl %d0
5458a: 6708 beqs 54594 <msdos_eval_path+0x1a8>
5458c: 7204 moveq #4,%d1
5458e: b280 cmpl %d0,%d1
54590: 6600 fed6 bnew 54468 <msdos_eval_path+0x7c>
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
54594: 206a 0010 moveal %a2@(16),%a0
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
54598: 7401 moveq #1,%d2
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
5459a: 2068 0034 moveal %a0@(52),%a0
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
5459e: 2252 moveal %a2@,%a1
545a0: b4a9 0010 cmpl %a1@(16),%d2
545a4: 6608 bnes 545ae <msdos_eval_path+0x1c2>
loc->handlers = fs_info->directory_handlers;
545a6: 2568 0080 0008 movel %a0@(128),%a2@(8)
545ac: 6018 bras 545c6 <msdos_eval_path+0x1da>
else
loc->handlers = fs_info->file_handlers;
545ae: 2568 0084 0008 movel %a0@(132),%a2@(8)
545b4: 6010 bras 545c6 <msdos_eval_path+0x1da>
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
545b6: 2f0c movel %a4,%sp@-
545b8: 2f2a 0010 movel %a2@(16),%sp@-
545bc: 2602 movel %d2,%d3
545be: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close>
545c4: 508f addql #8,%sp
err:
rtems_semaphore_release(fs_info->vol_sema);
545c6: 2f2b 0088 movel %a3@(136),%sp@-
545ca: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
545d0: 588f addql #4,%sp
}
545d2: 2003 movel %d3,%d0
545d4: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
545da: 4e5e unlk %fp <== NOT EXECUTED
00054db2 <msdos_file_chmod>:
int
msdos_file_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
54db2: 4280 clrl %d0 <== NOT EXECUTED
* RC_OK always
*/
int
msdos_file_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
54db4: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return RC_OK;
}
54db8: 4e5e unlk %fp <== NOT EXECUTED
000548a2 <msdos_file_close>:
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
548a2: 4e56 fff0 linkw %fp,#-16
548a6: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
548aa: 246e 0008 moveal %fp@(8),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
548ae: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
548b2: 286a 0018 moveal %a2@(24),%a4
int
msdos_file_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
548b6: 2668 0034 moveal %a0@(52),%a3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
548ba: 42a7 clrl %sp@-
548bc: 42a7 clrl %sp@-
548be: 2f2b 0088 movel %a3@(136),%sp@-
548c2: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
548c8: 4fef 000c lea %sp@(12),%sp
548cc: 4a80 tstl %d0
548ce: 6710 beqs 548e0 <msdos_file_close+0x3e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
548d0: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
548d6: 74ff moveq #-1,%d2 <== NOT EXECUTED
548d8: 7205 moveq #5,%d1 <== NOT EXECUTED
548da: 2040 moveal %d0,%a0 <== NOT EXECUTED
548dc: 2081 movel %d1,%a0@ <== NOT EXECUTED
548de: 605c bras 5493c <msdos_file_close+0x9a> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
548e0: 4280 clrl %d0
548e2: 102c 0030 moveb %a4@(48),%d0
548e6: 0800 0000 btst #0,%d0
548ea: 6634 bnes 54920 <msdos_file_close+0x7e> <== NEVER TAKEN
548ec: 605a bras 54948 <msdos_file_close+0xa6>
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
548ee: 2f0c movel %a4,%sp@-
548f0: 2f2a 0028 movel %a2@(40),%sp@-
548f4: 4eb9 0005 53a6 jsr 553a6 <msdos_set_file_size>
if (rc != RC_OK)
548fa: 508f addql #8,%sp
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
548fc: 2400 movel %d0,%d2
if (rc != RC_OK)
548fe: 6612 bnes 54912 <msdos_file_close+0x70> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
54900: 2f0c movel %a4,%sp@-
54902: 2f2a 0028 movel %a2@(40),%sp@-
54906: 4eb9 0005 521a jsr 5521a <msdos_set_dir_wrt_time_and_date>
if (rc != RC_OK)
5490c: 508f addql #8,%sp
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
5490e: 2400 movel %d0,%d2
if (rc != RC_OK)
54910: 670e beqs 54920 <msdos_file_close+0x7e> <== ALWAYS TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
54912: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54916: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
5491c: 588f addql #4,%sp <== NOT EXECUTED
5491e: 601c bras 5493c <msdos_file_close+0x9a> <== NOT EXECUTED
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
54920: 2f0c movel %a4,%sp@-
54922: 2f2a 0028 movel %a2@(40),%sp@-
54926: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close>
rtems_semaphore_release(fs_info->vol_sema);
5492c: 2f2b 0088 movel %a3@(136),%sp@-
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
54930: 2400 movel %d0,%d2
rtems_semaphore_release(fs_info->vol_sema);
54932: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
54938: 4fef 000c lea %sp@(12),%sp
}
5493c: 2002 movel %d2,%d0
5493e: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
54944: 4e5e unlk %fp
54946: 4e75 rts
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
54948: 2f0c movel %a4,%sp@-
5494a: 2f2a 0028 movel %a2@(40),%sp@-
5494e: 4eb9 0005 52f4 jsr 552f4 <msdos_set_first_cluster_num>
if (rc != RC_OK)
54954: 508f addql #8,%sp
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
54956: 2400 movel %d0,%d2
if (rc != RC_OK)
54958: 6794 beqs 548ee <msdos_file_close+0x4c> <== ALWAYS TAKEN
5495a: 60b6 bras 54912 <msdos_file_close+0x70> <== NOT EXECUTED
00054d44 <msdos_file_datasync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
54d44: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
54d48: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
54d4c: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54d50: 206a 0028 moveal %a2@(40),%a0 <== NOT EXECUTED
int
msdos_file_datasync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
54d54: 242a 0018 movel %a2@(24),%d2 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54d58: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54d5c: 42a7 clrl %sp@- <== NOT EXECUTED
54d5e: 42a7 clrl %sp@- <== NOT EXECUTED
54d60: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54d64: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54d6a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
54d6e: 4a80 tstl %d0 <== NOT EXECUTED
54d70: 6710 beqs 54d82 <msdos_file_datasync+0x3e> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
54d72: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54d78: 2040 moveal %d0,%a0 <== NOT EXECUTED
54d7a: 7005 moveq #5,%d0 <== NOT EXECUTED
54d7c: 2080 movel %d0,%a0@ <== NOT EXECUTED
54d7e: 70ff moveq #-1,%d0 <== NOT EXECUTED
54d80: 601c bras 54d9e <msdos_file_datasync+0x5a> <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
54d82: 2f02 movel %d2,%sp@- <== NOT EXECUTED
54d84: 2f2a 0028 movel %a2@(40),%sp@- <== NOT EXECUTED
54d88: 4eb9 0005 02c8 jsr 502c8 <fat_file_datasync> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
54d8e: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54d92: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
54d98: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
54d9c: 4280 clrl %d0 <== NOT EXECUTED
}
54d9e: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
54da4: 4e5e unlk %fp <== NOT EXECUTED
00054be2 <msdos_file_ftruncate>:
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
54be2: 4280 clrl %d0
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
54be4: 4e56 ffdc linkw %fp,#-36
54be8: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
54bec: 246e 0008 moveal %fp@(8),%a2
54bf0: 242e 000c movel %fp@(12),%d2
54bf4: 262e 0010 movel %fp@(16),%d3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54bf8: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
54bfc: 266a 0018 moveal %a2@(24),%a3
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54c00: 2868 0034 moveal %a0@(52),%a4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
54c04: 222b 0018 movel %a3@(24),%d1
54c08: 2802 movel %d2,%d4
54c0a: 2a03 movel %d3,%d5
54c0c: 9a81 subl %d1,%d5
54c0e: 9980 subxl %d0,%d4
54c10: 6c66 bges 54c78 <msdos_file_ftruncate+0x96>
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54c12: 42a7 clrl %sp@-
54c14: 42a7 clrl %sp@-
54c16: 2f2c 0088 movel %a4@(136),%sp@-
54c1a: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54c20: 4fef 000c lea %sp@(12),%sp
54c24: 4a80 tstl %d0
54c26: 6710 beqs 54c38 <msdos_file_ftruncate+0x56> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
54c28: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54c2e: 7405 moveq #5,%d2 <== NOT EXECUTED
54c30: 78ff moveq #-1,%d4 <== NOT EXECUTED
54c32: 2040 moveal %d0,%a0 <== NOT EXECUTED
54c34: 2082 movel %d2,%a0@ <== NOT EXECUTED
54c36: 6042 bras 54c7a <msdos_file_ftruncate+0x98> <== NOT EXECUTED
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
54c38: 2f03 movel %d3,%sp@-
54c3a: 2f0b movel %a3,%sp@-
54c3c: 2f2a 0028 movel %a2@(40),%sp@-
54c40: 4eb9 0004 fcdc jsr 4fcdc <fat_file_truncate>
if (rc != RC_OK)
54c46: 4fef 000c lea %sp@(12),%sp
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
54c4a: 2800 movel %d0,%d4
if (rc != RC_OK)
54c4c: 661c bnes 54c6a <msdos_file_ftruncate+0x88> <== NEVER TAKEN
/*
* fat_file_truncate do nothing if new length >= fat-file size, so update
* file size only if length < fat-file size
*/
if (length < fat_fd->fat_file_size)
54c4e: 2e2b 0018 movel %a3@(24),%d7
54c52: 4286 clrl %d6
54c54: 2002 movel %d2,%d0
54c56: 2203 movel %d3,%d1
54c58: 9287 subl %d7,%d1
54c5a: 9186 subxl %d6,%d0
54c5c: 6c0c bges 54c6a <msdos_file_ftruncate+0x88> <== NEVER TAKEN
iop->size = fat_fd->fat_file_size = length;
54c5e: 2743 0018 movel %d3,%a3@(24)
54c62: 2543 0008 movel %d3,%a2@(8)
54c66: 42aa 0004 clrl %a2@(4)
rtems_semaphore_release(fs_info->vol_sema);
54c6a: 2f2c 0088 movel %a4@(136),%sp@-
54c6e: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return RC_OK;
54c74: 588f addql #4,%sp
54c76: 6002 bras 54c7a <msdos_file_ftruncate+0x98>
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
if (length >= fat_fd->fat_file_size)
return RC_OK;
54c78: 4284 clrl %d4
if (length < fat_fd->fat_file_size)
iop->size = fat_fd->fat_file_size = length;
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
}
54c7a: 2004 movel %d4,%d0
54c7c: 4cee 1cfc ffdc moveml %fp@(-36),%d2-%d7/%a2-%a4
54c82: 4e5e unlk %fp <== NOT EXECUTED
00054da8 <msdos_file_ioctl>:
msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer)
{
int rc = RC_OK;
return rc;
}
54da8: 4280 clrl %d0 <== NOT EXECUTED
* RETURNS:
*
*/
int
msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer)
{
54daa: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
int rc = RC_OK;
return rc;
}
54dae: 4e5e unlk %fp <== NOT EXECUTED
00054a8c <msdos_file_lseek>:
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
54a8c: 4e56 ffec linkw %fp,#-20
54a90: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
54a94: 246e 0008 moveal %fp@(8),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54a98: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
54a9c: 266a 0018 moveal %a2@(24),%a3
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54aa0: 2868 0034 moveal %a0@(52),%a4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54aa4: 42a7 clrl %sp@-
54aa6: 42a7 clrl %sp@-
54aa8: 2f2c 0088 movel %a4@(136),%sp@-
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t real_size = 0;
54aac: 42ae fffc clrl %fp@(-4)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54ab0: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54ab6: 4fef 000c lea %sp@(12),%sp
54aba: 4a80 tstl %d0
54abc: 6712 beqs 54ad0 <msdos_file_lseek+0x44> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
54abe: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54ac4: 2040 moveal %d0,%a0 <== NOT EXECUTED
54ac6: 7005 moveq #5,%d0 <== NOT EXECUTED
54ac8: 2080 movel %d0,%a0@ <== NOT EXECUTED
54aca: 70ff moveq #-1,%d0 <== NOT EXECUTED
54acc: 72ff moveq #-1,%d1 <== NOT EXECUTED
54ace: 6064 bras 54b34 <msdos_file_lseek+0xa8> <== NOT EXECUTED
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
54ad0: 486e fffc pea %fp@(-4)
54ad4: 2f2a 0010 movel %a2@(16),%sp@-
54ad8: 2f0b movel %a3,%sp@-
54ada: 2f2a 0028 movel %a2@(40),%sp@-
54ade: 4eb9 0004 ff24 jsr 4ff24 <fat_file_extend>
&real_size);
if (rc != RC_OK)
54ae4: 4fef 0010 lea %sp@(16),%sp
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
54ae8: 2400 movel %d0,%d2
&real_size);
if (rc != RC_OK)
54aea: 6712 beqs 54afe <msdos_file_lseek+0x72> <== ALWAYS TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
54aec: 2f2c 0088 movel %a4@(136),%sp@- <== NOT EXECUTED
54af0: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
54af6: 2202 movel %d2,%d1 <== NOT EXECUTED
54af8: 5bc0 smi %d0 <== NOT EXECUTED
54afa: 49c0 extbl %d0 <== NOT EXECUTED
54afc: 6034 bras 54b32 <msdos_file_lseek+0xa6> <== NOT EXECUTED
}
if (real_size > fat_fd->fat_file_size)
54afe: 202e fffc movel %fp@(-4),%d0
54b02: b0ab 0018 cmpl %a3@(24),%d0
54b06: 630c blss 54b14 <msdos_file_lseek+0x88> <== ALWAYS TAKEN
fat_fd->fat_file_size = iop->offset = real_size;
54b08: 2540 0010 movel %d0,%a2@(16) <== NOT EXECUTED
54b0c: 42aa 000c clrl %a2@(12) <== NOT EXECUTED
54b10: 2740 0018 movel %d0,%a3@(24) <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
54b14: 202b 0018 movel %a3@(24),%d0
54b18: 42aa 0004 clrl %a2@(4)
54b1c: 2540 0008 movel %d0,%a2@(8)
rtems_semaphore_release(fs_info->vol_sema);
54b20: 2f2c 0088 movel %a4@(136),%sp@-
54b24: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return iop->offset;
54b2a: 202a 000c movel %a2@(12),%d0
54b2e: 222a 0010 movel %a2@(16),%d1
54b32: 588f addql #4,%sp
}
54b34: 4cee 1c04 ffec moveml %fp@(-20),%d2/%a2-%a4
54b3a: 4e5e unlk %fp <== NOT EXECUTED
0005481c <msdos_file_open>:
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
5481c: 4e56 fff0 linkw %fp,#-16
54820: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
54824: 246e 0008 moveal %fp@(8),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54828: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
5482c: 286a 0018 moveal %a2@(24),%a4
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54830: 2668 0034 moveal %a0@(52),%a3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54834: 42a7 clrl %sp@-
54836: 42a7 clrl %sp@-
54838: 2f2b 0088 movel %a3@(136),%sp@-
5483c: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54842: 4fef 000c lea %sp@(12),%sp
54846: 4a80 tstl %d0
54848: 6710 beqs 5485a <msdos_file_open+0x3e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
5484a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54850: 74ff moveq #-1,%d2 <== NOT EXECUTED
54852: 2040 moveal %d0,%a0 <== NOT EXECUTED
54854: 7005 moveq #5,%d0 <== NOT EXECUTED
54856: 2080 movel %d0,%a0@ <== NOT EXECUTED
54858: 603c bras 54896 <msdos_file_open+0x7a> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
5485a: 2f0c movel %a4,%sp@-
5485c: 4eb9 0004 fb54 jsr 4fb54 <fat_file_reopen>
if (rc != RC_OK)
54862: 588f addql #4,%sp
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_reopen(fat_fd);
54864: 2400 movel %d0,%d2
if (rc != RC_OK)
54866: 6622 bnes 5488a <msdos_file_open+0x6e> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
54868: 222a 0014 movel %a2@(20),%d1
5486c: 0281 0000 0200 andil #512,%d1
54872: 202c 0018 movel %a4@(24),%d0
54876: 4a81 tstl %d1
54878: 6708 beqs 54882 <msdos_file_open+0x66>
iop->offset = fat_fd->fat_file_size;
5487a: 2540 0010 movel %d0,%a2@(16)
5487e: 42aa 000c clrl %a2@(12)
iop->size = fat_fd->fat_file_size;
54882: 2540 0008 movel %d0,%a2@(8)
54886: 42aa 0004 clrl %a2@(4)
rtems_semaphore_release(fs_info->vol_sema);
5488a: 2f2b 0088 movel %a3@(136),%sp@-
5488e: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return RC_OK;
54894: 588f addql #4,%sp
}
54896: 2002 movel %d2,%d0
54898: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
5489e: 4e5e unlk %fp <== NOT EXECUTED
0005495c <msdos_file_read>:
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
5495c: 4e56 fff4 linkw %fp,#-12
54960: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
54964: 246e 0008 moveal %fp@(8),%a2
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54968: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
5496c: 242a 0018 movel %a2@(24),%d2
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54970: 2668 0034 moveal %a0@(52),%a3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54974: 42a7 clrl %sp@-
54976: 42a7 clrl %sp@-
54978: 2f2b 0088 movel %a3@(136),%sp@-
5497c: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54982: 4fef 000c lea %sp@(12),%sp
54986: 4a80 tstl %d0
54988: 6712 beqs 5499c <msdos_file_read+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
5498a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54990: 7405 moveq #5,%d2 <== NOT EXECUTED
54992: 2040 moveal %d0,%a0 <== NOT EXECUTED
54994: 347c ffff moveaw #-1,%a2 <== NOT EXECUTED
54998: 2082 movel %d2,%a0@ <== NOT EXECUTED
5499a: 6028 bras 549c4 <msdos_file_read+0x68> <== NOT EXECUTED
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
5499c: 2f2e 000c movel %fp@(12),%sp@-
549a0: 2f2e 0010 movel %fp@(16),%sp@-
549a4: 2f2a 0010 movel %a2@(16),%sp@-
549a8: 2f02 movel %d2,%sp@-
549aa: 2f2a 0028 movel %a2@(40),%sp@-
549ae: 4eb9 0004 fb66 jsr 4fb66 <fat_file_read>
buffer);
rtems_semaphore_release(fs_info->vol_sema);
549b4: 2f2b 0088 movel %a3@(136),%sp@-
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
549b8: 2440 moveal %d0,%a2
buffer);
rtems_semaphore_release(fs_info->vol_sema);
549ba: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return ret;
549c0: 4fef 0018 lea %sp@(24),%sp
}
549c4: 200a movel %a2,%d0
549c6: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
549cc: 4e5e unlk %fp <== NOT EXECUTED
00054dbc <msdos_file_rmnod>:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
54dbc: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
54dc0: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ <== NOT EXECUTED
54dc4: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
54dc8: 206a 0010 moveal %a2@(16),%a0 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
54dcc: 2852 moveal %a2@,%a4 <== NOT EXECUTED
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
54dce: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54dd2: 42a7 clrl %sp@- <== NOT EXECUTED
54dd4: 42a7 clrl %sp@- <== NOT EXECUTED
54dd6: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54dda: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54de0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
54de4: 4a80 tstl %d0 <== NOT EXECUTED
54de6: 6710 beqs 54df8 <msdos_file_rmnod+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
54de8: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54dee: 74ff moveq #-1,%d2 <== NOT EXECUTED
54df0: 7205 moveq #5,%d1 <== NOT EXECUTED
54df2: 2040 moveal %d0,%a0 <== NOT EXECUTED
54df4: 2081 movel %d1,%a0@ <== NOT EXECUTED
54df6: 6042 bras 54e3a <msdos_file_rmnod+0x7e> <== NOT EXECUTED
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry,
54df8: 4878 00e5 pea e5 <DBL_MANT_DIG+0xb0> <== NOT EXECUTED
54dfc: 486c 0020 pea %a4@(32) <== NOT EXECUTED
54e00: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
54e04: 4eb9 0005 5416 jsr 55416 <msdos_set_first_char4file_name> <== NOT EXECUTED
&fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
54e0a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry,
54e0e: 2400 movel %d0,%d2 <== NOT EXECUTED
&fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
54e10: 670e beqs 54e20 <msdos_file_rmnod+0x64> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
54e12: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54e16: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
54e1c: 588f addql #4,%sp <== NOT EXECUTED
54e1e: 601a bras 54e3a <msdos_file_rmnod+0x7e> <== NOT EXECUTED
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
54e20: 2f0c movel %a4,%sp@- <== NOT EXECUTED
54e22: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
54e26: 4eb9 0005 026a jsr 5026a <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
54e2c: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54e30: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
54e36: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
54e3a: 2002 movel %d2,%d0 <== NOT EXECUTED
54e3c: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 <== NOT EXECUTED
54e42: 4e5e unlk %fp <== NOT EXECUTED
...
00054b3e <msdos_file_stat>:
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
54b3e: 4e56 fff4 linkw %fp,#-12
54b42: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
54b46: 2268 0010 moveal %a0@(16),%a1
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
54b4a: 48d7 1c00 moveml %a2-%a4,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
54b4e: 2669 0034 moveal %a1@(52),%a3
fat_file_fd_t *fat_fd = loc->node_access;
54b52: 2850 moveal %a0@,%a4
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54b54: 42a7 clrl %sp@-
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
54b56: 246e 000c moveal %fp@(12),%a2
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54b5a: 42a7 clrl %sp@-
54b5c: 2f2b 0088 movel %a3@(136),%sp@-
54b60: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54b66: 4fef 000c lea %sp@(12),%sp
54b6a: 4a80 tstl %d0
54b6c: 6710 beqs 54b7e <msdos_file_stat+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
54b6e: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54b74: 7205 moveq #5,%d1 <== NOT EXECUTED
54b76: 2040 moveal %d0,%a0 <== NOT EXECUTED
54b78: 70ff moveq #-1,%d0 <== NOT EXECUTED
54b7a: 2081 movel %d1,%a0@ <== NOT EXECUTED
54b7c: 605a bras 54bd8 <msdos_file_stat+0x9a> <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
54b7e: 202b 004a movel %a3@(74),%d0
54b82: 222b 004e movel %a3@(78),%d1
buf->st_ino = fat_fd->ino;
54b86: 256c 000c 0008 movel %a4@(12),%a2@(8)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
54b8c: 2480 movel %d0,%a2@
54b8e: 2541 0004 movel %d1,%a2@(4)
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
54b92: 223c 0000 81ff movel #33279,%d1
54b98: 2541 000c movel %d1,%a2@(12)
buf->st_rdev = 0ll;
54b9c: 4280 clrl %d0
54b9e: 4281 clrl %d1
54ba0: 2540 0016 movel %d0,%a2@(22)
54ba4: 2541 001a movel %d1,%a2@(26)
buf->st_size = fat_fd->fat_file_size;
54ba8: 202c 0018 movel %a4@(24),%d0
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
54bac: 7209 moveq #9,%d1
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
54bae: 2540 0022 movel %d0,%a2@(34)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
54bb2: e2a8 lsrl %d1,%d0
54bb4: 2540 0042 movel %d0,%a2@(66)
buf->st_blksize = fs_info->fat.vol.bps;
54bb8: 4280 clrl %d0
54bba: 3013 movew %a3@,%d0
buf->st_mtime = fat_fd->mtime;
54bbc: 256c 003e 002e movel %a4@(62),%a2@(46)
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
54bc2: 42aa 001e clrl %a2@(30)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
54bc6: 2540 003e movel %d0,%a2@(62)
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
54bca: 2f2b 0088 movel %a3@(136),%sp@-
54bce: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return RC_OK;
54bd4: 588f addql #4,%sp
54bd6: 4280 clrl %d0
}
54bd8: 4cee 1c00 fff4 moveml %fp@(-12),%a2-%a4
54bde: 4e5e unlk %fp <== NOT EXECUTED
00054c86 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
54c86: 4e56 ffec linkw %fp,#-20 <== NOT EXECUTED
54c8a: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ <== NOT EXECUTED
54c8e: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54c92: 206b 0028 moveal %a3@(40),%a0 <== NOT EXECUTED
int
msdos_file_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
54c96: 286b 0018 moveal %a3@(24),%a4 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
54c9a: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54c9e: 42a7 clrl %sp@- <== NOT EXECUTED
54ca0: 42a7 clrl %sp@- <== NOT EXECUTED
54ca2: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
54ca6: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54cac: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
54cb0: 4a80 tstl %d0 <== NOT EXECUTED
54cb2: 6710 beqs 54cc4 <msdos_file_sync+0x3e> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
54cb4: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54cba: 7605 moveq #5,%d3 <== NOT EXECUTED
54cbc: 74ff moveq #-1,%d2 <== NOT EXECUTED
54cbe: 2040 moveal %d0,%a0 <== NOT EXECUTED
54cc0: 2083 movel %d3,%a0@ <== NOT EXECUTED
54cc2: 6060 bras 54d24 <msdos_file_sync+0x9e> <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
54cc4: 2f0c movel %a4,%sp@- <== NOT EXECUTED
54cc6: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
54cca: 4eb9 0005 02c8 jsr 502c8 <fat_file_datasync> <== NOT EXECUTED
if (rc != RC_OK)
54cd0: 508f addql #8,%sp <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
54cd2: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
54cd4: 6642 bnes 54d18 <msdos_file_sync+0x92> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
54cd6: 4280 clrl %d0 <== NOT EXECUTED
54cd8: 102c 0030 moveb %a4@(48),%d0 <== NOT EXECUTED
54cdc: 0800 0000 btst #0,%d0 <== NOT EXECUTED
54ce0: 6636 bnes 54d18 <msdos_file_sync+0x92> <== NOT EXECUTED
54ce2: 604c bras 54d30 <msdos_file_sync+0xaa> <== NOT EXECUTED
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
54ce4: 2f0c movel %a4,%sp@- <== NOT EXECUTED
54ce6: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
54cea: 4eb9 0005 53a6 jsr 553a6 <msdos_set_file_size> <== NOT EXECUTED
if (rc != RC_OK)
54cf0: 508f addql #8,%sp <== NOT EXECUTED
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
54cf2: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
54cf4: 6612 bnes 54d08 <msdos_file_sync+0x82> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
54cf6: 2f0c movel %a4,%sp@- <== NOT EXECUTED
54cf8: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
54cfc: 4eb9 0005 521a jsr 5521a <msdos_set_dir_wrt_time_and_date> <== NOT EXECUTED
if (rc != RC_OK)
54d02: 508f addql #8,%sp <== NOT EXECUTED
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
54d04: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
54d06: 6710 beqs 54d18 <msdos_file_sync+0x92> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
54d08: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
return rc;
54d0c: 2403 movel %d3,%d2 <== NOT EXECUTED
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
54d0e: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
54d14: 588f addql #4,%sp <== NOT EXECUTED
54d16: 600c bras 54d24 <msdos_file_sync+0x9e> <== NOT EXECUTED
}
}
rtems_semaphore_release(fs_info->vol_sema);
54d18: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
54d1c: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
54d22: 588f addql #4,%sp <== NOT EXECUTED
}
54d24: 2002 movel %d2,%d0 <== NOT EXECUTED
54d26: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4 <== NOT EXECUTED
54d2c: 4e5e unlk %fp <== NOT EXECUTED
54d2e: 4e75 rts <== NOT EXECUTED
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
54d30: 2f0c movel %a4,%sp@- <== NOT EXECUTED
54d32: 2f2b 0028 movel %a3@(40),%sp@- <== NOT EXECUTED
54d36: 4eb9 0005 52f4 jsr 552f4 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
54d3c: 508f addql #8,%sp <== NOT EXECUTED
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
54d3e: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc != RC_OK)
54d40: 67a2 beqs 54ce4 <msdos_file_sync+0x5e> <== NOT EXECUTED
54d42: 60c4 bras 54d08 <msdos_file_sync+0x82> <== NOT EXECUTED
000549d0 <msdos_file_write>:
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
549d0: 4e56 ffd8 linkw %fp,#-40
549d4: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
549d8: 246e 0008 moveal %fp@(8),%a2
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
549dc: 206a 0028 moveal %a2@(40),%a0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
549e0: 266a 0018 moveal %a2@(24),%a3
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
549e4: 2868 0034 moveal %a0@(52),%a4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
549e8: 42a7 clrl %sp@-
549ea: 42a7 clrl %sp@-
549ec: 2f2c 0088 movel %a4@(136),%sp@-
549f0: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
549f6: 4fef 000c lea %sp@(12),%sp
549fa: 4a80 tstl %d0
549fc: 670e beqs 54a0c <msdos_file_write+0x3c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
549fe: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54a04: 7605 moveq #5,%d3 <== NOT EXECUTED
54a06: 2040 moveal %d0,%a0 <== NOT EXECUTED
54a08: 2083 movel %d3,%a0@ <== NOT EXECUTED
54a0a: 602c bras 54a38 <msdos_file_write+0x68> <== NOT EXECUTED
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
54a0c: 2f2e 000c movel %fp@(12),%sp@-
54a10: 2f2e 0010 movel %fp@(16),%sp@-
54a14: 2f2a 0010 movel %a2@(16),%sp@-
54a18: 2f0b movel %a3,%sp@-
54a1a: 2f2a 0028 movel %a2@(40),%sp@-
54a1e: 4eb9 0005 00b2 jsr 500b2 <fat_file_write>
buffer);
if (ret < 0)
54a24: 4fef 0014 lea %sp@(20),%sp
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
54a28: 2400 movel %d0,%d2
buffer);
if (ret < 0)
54a2a: 6c10 bges 54a3c <msdos_file_write+0x6c> <== ALWAYS TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
54a2c: 2f2c 0088 movel %a4@(136),%sp@- <== NOT EXECUTED
54a30: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return -1;
54a36: 588f addql #4,%sp <== NOT EXECUTED
54a38: 74ff moveq #-1,%d2 <== NOT EXECUTED
54a3a: 6044 bras 54a80 <msdos_file_write+0xb0> <== NOT EXECUTED
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
if (iop->offset + ret > fat_fd->fat_file_size)
54a3c: 2a2b 0018 movel %a3@(24),%d5
54a40: 4284 clrl %d4
54a42: 206a 000c moveal %a2@(12),%a0
54a46: 226a 0010 moveal %a2@(16),%a1
54a4a: 2200 movel %d0,%d1
54a4c: 5bc0 smi %d0
54a4e: 49c0 extbl %d0
54a50: 2608 movel %a0,%d3
54a52: d289 addl %a1,%d1
54a54: d183 addxl %d3,%d0
54a56: 2c00 movel %d0,%d6
54a58: 2e01 movel %d1,%d7
54a5a: 9e85 subl %d5,%d7
54a5c: 9d84 subxl %d4,%d6
54a5e: 6f08 bles 54a68 <msdos_file_write+0x98>
fat_fd->fat_file_size = iop->offset + ret;
54a60: 4bf1 2800 lea %a1@(00000000,%d2:l),%a5
54a64: 274d 0018 movel %a5,%a3@(24)
iop->size = fat_fd->fat_file_size;
54a68: 202b 0018 movel %a3@(24),%d0
54a6c: 42aa 0004 clrl %a2@(4)
54a70: 2540 0008 movel %d0,%a2@(8)
rtems_semaphore_release(fs_info->vol_sema);
54a74: 2f2c 0088 movel %a4@(136),%sp@-
54a78: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return ret;
54a7e: 588f addql #4,%sp
}
54a80: 2002 movel %d2,%d0
54a82: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5
54a88: 4e5e unlk %fp <== NOT EXECUTED
000574f6 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
574f6: 4281 clrl %d1
* Convert a unix filename to a DOS filename. Return -1 if wrong name is
* supplied.
*/
int
msdos_filename_unix2dos(const char *un, int unlen, char *dn)
{
574f8: 4e56 ffe8 linkw %fp,#-24
574fc: 206e 0010 moveal %fp@(16),%a0
57500: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
57504: 226e 0008 moveal %fp@(8),%a1
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
57508: 2448 moveal %a0,%a2
* Convert a unix filename to a DOS filename. Return -1 if wrong name is
* supplied.
*/
int
msdos_filename_unix2dos(const char *un, int unlen, char *dn)
{
5750a: 2648 moveal %a0,%a3
5750c: 202e 000c movel %fp@(12),%d0
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
57510: 5281 addql #1,%d1
57512: 740b moveq #11,%d2
dn[i] = ' ';
57514: 16fc 0020 moveb #32,%a3@+
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
57518: b481 cmpl %d1,%d2
5751a: 66f4 bnes 57510 <msdos_filename_unix2dos+0x1a>
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
5751c: 762e moveq #46,%d3
5751e: 1211 moveb %a1@,%d1
57520: 49c1 extbl %d1
57522: b681 cmpl %d1,%d3
57524: 661a bnes 57540 <msdos_filename_unix2dos+0x4a> <== ALWAYS TAKEN
57526: 7801 moveq #1,%d4 <== NOT EXECUTED
57528: b880 cmpl %d0,%d4 <== NOT EXECUTED
5752a: 6608 bnes 57534 <msdos_filename_unix2dos+0x3e> <== NOT EXECUTED
dn[0] = '.';
5752c: 10bc 002e moveb #46,%a0@ <== NOT EXECUTED
return 0;
57530: 6000 00be braw 575f0 <msdos_filename_unix2dos+0xfa> <== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
57534: 742e moveq #46,%d2 <== NOT EXECUTED
57536: 1229 0001 moveb %a1@(1),%d1 <== NOT EXECUTED
5753a: 49c1 extbl %d1 <== NOT EXECUTED
5753c: b481 cmpl %d1,%d2 <== NOT EXECUTED
5753e: 6704 beqs 57544 <msdos_filename_unix2dos+0x4e> <== NOT EXECUTED
57540: 2209 movel %a1,%d1
57542: 6016 bras 5755a <msdos_filename_unix2dos+0x64>
57544: 7602 moveq #2,%d3 <== NOT EXECUTED
57546: b680 cmpl %d0,%d3 <== NOT EXECUTED
57548: 66f6 bnes 57540 <msdos_filename_unix2dos+0x4a> <== NOT EXECUTED
dn[0] = '.';
dn[1] = '.';
5754a: 782e moveq #46,%d4 <== NOT EXECUTED
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
dn[0] = '.';
5754c: 10bc 002e moveb #46,%a0@ <== NOT EXECUTED
dn[1] = '.';
57550: 1144 0001 moveb %d4,%a0@(1) <== NOT EXECUTED
return 0;
57554: 6000 009a braw 575f0 <msdos_filename_unix2dos+0xfa> <== NOT EXECUTED
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
un++;
unlen--;
57558: 5380 subql #1,%d0 <== NOT EXECUTED
5755a: 2241 moveal %d1,%a1
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
5755c: 4a80 tstl %d0
5755e: 660a bnes 5756a <msdos_filename_unix2dos+0x74> <== ALWAYS TAKEN
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
57560: 4282 clrl %d2
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
57562: 47f9 0006 7c82 lea 67c82 <msdos_map>,%a3
57568: 6022 bras 5758c <msdos_filename_unix2dos+0x96>
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
5756a: 5281 addql #1,%d1
5756c: 762e moveq #46,%d3
5756e: 1411 moveb %a1@,%d2
57570: 49c2 extbl %d2
57572: b682 cmpl %d2,%d3
57574: 67e2 beqs 57558 <msdos_filename_unix2dos+0x62> <== NEVER TAKEN
57576: 60e8 bras 57560 <msdos_filename_unix2dos+0x6a>
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
57578: 1633 3800 moveb %a3@(00000000,%d3:l),%d3
5757c: 673a beqs 575b8 <msdos_filename_unix2dos+0xc2> <== NEVER TAKEN
break;
dn[i] = msdos_map[c];
un++;
5757e: 2209 movel %a1,%d1
unlen--;
57580: 5380 subql #1,%d0
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
57582: 5282 addql #1,%d2
57584: 7808 moveq #8,%d4
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
57586: 14c3 moveb %d3,%a2@+
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
57588: b882 cmpl %d2,%d4
5758a: 672c beqs 575b8 <msdos_filename_unix2dos+0xc2>
5758c: 2209 movel %a1,%d1
5758e: 4a80 tstl %d0
57590: 6726 beqs 575b8 <msdos_filename_unix2dos+0xc2>
57592: 2841 moveal %d1,%a4
57594: 5289 addql #1,%a1
57596: 1614 moveb %a4@,%d3
57598: 671e beqs 575b8 <msdos_filename_unix2dos+0xc2> <== NEVER TAKEN
5759a: 782e moveq #46,%d4
5759c: 0283 0000 00ff andil #255,%d3
575a2: b883 cmpl %d3,%d4
575a4: 66d2 bnes 57578 <msdos_filename_unix2dos+0x82> <== ALWAYS TAKEN
575a6: 6010 bras 575b8 <msdos_filename_unix2dos+0xc2> <== NOT EXECUTED
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
575a8: 2241 moveal %d1,%a1
unlen--;
575aa: 5380 subql #1,%d0
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
575ac: 762e moveq #46,%d3
575ae: 0282 0000 00ff andil #255,%d2
575b4: b682 cmpl %d2,%d3
575b6: 670c beqs 575c4 <msdos_filename_unix2dos+0xce> <== NEVER TAKEN
575b8: 2241 moveal %d1,%a1
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
575ba: 4a80 tstl %d0
575bc: 6706 beqs 575c4 <msdos_filename_unix2dos+0xce>
575be: 5281 addql #1,%d1
575c0: 1411 moveb %a1@,%d2
575c2: 66e4 bnes 575a8 <msdos_filename_unix2dos+0xb2> <== ALWAYS TAKEN
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
575c4: 7208 moveq #8,%d1
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
if (msdos_map[c] == 0)
575c6: 45f9 0006 7c82 lea 67c82 <msdos_map>,%a2
575cc: 601a bras 575e8 <msdos_filename_unix2dos+0xf2>
575ce: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
575d4: 1432 2800 moveb %a2@(00000000,%d2:l),%d2 <== NOT EXECUTED
575d8: 6716 beqs 575f0 <msdos_filename_unix2dos+0xfa> <== NOT EXECUTED
break;
dn[i] = msdos_map[c];
un++;
unlen--;
575da: 5380 subql #1,%d0 <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
575dc: 780b moveq #11,%d4 <== NOT EXECUTED
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
575de: 1182 1800 moveb %d2,%a0@(00000000,%d1:l) <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
575e2: 5281 addql #1,%d1 <== NOT EXECUTED
575e4: b881 cmpl %d1,%d4 <== NOT EXECUTED
575e6: 6708 beqs 575f0 <msdos_filename_unix2dos+0xfa> <== NOT EXECUTED
575e8: 4a80 tstl %d0
575ea: 6704 beqs 575f0 <msdos_filename_unix2dos+0xfa> <== ALWAYS TAKEN
575ec: 1419 moveb %a1@+,%d2 <== NOT EXECUTED
575ee: 66de bnes 575ce <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
575f0: 4280 clrl %d0
575f2: 4cd7 1c1c moveml %sp@,%d2-%d4/%a2-%a4
575f6: 4e5e unlk %fp
...
0005625e <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
5625e: 4e56 ffb4 linkw %fp,#-76
56262: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
56266: 266e 0008 moveal %fp@(8),%a3
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
5626a: 45ee ffcc lea %fp@(-52),%a2
/*
* find the node which correspondes to the name in the directory pointed by
* 'parent_loc'
*/
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
5626e: 260e movel %fp,%d3
56270: 0683 ffff ffec addil #-20,%d3
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
56276: 206b 0010 moveal %a3@(16),%a0
5627a: 2a68 0034 moveal %a0@(52),%a5
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
5627e: 4878 0020 pea 20 <OPER2+0xc>
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
56282: 242e 000c movel %fp@(12),%d2
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56286: 42a7 clrl %sp@-
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
56288: 286e 0010 moveal %fp@(16),%a4
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
5628c: 2f0a movel %a2,%sp@-
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
5628e: 42ae fffc clrl %fp@(-4)
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
56292: 4eb9 0005 8848 jsr 58848 <memset>
name_type = msdos_long_to_short (name,
56298: 4878 000b pea b <LASTO+0x1>
5629c: 2f0a movel %a2,%sp@-
5629e: 2f0c movel %a4,%sp@-
562a0: 2f02 movel %d2,%sp@-
562a2: 4eb9 0005 4fe8 jsr 54fe8 <msdos_long_to_short>
/*
* find the node which correspondes to the name in the directory pointed by
* 'parent_loc'
*/
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
562a8: 2f0a movel %a2,%sp@-
562aa: 2f03 movel %d3,%sp@-
562ac: 2f00 movel %d0,%sp@-
562ae: 2f0c movel %a4,%sp@-
562b0: 2f02 movel %d2,%sp@-
562b2: 42a7 clrl %sp@-
562b4: 2f0b movel %a3,%sp@-
562b6: 4eb9 0005 617a jsr 5617a <msdos_get_name_node>
&dir_pos, node_entry);
if (rc != RC_OK)
562bc: 4fef 0038 lea %sp@(56),%sp
/*
* find the node which correspondes to the name in the directory pointed by
* 'parent_loc'
*/
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
562c0: 2400 movel %d0,%d2
&dir_pos, node_entry);
if (rc != RC_OK)
562c2: 6600 0166 bnew 5642a <msdos_find_name+0x1cc>
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
562c6: 4280 clrl %d0
562c8: 102a 000b moveb %a2@(11),%d0
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
562cc: 343c 7d01 movew #32001,%d2
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
&dir_pos, node_entry);
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
562d0: 44c0 movew %d0,%ccr
562d2: 6b00 0156 bmiw 5642a <msdos_find_name+0x1cc>
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
562d6: 723f moveq #63,%d1
562d8: c081 andl %d1,%d0
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
&dir_pos, node_entry);
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
562da: 123c 000f moveb #15,%d1
562de: b280 cmpl %d0,%d1
562e0: 6700 0148 beqw 5642a <msdos_find_name+0x1cc>
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
562e4: 486e fffc pea %fp@(-4)
562e8: 2f03 movel %d3,%sp@-
562ea: 2f2b 0010 movel %a3@(16),%sp@-
562ee: 4eb9 0004 fa28 jsr 4fa28 <fat_file_open>
if (rc != RC_OK)
562f4: 4fef 000c lea %sp@(12),%sp
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
562f8: 2400 movel %d0,%d2
if (rc != RC_OK)
562fa: 6600 012e bnew 5642a <msdos_find_name+0x1cc>
return rc;
fat_fd->dir_pos = dir_pos;
562fe: 4878 0010 pea 10 <INVALID_OPERATION>
56302: 286e fffc moveal %fp@(-4),%a4
56306: 2f03 movel %d3,%sp@-
56308: 486c 0020 pea %a4@(32)
5630c: 4eb9 0005 87d8 jsr 587d8 <memcpy>
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
56312: 4fef 000c lea %sp@(12),%sp
56316: 7001 moveq #1,%d0
56318: b0ac 0008 cmpl %a4@(8),%d0
5631c: 6600 00e6 bnew 56404 <msdos_find_name+0x1a6>
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
56320: 4281 clrl %d1
56322: 4282 clrl %d2
56324: 322a 0014 movew %a2@(20),%d1
56328: 342a 001a movew %a2@(26),%d2
5632c: 2001 movel %d1,%d0
5632e: e089 lsrl #8,%d1
56330: e188 lsll #8,%d0
56332: 8081 orl %d1,%d0
56334: 2202 movel %d2,%d1
56336: e08a lsrl #8,%d2
56338: e189 lsll #8,%d1
5633a: 4840 swap %d0
5633c: 4240 clrw %d0
5633e: 8282 orl %d2,%d1
56340: 0281 0000 ffff andil #65535,%d1
56346: 8081 orl %d1,%d0
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
56348: 4281 clrl %d1
5634a: 322a 0016 movew %a2@(22),%d1
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
5634e: 2940 001c movel %d0,%a4@(28)
56352: 2001 movel %d1,%d0
56354: e089 lsrl #8,%d1
56356: e188 lsll #8,%d0
56358: 8081 orl %d1,%d0
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
5635a: 4281 clrl %d1
5635c: 3f00 movew %d0,%sp@-
5635e: 4267 clrw %sp@-
56360: 322a 0018 movew %a2@(24),%d1
56364: 2001 movel %d1,%d0
56366: e089 lsrl #8,%d1
56368: e188 lsll #8,%d0
5636a: 8081 orl %d1,%d0
5636c: 3f00 movew %d0,%sp@-
5636e: 4267 clrw %sp@-
56370: 4eb9 0005 7412 jsr 57412 <msdos_date_dos2unix>
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
56376: 508f addql #8,%sp
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
56378: 2940 003e movel %d0,%a4@(62)
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
5637c: 4280 clrl %d0
5637e: 102a 000b moveb %a2@(11),%d0
56382: 286e fffc moveal %fp@(-4),%a4
56386: 0800 0004 btst #4,%d0
5638a: 6730 beqs 563bc <msdos_find_name+0x15e>
{
fat_fd->fat_file_type = FAT_DIRECTORY;
5638c: 7201 moveq #1,%d1
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
5638e: 7020 moveq #32,%d0
56390: 4840 swap %d0
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
56392: 2941 0010 movel %d1,%a4@(16)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
56396: 2940 0014 movel %d0,%a4@(20)
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
5639a: 2f0c movel %a4,%sp@-
5639c: 2f2b 0010 movel %a3@(16),%sp@-
563a0: 4eb9 0005 03b6 jsr 503b6 <fat_file_size>
if (rc != RC_OK)
563a6: 508f addql #8,%sp
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
563a8: 2400 movel %d0,%d2
if (rc != RC_OK)
563aa: 672a beqs 563d6 <msdos_find_name+0x178> <== ALWAYS TAKEN
{
fat_file_close(parent_loc->mt_entry, fat_fd);
563ac: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
563b0: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
563b4: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
563ba: 6066 bras 56422 <msdos_find_name+0x1c4> <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
563bc: 2f2a 001c movel %a2@(28),%sp@-
563c0: 4eba eb4a jsr %pc@(54f0c <m68k_swap_u32>)
563c4: 588f addql #4,%sp
fat_fd->fat_file_type = FAT_FILE;
563c6: 7205 moveq #5,%d1
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
563c8: 2940 0018 movel %d0,%a4@(24)
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
563cc: 70ff moveq #-1,%d0
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
fat_fd->fat_file_type = FAT_FILE;
563ce: 2941 0010 movel %d1,%a4@(16)
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
563d2: 2940 0014 movel %d0,%a4@(20)
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
563d6: 206e fffc moveal %fp@(-4),%a0
fat_fd->map.disk_cln = fat_fd->cln;
563da: 2028 001c movel %a0@(28),%d0
if ((fat_fd->fat_file_size != 0) &&
563de: 2228 0018 movel %a0@(24),%d1
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
563e2: 42a8 0032 clrl %a0@(50)
fat_fd->map.disk_cln = fat_fd->cln;
563e6: 2140 0036 movel %d0,%a0@(54)
if ((fat_fd->fat_file_size != 0) &&
563ea: 4a81 tstl %d1
563ec: 6710 beqs 563fe <msdos_find_name+0x1a0>
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
563ee: 4282 clrl %d2
563f0: 342d 0006 movew %a5@(6),%d2
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
563f4: b481 cmpl %d1,%d2
563f6: 6506 bcss 563fe <msdos_find_name+0x1a0> <== NEVER TAKEN
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
{
fat_fd->map.last_cln = fat_fd->cln;
563f8: 2140 003a movel %d0,%a0@(58)
563fc: 6006 bras 56404 <msdos_find_name+0x1a6>
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
563fe: 72ff moveq #-1,%d1
56400: 2141 003a movel %d1,%a0@(58)
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
56404: 2f13 movel %a3@,%sp@-
56406: 45f9 0004 fdc6 lea 4fdc6 <fat_file_close>,%a2
5640c: 2f2b 0010 movel %a3@(16),%sp@-
56410: 4e92 jsr %a2@
if (rc != RC_OK)
56412: 508f addql #8,%sp
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
56414: 2400 movel %d0,%d2
if (rc != RC_OK)
56416: 670e beqs 56426 <msdos_find_name+0x1c8> <== ALWAYS TAKEN
{
fat_file_close(parent_loc->mt_entry, fat_fd);
56418: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
5641c: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
56420: 4e92 jsr %a2@ <== NOT EXECUTED
return rc;
56422: 508f addql #8,%sp <== NOT EXECUTED
56424: 6004 bras 5642a <msdos_find_name+0x1cc> <== NOT EXECUTED
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
56426: 26ae fffc movel %fp@(-4),%a3@
return rc;
}
5642a: 2002 movel %d2,%d0
5642c: 4cee 3c0c ffb4 moveml %fp@(-76),%d2-%d3/%a2-%a5
56432: 4e5e unlk %fp
...
00055636 <msdos_find_name_in_fat_file>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
55636: 4e56 ff94 linkw %fp,#-108
5563a: 122e 0013 moveb %fp@(19),%d1
5563e: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
55642: 2a6e 0008 moveal %fp@(8),%a5
55646: 246e 000c moveal %fp@(12),%a2
5564a: 266e 0020 moveal %fp@(32),%a3
5564e: 286e 0024 moveal %fp@(36),%a4
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55652: 282d 0034 movel %a5@(52),%d4
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
55656: 1d41 ffec moveb %d1,%fp@(-20)
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
5565a: 4aae 0018 tstl %fp@(24)
5565e: 6e14 bgts 55674 <msdos_find_name_in_fat_file+0x3e><== ALWAYS TAKEN
55660: 4879 0006 7c05 pea 67c05 <msdos_file_handlers+0xcf> <== NOT EXECUTED
55666: 4879 0006 7c3b pea 67c3b <__FUNCTION__.7091> <== NOT EXECUTED
5566c: 4878 0419 pea 419 <DBL_MAX_EXP+0x18> <== NOT EXECUTED
55670: 6000 00ae braw 55720 <msdos_find_name_in_fat_file+0xea><== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
55674: 74ff moveq #-1,%d2
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
55676: 4293 clrl %a3@
dir_pos->sname.ofs = 0;
55678: 42ab 0004 clrl %a3@(4)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
5567c: 2742 0008 movel %d2,%a3@(8)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
55680: 2742 000c movel %d2,%a3@(12)
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
55684: 2d42 fff8 movel %d2,%fp@(-8)
55688: 2d42 fff4 movel %d2,%fp@(-12)
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
5568c: 4a2e ffec tstb %fp@(-20)
55690: 6708 beqs 5569a <msdos_find_name_in_fat_file+0x64>
55692: 7601 moveq #1,%d3
55694: b6ae 001c cmpl %fp@(28),%d3
55698: 6712 beqs 556ac <msdos_find_name_in_fat_file+0x76>
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
5569a: 262e 0018 movel %fp@(24),%d3
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
5569e: 7c0d moveq #13,%d6
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
556a0: 0683 0000 000c addil #12,%d3
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
556a6: 4c46 3803 remsl %d6,%d3,%d3
556aa: 6002 bras 556ae <msdos_find_name_in_fat_file+0x78>
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
556ac: 4283 clrl %d3
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
556ae: 7e01 moveq #1,%d7
556b0: beaa 0020 cmpl %a2@(32),%d7
556b4: 661a bnes 556d0 <msdos_find_name_in_fat_file+0x9a>
556b6: 4aaa 0024 tstl %a2@(36)
556ba: 6614 bnes 556d0 <msdos_find_name_in_fat_file+0x9a><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
556bc: 2044 moveal %d4,%a0
556be: 4280 clrl %d0
556c0: 1028 000a moveb %a0@(10),%d0
556c4: 7203 moveq #3,%d1
556c6: c081 andl %d1,%d0
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
556c8: 6706 beqs 556d0 <msdos_find_name_in_fat_file+0x9a><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
556ca: 242a 0018 movel %a2@(24),%d2
556ce: 6008 bras 556d8 <msdos_find_name_in_fat_file+0xa2>
else
bts2rd = fs_info->fat.vol.bpc;
556d0: 2044 moveal %d4,%a0
556d2: 4282 clrl %d2
556d4: 3428 0006 movew %a0@(6),%d2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
556d8: 2043 moveal %d3,%a0
556da: 5288 addql #1,%a0
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
556dc: 4285 clrl %d5
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
556de: 4287 clrl %d7
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
556e0: 4201 clrb %d1
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
556e2: 4206 clrb %d6
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
556e4: 42ae ffe0 clrl %fp@(-32)
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
556e8: 1d41 ffce moveb %d1,%fp@(-50)
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
556ec: 42ae ffe4 clrl %fp@(-28)
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
556f0: 1d46 ffd2 moveb %d6,%fp@(-46)
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
556f4: 42ae ffe8 clrl %fp@(-24)
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
556f8: 42ae fff0 clrl %fp@(-16)
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
556fc: 2d48 ffc2 movel %a0,%fp@(-62)
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
55700: 6000 030e braw 55a10 <msdos_find_name_in_fat_file+0x3da>
bool remainder_empty = false;
#if MSDOS_FIND_PRINT
printf ("MSFS:[2] dir_offset:%li\n", dir_offset);
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
55704: 7c1f moveq #31,%d6
55706: bc80 cmpl %d0,%d6
55708: 6c00 0690 bgew 55d9a <msdos_find_name_in_fat_file+0x764>
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
5570c: b480 cmpl %d0,%d2
5570e: 671c beqs 5572c <msdos_find_name_in_fat_file+0xf6><== ALWAYS TAKEN
55710: 4879 0006 7c12 pea 67c12 <msdos_file_handlers+0xdc> <== NOT EXECUTED
55716: 4879 0006 7c3b pea 67c3b <__FUNCTION__.7091> <== NOT EXECUTED
5571c: 4878 0449 pea 449 <DBL_MAX_EXP+0x48> <== NOT EXECUTED
55720: 4879 0006 7ba3 pea 67ba3 <msdos_file_handlers+0x6d> <== NOT EXECUTED
55726: 4eb9 0005 20dc jsr 520dc <__assert_func> <== NOT EXECUTED
5572c: 4286 clrl %d6
5572e: 1d41 ffdb moveb %d1,%fp@(-37)
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
55732: 2044 moveal %d4,%a0
55734: 2268 008c moveal %a0@(140),%a1
55738: d3c6 addal %d6,%a1
/*
* See if the entry is empty or the remainder of the directory is
* empty ? Localise to make the code read better.
*/
bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
5573a: 1d51 ffdc moveb %a1@,%fp@(-36)
* to here and write the long file name if this is the start of
* a series of empty entries. If empty_space_count is 0 then
* we are currently not inside an empty series of entries. It
* is a count of empty entries.
*/
if (empty_space_count == 0)
5573e: 4a85 tstl %d5
55740: 660c bnes 5574e <msdos_find_name_in_fat_file+0x118><== NEVER TAKEN
55742: 222e fff0 movel %fp@(-16),%d1
55746: 2d46 ffe4 movel %d6,%fp@(-28)
5574a: 2d41 ffe8 movel %d1,%fp@(-24)
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
5574e: 4a2e ffdc tstb %fp@(-36)
55752: 6624 bnes 55778 <msdos_find_name_in_fat_file+0x142>
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
55754: 2e3c 0000 7d01 movel #32001,%d7
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
5575a: 4a2e ffec tstb %fp@(-20)
5575e: 6700 0664 beqw 55dc4 <msdos_find_name_in_fat_file+0x78e>
* Lets go and write the directory entries. If we have not found
* any available space add the remaining number of entries to any that
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
55762: 4a2e ffce tstb %fp@(-50)
55766: 6600 02de bnew 55a46 <msdos_find_name_in_fat_file+0x410>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
5576a: 2002 movel %d2,%d0
5576c: ea88 lsrl #5,%d0
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
5576e: da80 addl %d0,%d5
55770: ea8e lsrl #5,%d6
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
55772: 9a86 subl %d6,%d5
55774: 6000 02d0 braw 55a46 <msdos_find_name_in_fat_file+0x410>
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
55778: 4280 clrl %d0
5577a: 102e ffdc moveb %fp@(-36),%d0
5577e: 2040 moveal %d0,%a0
55780: b1fc 0000 00e5 cmpal #229,%a0
55786: 6616 bnes 5579e <msdos_find_name_in_fat_file+0x168><== ALWAYS TAKEN
{
if (create_node)
55788: 4a2e ffec tstb %fp@(-20) <== NOT EXECUTED
5578c: 6700 026a beqw 559f8 <msdos_find_name_in_fat_file+0x3c2><== NOT EXECUTED
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
55790: 5285 addql #1,%d5 <== NOT EXECUTED
if (empty_space_count == (lfn_entries + 1))
55792: baae ffc2 cmpl %fp@(-62),%d5 <== NOT EXECUTED
55796: 6600 0260 bnew 559f8 <msdos_find_name_in_fat_file+0x3c2><== NOT EXECUTED
5579a: 6000 0246 braw 559e2 <msdos_find_name_in_fat_file+0x3ac><== NOT EXECUTED
* A valid entry so handle it.
*
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
5579e: 4a2e ffec tstb %fp@(-20)
557a2: 670c beqs 557b0 <msdos_find_name_in_fat_file+0x17a>
557a4: 4a2e ffce tstb %fp@(-50)
557a8: 6606 bnes 557b0 <msdos_find_name_in_fat_file+0x17a><== NEVER TAKEN
{
empty_space_entry = 0;
empty_space_count = 0;
557aa: 4285 clrl %d5
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
{
empty_space_entry = 0;
557ac: 42ae ffe4 clrl %fp@(-28)
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
557b0: 4281 clrl %d1
557b2: 1229 000b moveb %a1@(11),%d1
557b6: 703f moveq #63,%d0
557b8: c280 andl %d0,%d1
557ba: 2041 moveal %d1,%a0
557bc: 720f moveq #15,%d1
557be: b288 cmpl %a0,%d1
557c0: 6600 0118 bnew 558da <msdos_find_name_in_fat_file+0x2a4>
#endif
/*
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
557c4: 70ff moveq #-1,%d0
557c6: b0ae fff4 cmpl %fp@(-12),%d0
557ca: 6636 bnes 55802 <msdos_find_name_in_fat_file+0x1cc>
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
557cc: 4280 clrl %d0
557ce: 102e ffdc moveb %fp@(-36),%d0
557d2: 0800 0006 btst #6,%d0
557d6: 6700 0212 beqw 559ea <msdos_find_name_in_fat_file+0x3b4>
* entry match the number we expect for this
* file name. Note we do not know the number of
* characters in the entry so this is check further
* on when the characters are checked.
*/
if (lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
557da: 123c 003f moveb #63,%d1
557de: c081 andl %d1,%d0
557e0: b083 cmpl %d3,%d0
557e2: 6600 020e bnew 559f2 <msdos_find_name_in_fat_file+0x3bc>
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
557e6: 2e2e fff0 movel %fp@(-16),%d7
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
557ea: 1229 000d moveb %a1@(13),%d1
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
557ee: 4200 clrb %d0
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
557f0: 2d47 fff4 movel %d7,%fp@(-12)
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
557f4: 2e03 movel %d3,%d7
557f6: 1d41 ffd2 moveb %d1,%fp@(-46)
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
lfn_start.ofs = dir_entry;
557fa: 2d46 fff8 movel %d6,%fp@(-8)
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
557fe: 1d40 ffdb moveb %d0,%fp@(-37)
* If the entry number or the check sum do not match
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
55802: 4280 clrl %d0
55804: 1011 moveb %a1@,%d0
55806: 723f moveq #63,%d1
55808: c081 andl %d1,%d0
5580a: b087 cmpl %d7,%d0
5580c: 6610 bnes 5581e <msdos_find_name_in_fat_file+0x1e8><== NEVER TAKEN
MSDOS_LAST_LONG_ENTRY_MASK)) ||
5580e: 4280 clrl %d0
55810: 102e ffd2 moveb %fp@(-46),%d0
55814: 2040 moveal %d0,%a0
55816: 1029 000d moveb %a1@(13),%d0
5581a: b088 cmpl %a0,%d0
5581c: 670a beqs 55828 <msdos_find_name_in_fat_file+0x1f2><== ALWAYS TAKEN
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
5581e: 72ff moveq #-1,%d1 <== NOT EXECUTED
55820: 2d41 fff4 movel %d1,%fp@(-12) <== NOT EXECUTED
continue;
55824: 6000 01d2 braw 559f8 <msdos_find_name_in_fat_file+0x3c2><== NOT EXECUTED
}
lfn_entry--;
55828: 2047 moveal %d7,%a0
5582a: 5388 subql #1,%a0
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
5582c: 2008 movel %a0,%d0
5582e: 720d moveq #13,%d1
55830: 4c01 0800 mulsl %d1,%d0
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
55834: 2d48 ffdc movel %a0,%fp@(-36)
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
55838: 91c8 subal %a0,%a0
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
5583a: 2d40 ffd6 movel %d0,%fp@(-42)
p = entry + 1;
5583e: 2009 movel %a1,%d0
55840: 5280 addql #1,%d0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55842: 226e 0014 moveal %fp@(20),%a1
55846: d3ee ffd6 addal %fp@(-42),%a1
5584a: 2d49 ffc6 movel %a1,%fp@(-58)
5584e: 2240 moveal %d0,%a1
55850: 2d4a ffca movel %a2,%fp@(-54)
{
#if MSDOS_FIND_PRINT > 1
printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
o, i, *p, *p, name[o + i], name[o + i]);
#endif
if (*p == '\0')
55854: 1011 moveb %a1@,%d0
55856: 6614 bnes 5586c <msdos_find_name_in_fat_file+0x236>
55858: 246e ffca moveal %fp@(-54),%a2
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
5585c: b687 cmpl %d7,%d3
5585e: 6658 bnes 558b8 <msdos_find_name_in_fat_file+0x282><== NEVER TAKEN
((o + i) != name_len))
55860: d1ee ffd6 addal %fp@(-42),%a0
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
55864: b1ee 0018 cmpal %fp@(24),%a0
55868: 6622 bnes 5588c <msdos_find_name_in_fat_file+0x256><== NEVER TAKEN
5586a: 604c bras 558b8 <msdos_find_name_in_fat_file+0x282>
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
5586c: 222e ffd6 movel %fp@(-42),%d1
55870: d288 addl %a0,%d1
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
55872: b2ae 0018 cmpl %fp@(24),%d1
55876: 6c10 bges 55888 <msdos_find_name_in_fat_file+0x252>
55878: 246e ffc6 moveal %fp@(-58),%a2
5587c: 49c0 extbl %d0
5587e: 1232 8800 moveb %a2@(00000000,%a0:l),%d1
55882: 49c1 extbl %d1
55884: b280 cmpl %d0,%d1
55886: 670c beqs 55894 <msdos_find_name_in_fat_file+0x25e>
55888: 246e ffca moveal %fp@(-54),%a2
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
5588c: 70ff moveq #-1,%d0
5588e: 2d40 fff4 movel %d0,%fp@(-12)
break;
55892: 6024 bras 558b8 <msdos_find_name_in_fat_file+0x282>
}
switch (i)
55894: 7204 moveq #4,%d1
55896: b288 cmpl %a0,%d1
55898: 6708 beqs 558a2 <msdos_find_name_in_fat_file+0x26c>
5589a: 700a moveq #10,%d0
5589c: b088 cmpl %a0,%d0
5589e: 660a bnes 558aa <msdos_find_name_in_fat_file+0x274>
558a0: 6004 bras 558a6 <msdos_find_name_in_fat_file+0x270>
{
case 4:
p += 5;
558a2: 5a89 addql #5,%a1
break;
558a4: 6006 bras 558ac <msdos_find_name_in_fat_file+0x276>
case 10:
p += 4;
558a6: 5889 addql #4,%a1
break;
558a8: 6002 bras 558ac <msdos_find_name_in_fat_file+0x276>
default:
p += 2;
558aa: 5489 addql #2,%a1
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
558ac: 5288 addql #1,%a0
558ae: 720d moveq #13,%d1
558b0: b288 cmpl %a0,%d1
558b2: 66a0 bnes 55854 <msdos_find_name_in_fat_file+0x21e>
558b4: 246e ffca moveal %fp@(-54),%a2
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
558b8: 4aae ffdc tstl %fp@(-36)
558bc: 660e bnes 558cc <msdos_find_name_in_fat_file+0x296>
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
558be: 7eff moveq #-1,%d7
558c0: beae fff4 cmpl %fp@(-12),%d7
558c4: 56c1 sne %d1
558c6: 49c1 extbl %d1
558c8: 4481 negl %d1
558ca: 6002 bras 558ce <msdos_find_name_in_fat_file+0x298>
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
558cc: 4281 clrl %d1
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
558ce: 2e2e ffdc movel %fp@(-36),%d7
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
558d2: 1d41 ffdb moveb %d1,%fp@(-37)
558d6: 6000 0120 braw 559f8 <msdos_find_name_in_fat_file+0x3c2>
* If a LFN has been found and it matched check the
* entries have all been found and the checksum is
* correct. If this is the case return the short file
* name entry.
*/
if (lfn_matched)
558da: 4a2e ffdb tstb %fp@(-37)
558de: 674a beqs 5592a <msdos_find_name_in_fat_file+0x2f4>
558e0: 2049 moveal %a1,%a0
558e2: 700b moveq #11,%d0
558e4: 4201 clrb %d1
558e6: 2d42 ffca movel %d2,%fp@(-54)
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
558ea: 0281 0000 00ff andil #255,%d1
558f0: 0801 0000 btst #0,%d1
558f4: 6704 beqs 558fa <msdos_find_name_in_fat_file+0x2c4>
558f6: 7480 moveq #-128,%d2
558f8: 6002 bras 558fc <msdos_find_name_in_fat_file+0x2c6>
558fa: 4202 clrb %d2
558fc: e289 lsrl #1,%d1
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
558fe: 5380 subql #1,%d0
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
55900: 1d42 ffdf moveb %d2,%fp@(-33)
55904: 1418 moveb %a0@+,%d2
55906: d282 addl %d2,%d1
55908: 142e ffdf moveb %fp@(-33),%d2
5590c: d282 addl %d2,%d1
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
5590e: 4a80 tstl %d0
55910: 66d8 bnes 558ea <msdos_find_name_in_fat_file+0x2b4>
55912: 242e ffca movel %fp@(-54),%d2
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
55916: 4a87 tstl %d7
55918: 6610 bnes 5592a <msdos_find_name_in_fat_file+0x2f4><== NEVER TAKEN
5591a: 4280 clrl %d0
5591c: 102e ffd2 moveb %fp@(-46),%d0
55920: 0281 0000 00ff andil #255,%d1
55926: b280 cmpl %d0,%d1
55928: 6732 beqs 5595c <msdos_find_name_in_fat_file+0x326><== ALWAYS TAKEN
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
5592a: 7001 moveq #1,%d0
5592c: b0ae 001c cmpl %fp@(28),%d0
55930: 6600 00a8 bnew 559da <msdos_find_name_in_fat_file+0x3a4>
((name_type == MSDOS_NAME_SHORT) &&
55934: 72ff moveq #-1,%d1
55936: b2ae fff4 cmpl %fp@(-12),%d1
5593a: 6600 009e bnew 559da <msdos_find_name_in_fat_file+0x3a4>
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
5593e: 4878 000b pea b <LASTO+0x1>
55942: 2f0c movel %a4,%sp@-
55944: 2d49 ffbe movel %a1,%fp@(-66)
55948: 2f09 movel %a1,%sp@-
5594a: 4eb9 0005 8750 jsr 58750 <memcmp>
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
55950: 226e ffbe moveal %fp@(-66),%a1
(memcmp(MSDOS_DIR_NAME(entry),
55954: 4fef 000c lea %sp@(12),%sp
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
55958: 4a80 tstl %d0
5595a: 667e bnes 559da <msdos_find_name_in_fat_file+0x3a4>
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
5595c: 2f0b movel %a3,%sp@-
5595e: 2f2e ffe0 movel %fp@(-32),%sp@-
55962: 4878 0001 pea 1 <ADD>
55966: 263c 0004 fe8c movel #327308,%d3
5596c: 2043 moveal %d3,%a0
5596e: 2f0a movel %a2,%sp@-
55970: 2d49 ffbe movel %a1,%fp@(-66)
55974: 2f0d movel %a5,%sp@-
55976: 4e90 jsr %a0@
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
55978: 226e ffbe moveal %fp@(-66),%a1
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
5597c: 2e00 movel %d0,%d7
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
5597e: 4fef 0014 lea %sp@(20),%sp
55982: 6600 0440 bnew 55dc4 <msdos_find_name_in_fat_file+0x78e>
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
55986: 202e fff4 movel %fp@(-12),%d0
5598a: 72ff moveq #-1,%d1
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
5598c: 2746 0004 movel %d6,%a3@(4)
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
55990: b280 cmpl %d0,%d1
55992: 6724 beqs 559b8 <msdos_find_name_in_fat_file+0x382>
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
55994: 486e fff4 pea %fp@(-12)
55998: 4c00 2800 mulsl %d0,%d2
5599c: 2043 moveal %d3,%a0
5599e: 2f02 movel %d2,%sp@-
559a0: 4878 0001 pea 1 <ADD>
559a4: 2f0a movel %a2,%sp@-
559a6: 2f0d movel %a5,%sp@-
559a8: 4e90 jsr %a0@
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
559aa: 226e ffbe moveal %fp@(-66),%a1
559ae: 4fef 0014 lea %sp@(20),%sp
559b2: 4a80 tstl %d0
559b4: 6600 0408 bnew 55dbe <msdos_find_name_in_fat_file+0x788>
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
559b8: 276e fff4 0008 movel %fp@(-12),%a3@(8)
dir_pos->lname.ofs = lfn_start.ofs;
559be: 276e fff8 000c movel %fp@(-8),%a3@(12)
memcpy(name_dir_entry, entry,
559c4: 4878 0020 pea 20 <OPER2+0xc>
559c8: 2f09 movel %a1,%sp@-
559ca: 2f0c movel %a4,%sp@-
559cc: 4eb9 0005 87d8 jsr 587d8 <memcpy>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
559d2: 4fef 000c lea %sp@(12),%sp
559d6: 6000 03ec braw 55dc4 <msdos_find_name_in_fat_file+0x78e>
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
559da: 70ff moveq #-1,%d0
559dc: 2d40 fff4 movel %d0,%fp@(-12)
559e0: 6010 bras 559f2 <msdos_find_name_in_fat_file+0x3bc>
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
559e2: 7201 moveq #1,%d1 <== NOT EXECUTED
559e4: 1d41 ffce moveb %d1,%fp@(-50) <== NOT EXECUTED
559e8: 600e bras 559f8 <msdos_find_name_in_fat_file+0x3c2><== NOT EXECUTED
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
559ea: 4200 clrb %d0
559ec: 1d40 ffdb moveb %d0,%fp@(-37)
559f0: 6006 bras 559f8 <msdos_find_name_in_fat_file+0x3c2>
559f2: 4201 clrb %d1
559f4: 1d41 ffdb moveb %d1,%fp@(-37)
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
559f8: 0686 0000 0020 addil #32,%d6
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
559fe: b486 cmpl %d6,%d2
55a00: 6200 fd30 bhiw 55732 <msdos_find_name_in_fat_file+0xfc>
55a04: d5ae ffe0 addl %d2,%fp@(-32) <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
55a08: 52ae fff0 addql #1,%fp@(-16) <== NOT EXECUTED
55a0c: 122e ffdb moveb %fp@(-37),%d1 <== NOT EXECUTED
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
55a10: 2044 moveal %d4,%a0
55a12: 2f28 008c movel %a0@(140),%sp@-
55a16: 2f02 movel %d2,%sp@-
55a18: 2f2e ffe0 movel %fp@(-32),%sp@-
55a1c: 2f0a movel %a2,%sp@-
55a1e: 2d41 ffbe movel %d1,%fp@(-66)
55a22: 2f0d movel %a5,%sp@-
55a24: 4eb9 0004 fb66 jsr 4fb66 <fat_file_read>
55a2a: 222e ffbe movel %fp@(-66),%d1
55a2e: 4fef 0014 lea %sp@(20),%sp
55a32: 4a80 tstl %d0
55a34: 6600 fcce bnew 55704 <msdos_find_name_in_fat_file+0xce>
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
55a38: 2e3c 0000 7d01 movel #32001,%d7 <== NOT EXECUTED
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
55a3e: 4a2e ffec tstb %fp@(-20) <== NOT EXECUTED
55a42: 6700 0380 beqw 55dc4 <msdos_find_name_in_fat_file+0x78e><== NOT EXECUTED
* data to place in each long file name entry. First set the short
* file name to the slot of the SFN entry. This will mean no clashes
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
55a46: 7002 moveq #2,%d0
55a48: b0ae 001c cmpl %fp@(28),%d0
55a4c: 6672 bnes 55ac0 <msdos_find_name_in_fat_file+0x48a>
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
55a4e: 202e ffe8 movel %fp@(-24),%d0
55a52: 4c02 0800 mulsl %d2,%d0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
55a56: 2043 moveal %d3,%a0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
55a58: 7220 moveq #32,%d1
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
55a5a: d0ae ffe4 addl %fp@(-28),%d0
55a5e: ea88 lsrl #5,%d0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
55a60: 41f0 0801 lea %a0@(00000001,%d0:l),%a0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
55a64: 1014 moveb %a4@,%d0
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
55a66: 2c08 movel %a0,%d6
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
55a68: 49c0 extbl %d0
55a6a: b280 cmpl %d0,%d1
55a6c: 6606 bnes 55a74 <msdos_find_name_in_fat_file+0x43e><== ALWAYS TAKEN
*c = '_';
55a6e: 18bc 005f moveb #95,%a4@ <== NOT EXECUTED
55a72: 6006 bras 55a7a <msdos_find_name_in_fat_file+0x444><== NOT EXECUTED
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
55a74: 7e2e moveq #46,%d7
55a76: be80 cmpl %d0,%d7
55a78: 67f4 beqs 55a6e <msdos_find_name_in_fat_file+0x438><== NEVER TAKEN
55a7a: 7220 moveq #32,%d1
55a7c: 102c 0001 moveb %a4@(1),%d0
55a80: 49c0 extbl %d0
55a82: b280 cmpl %d0,%d1
55a84: 6608 bnes 55a8e <msdos_find_name_in_fat_file+0x458><== ALWAYS TAKEN
*c = '_';
55a86: 7e5f moveq #95,%d7 <== NOT EXECUTED
55a88: 1947 0001 moveb %d7,%a4@(1) <== NOT EXECUTED
55a8c: 6006 bras 55a94 <msdos_find_name_in_fat_file+0x45e><== NOT EXECUTED
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
55a8e: 722e moveq #46,%d1
55a90: b280 cmpl %d0,%d1
55a92: 67f2 beqs 55a86 <msdos_find_name_in_fat_file+0x450><== NEVER TAKEN
msdos_short_name_hex(char* sfn, int num)
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
55a94: 41ec 0002 lea %a4@(2),%a0
55a98: 700c moveq #12,%d0
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
55a9a: 43f9 0006 75d2 lea 675d2 <rtems_filesystem_default_pathconf+0xac>,%a1
55aa0: 2206 movel %d6,%d1
55aa2: e0a1 asrl %d0,%d1
55aa4: 7e0f moveq #15,%d7
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
55aa6: 5980 subql #4,%d0
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
55aa8: c287 andl %d7,%d1
55aaa: 10f1 1800 moveb %a1@(00000000,%d1:l),%a0@+
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
55aae: 72fc moveq #-4,%d1
55ab0: b280 cmpl %d0,%d1
55ab2: 66ec bnes 55aa0 <msdos_find_name_in_fat_file+0x46a>
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
55ab4: 7c7e moveq #126,%d6
*c++ = '1';
55ab6: 7e31 moveq #49,%d7
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
55ab8: 1946 0006 moveb %d6,%a4@(6)
*c++ = '1';
55abc: 1947 0007 moveb %d7,%a4@(7)
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
}
if (lfn_entries)
55ac0: 4a83 tstl %d3
55ac2: 6730 beqs 55af4 <msdos_find_name_in_fat_file+0x4be>
55ac4: 204c moveal %a4,%a0
55ac6: 700b moveq #11,%d0
55ac8: 4201 clrb %d1
55aca: 1d41 ffef moveb %d1,%fp@(-17)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
((lfn_checksum & 1) ? 0x80 : 0) + (lfn_checksum >> 1) + *p;
55ace: 4286 clrl %d6
55ad0: 1c2e ffef moveb %fp@(-17),%d6
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
55ad4: 0806 0000 btst #0,%d6
55ad8: 6704 beqs 55ade <msdos_find_name_in_fat_file+0x4a8>
55ada: 7280 moveq #-128,%d1
55adc: 6002 bras 55ae0 <msdos_find_name_in_fat_file+0x4aa>
55ade: 4201 clrb %d1
55ae0: e28e lsrl #1,%d6
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
55ae2: 5380 subql #1,%d0
lfn_checksum =
55ae4: 1e18 moveb %a0@+,%d7
55ae6: dc87 addl %d7,%d6
55ae8: dc81 addl %d1,%d6
55aea: 1d46 ffef moveb %d6,%fp@(-17)
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
55aee: 4a80 tstl %d0
55af0: 66dc bnes 55ace <msdos_find_name_in_fat_file+0x498>
55af2: 6006 bras 55afa <msdos_find_name_in_fat_file+0x4c4>
* If a long file name calculate the checksum of the short file name
* data to place in each long file name entry. First set the short
* file name to the slot of the SFN entry. This will mean no clashes
* in this directory.
*/
lfn_checksum = 0;
55af4: 4201 clrb %d1
55af6: 1d41 ffef moveb %d1,%fp@(-17)
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
55afa: 4a85 tstl %d5
55afc: 670e beqs 55b0c <msdos_find_name_in_fat_file+0x4d6><== NEVER TAKEN
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
55afe: 2c2e ffe8 movel %fp@(-24),%d6
55b02: bcae fff0 cmpl %fp@(-16),%d6
55b06: 56c0 sne %d0
55b08: 4480 negl %d0
55b0a: 600e bras 55b1a <msdos_find_name_in_fat_file+0x4e4>
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
55b0c: 2e2e fff0 movel %fp@(-16),%d7 <== NOT EXECUTED
{
read_cluster = true;
55b10: 7001 moveq #1,%d0 <== NOT EXECUTED
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
55b12: 2d47 ffe8 movel %d7,%fp@(-24) <== NOT EXECUTED
{
read_cluster = true;
empty_space_offset = dir_offset;
empty_space_entry = 0;
55b16: 42ae ffe4 clrl %fp@(-28) <== NOT EXECUTED
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
55b1a: 72ff moveq #-1,%d1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55b1c: 2c03 movel %d3,%d6
55b1e: 5286 addql #1,%d6
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
55b20: 4287 clrl %d7
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
55b22: 2d41 fff8 movel %d1,%fp@(-8)
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55b26: 206e 0014 moveal %fp@(20),%a0
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
55b2a: 2d41 fff4 movel %d1,%fp@(-12)
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55b2e: 720d moveq #13,%d1
55b30: 4c03 1800 mulsl %d3,%d1
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
55b34: 2a2e ffe8 movel %fp@(-24),%d5
55b38: 4c02 5800 mulsl %d2,%d5
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55b3c: 41f0 18f3 lea %a0@(fffffff3,%d1:l),%a0
55b40: 2d4c ffca movel %a4,%fp@(-54)
55b44: 284b moveal %a3,%a4
55b46: 2644 moveal %d4,%a3
55b48: 2d43 ffd6 movel %d3,%fp@(-42)
55b4c: 260a movel %a2,%d3
55b4e: 2d46 ffd2 movel %d6,%fp@(-46)
55b52: 2d48 ffdc movel %a0,%fp@(-36)
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
55b56: 6000 025a braw 55db2 <msdos_find_name_in_fat_file+0x77c>
{
int length = 0;
if (read_cluster)
55b5a: 4a00 tstb %d0
55b5c: 671a beqs 55b78 <msdos_find_name_in_fat_file+0x542><== ALWAYS TAKEN
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(mt_entry, fat_fd,
55b5e: 2f2b 008c movel %a3@(140),%sp@- <== NOT EXECUTED
55b62: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55b64: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55b66: 2f03 movel %d3,%sp@- <== NOT EXECUTED
55b68: 2f0d movel %a5,%sp@- <== NOT EXECUTED
55b6a: 4eb9 0004 fb66 jsr 4fb66 <fat_file_read> <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
55b70: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
55b74: b480 cmpl %d0,%d2 <== NOT EXECUTED
55b76: 662c bnes 55ba4 <msdos_find_name_in_fat_file+0x56e><== NOT EXECUTED
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55b78: 2007 movel %d7,%d0
55b7a: 5280 addql #1,%d0
55b7c: 4284 clrl %d4
#endif
ret = fat_file_read(mt_entry, fat_fd,
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
55b7e: 222e ffd2 movel %fp@(-46),%d1
55b82: 9280 subl %d0,%d1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55b84: 700d moveq #13,%d0
55b86: 4c07 0800 mulsl %d7,%d0
55b8a: 226e ffdc moveal %fp@(-36),%a1
55b8e: 93c0 subal %d0,%a1
55b90: 2c2e ffe4 movel %fp@(-28),%d6
55b94: 42ae ffe0 clrl %fp@(-32)
55b98: 2d49 ffce movel %a1,%fp@(-50)
55b9c: 2d43 ffc2 movel %d3,%fp@(-62)
55ba0: 6000 01c0 braw 55d62 <msdos_find_name_in_fat_file+0x72c>
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
{
if (ret != FAT_EOF)
55ba4: 4a80 tstl %d0 <== NOT EXECUTED
55ba6: 6710 beqs 55bb8 <msdos_find_name_in_fat_file+0x582><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
55ba8: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
55bae: 7205 moveq #5,%d1 <== NOT EXECUTED
55bb0: 2440 moveal %d0,%a2 <== NOT EXECUTED
55bb2: 2481 movel %d1,%a2@ <== NOT EXECUTED
55bb4: 6000 020c braw 55dc2 <msdos_find_name_in_fat_file+0x78c><== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif
ret = fat_file_extend (mt_entry, fat_fd, empty_space_offset * bts2rd,
55bb8: 486e fffc pea %fp@(-4) <== NOT EXECUTED
55bbc: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55bbe: 2f03 movel %d3,%sp@- <== NOT EXECUTED
55bc0: 2f0d movel %a5,%sp@- <== NOT EXECUTED
55bc2: 4eb9 0004 ff24 jsr 4ff24 <fat_file_extend> <== NOT EXECUTED
&new_length);
if (ret != RC_OK)
55bc8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
55bcc: 4a80 tstl %d0 <== NOT EXECUTED
55bce: 6600 01ee bnew 55dbe <msdos_find_name_in_fat_file+0x788><== NOT EXECUTED
return ret;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.3] extended: %d <-> %d\n", new_length, empty_space_offset * bts2rd);
#endif
if (new_length != (empty_space_offset * bts2rd))
55bd2: baae fffc cmpl %fp@(-4),%d5 <== NOT EXECUTED
55bd6: 6600 01c2 bnew 55d9a <msdos_find_name_in_fat_file+0x764><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
55bda: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55bdc: 42a7 clrl %sp@- <== NOT EXECUTED
55bde: 2f2b 008c movel %a3@(140),%sp@- <== NOT EXECUTED
55be2: 4eb9 0005 8848 jsr 58848 <memset> <== NOT EXECUTED
ret = fat_file_write(mt_entry, fat_fd,
55be8: 2f2b 008c movel %a3@(140),%sp@- <== NOT EXECUTED
55bec: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55bee: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55bf0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
55bf2: 2f0d movel %a5,%sp@- <== NOT EXECUTED
55bf4: 4eb9 0005 00b2 jsr 500b2 <fat_file_write> <== NOT EXECUTED
empty_space_offset * bts2rd,
bts2rd, fs_info->cl_buf);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.4] clear write: %d\n", ret);
#endif
if (ret == -1)
55bfa: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
55bfe: 72ff moveq #-1,%d1 <== NOT EXECUTED
55c00: b280 cmpl %d0,%d1 <== NOT EXECUTED
55c02: 6700 01be beqw 55dc2 <msdos_find_name_in_fat_file+0x78c><== NOT EXECUTED
return ret;
else if (ret != bts2rd)
55c06: b480 cmpl %d0,%d2 <== NOT EXECUTED
55c08: 6700 ff6e beqw 55b78 <msdos_find_name_in_fat_file+0x542><== NOT EXECUTED
55c0c: 6000 018c braw 55d9a <msdos_find_name_in_fat_file+0x764><== NOT EXECUTED
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
55c10: 246b 008c moveal %a3@(140),%a2
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
55c14: 0684 0000 0020 addil #32,%d4
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
55c1a: d5c6 addal %d6,%a2
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
55c1c: 5287 addql #1,%d7
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
55c1e: beae ffd2 cmpl %fp@(-46),%d7
55c22: 667a bnes 55c9e <msdos_find_name_in_fat_file+0x668>
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
55c24: 2f0c movel %a4,%sp@-
55c26: 262e ffc2 movel %fp@(-62),%d3
55c2a: 2f05 movel %d5,%sp@-
55c2c: 4878 0001 pea 1 <ADD>
55c30: 41f9 0004 fe8c lea 4fe8c <fat_file_ioctl>,%a0
55c36: 2f03 movel %d3,%sp@-
55c38: 2d48 ffbe movel %a0,%fp@(-66)
55c3c: 2f0d movel %a5,%sp@-
55c3e: 4e90 jsr %a0@
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
55c40: 206e ffbe moveal %fp@(-66),%a0
55c44: 4fef 0014 lea %sp@(20),%sp
55c48: 4a80 tstl %d0
55c4a: 6600 0172 bnew 55dbe <msdos_find_name_in_fat_file+0x788>
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
55c4e: 202e fff4 movel %fp@(-12),%d0
55c52: 72ff moveq #-1,%d1
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
55c54: 2946 0004 movel %d6,%a4@(4)
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
55c58: b280 cmpl %d0,%d1
55c5a: 671e beqs 55c7a <msdos_find_name_in_fat_file+0x644>
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
55c5c: 486e fff4 pea %fp@(-12)
55c60: 4c02 0800 mulsl %d2,%d0
55c64: 2f00 movel %d0,%sp@-
55c66: 4878 0001 pea 1 <ADD>
55c6a: 2f03 movel %d3,%sp@-
55c6c: 2f0d movel %a5,%sp@-
55c6e: 4e90 jsr %a0@
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
55c70: 4fef 0014 lea %sp@(20),%sp
55c74: 4a80 tstl %d0
55c76: 6600 0146 bnew 55dbe <msdos_find_name_in_fat_file+0x788>
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
55c7a: 296e fff4 0008 movel %fp@(-12),%a4@(8)
dir_pos->lname.ofs = lfn_start.ofs;
55c80: 296e fff8 000c movel %fp@(-8),%a4@(12)
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
55c86: 4878 0020 pea 20 <OPER2+0xc>
55c8a: 2f2e ffca movel %fp@(-54),%sp@-
55c8e: 2f0a movel %a2,%sp@-
55c90: 4eb9 0005 87d8 jsr 587d8 <memcpy>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
55c96: 4fef 000c lea %sp@(12),%sp
55c9a: 6000 00d0 braw 55d6c <msdos_find_name_in_fat_file+0x736>
* This is a long file name and we need to write
* a long file name entry. See if this is the
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
55c9e: 76ff moveq #-1,%d3
55ca0: b6ae fff4 cmpl %fp@(-12),%d3
55ca4: 660c bnes 55cb2 <msdos_find_name_in_fat_file+0x67c>
{
lfn_start.cln = empty_space_offset;
55ca6: 262e ffe8 movel %fp@(-24),%d3
lfn_start.ofs = dir_entry;
55caa: 2d46 fff8 movel %d6,%fp@(-8)
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_start.cln = empty_space_offset;
55cae: 2d43 fff4 movel %d3,%fp@(-12)
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
55cb2: 4878 0020 pea 20 <OPER2+0xc>
55cb6: 42a7 clrl %sp@-
55cb8: 2d41 ffbe movel %d1,%fp@(-66)
55cbc: 2f0a movel %a2,%sp@-
55cbe: 4eb9 0005 8848 jsr 58848 <memset>
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55cc4: 226e ffce moveal %fp@(-50),%a1
55cc8: d3ee ffe0 addal %fp@(-32),%a1
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
55ccc: 41ea 0001 lea %a2@(1),%a0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
55cd0: 4fef 000c lea %sp@(12),%sp
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
55cd4: 162e ffef moveb %fp@(-17),%d3
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
55cd8: 4200 clrb %d0
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
55cda: 2d42 ffc6 movel %d2,%fp@(-58)
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
55cde: 1543 000d moveb %d3,%a2@(13)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
55ce2: 1d40 fff0 moveb %d0,%fp@(-16)
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
55ce6: 262e ffc2 movel %fp@(-62),%d3
55cea: 4280 clrl %d0
55cec: 222e ffbe movel %fp@(-66),%d1
{
if (*n != 0)
55cf0: 1411 moveb %a1@,%d2
55cf2: 6706 beqs 55cfa <msdos_find_name_in_fat_file+0x6c4>
{
*p = *n;
n++;
55cf4: 5289 addql #1,%a1
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
{
*p = *n;
55cf6: 1082 moveb %d2,%a0@
55cf8: 6012 bras 55d0c <msdos_find_name_in_fat_file+0x6d6>
n++;
}
else
{
p [0] = fill;
p [1] = fill;
55cfa: 142e fff0 moveb %fp@(-16),%d2
*p = *n;
n++;
}
else
{
p [0] = fill;
55cfe: 10ae fff0 moveb %fp@(-16),%a0@
p [1] = fill;
55d02: 1142 0001 moveb %d2,%a0@(1)
fill = 0xff;
55d06: 50c2 st %d2
55d08: 1d42 fff0 moveb %d2,%fp@(-16)
}
switch (i)
55d0c: 7404 moveq #4,%d2
55d0e: b480 cmpl %d0,%d2
55d10: 670a beqs 55d1c <msdos_find_name_in_fat_file+0x6e6>
55d12: 143c 000a moveb #10,%d2
55d16: b480 cmpl %d0,%d2
55d18: 660a bnes 55d24 <msdos_find_name_in_fat_file+0x6ee>
55d1a: 6004 bras 55d20 <msdos_find_name_in_fat_file+0x6ea>
{
case 4:
p += 5;
55d1c: 5a88 addql #5,%a0
break;
55d1e: 6006 bras 55d26 <msdos_find_name_in_fat_file+0x6f0>
case 10:
p += 4;
55d20: 5888 addql #4,%a0
break;
55d22: 6002 bras 55d26 <msdos_find_name_in_fat_file+0x6f0>
default:
p += 2;
55d24: 5488 addql #2,%a0
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
55d26: 5280 addql #1,%d0
55d28: 740d moveq #13,%d2
55d2a: b480 cmpl %d0,%d2
55d2c: 66c2 bnes 55cf0 <msdos_find_name_in_fat_file+0x6ba>
55d2e: 2d43 ffc2 movel %d3,%fp@(-62)
55d32: 242e ffc6 movel %fp@(-58),%d2
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
55d36: 7601 moveq #1,%d3
p += 2;
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
55d38: 1481 moveb %d1,%a2@
if (lfn_entry == 1)
55d3a: b687 cmpl %d7,%d3
55d3c: 6606 bnes 55d44 <msdos_find_name_in_fat_file+0x70e>
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
55d3e: 7040 moveq #64,%d0
55d40: 8081 orl %d1,%d0
55d42: 1480 moveb %d0,%a2@
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
55d44: 0686 0000 0020 addil #32,%d6
55d4a: 5381 subql #1,%d1
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
55d4c: 102a 000b moveb %a2@(11),%d0
55d50: 3040 moveaw %d0,%a0
55d52: 700f moveq #15,%d0
55d54: 2608 movel %a0,%d3
55d56: 8680 orl %d0,%d3
55d58: 1543 000b moveb %d3,%a2@(11)
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
55d5c: 76f3 moveq #-13,%d3
55d5e: d7ae ffe0 addl %d3,%fp@(-32)
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
55d62: b486 cmpl %d6,%d2
55d64: 6200 feaa bhiw 55c10 <msdos_find_name_in_fat_file+0x5da>
55d68: 262e ffc2 movel %fp@(-62),%d3 <== NOT EXECUTED
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(mt_entry, fat_fd,
55d6c: 2c2e ffe4 movel %fp@(-28),%d6
55d70: dcab 008c addl %a3@(140),%d6
55d74: 2f06 movel %d6,%sp@-
55d76: 206e ffe4 moveal %fp@(-28),%a0
55d7a: 2f04 movel %d4,%sp@-
55d7c: 4870 5800 pea %a0@(00000000,%d5:l)
55d80: 2f03 movel %d3,%sp@-
55d82: 2f0d movel %a5,%sp@-
55d84: 4eb9 0005 00b2 jsr 500b2 <fat_file_write>
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
55d8a: 4fef 0014 lea %sp@(20),%sp
55d8e: 72ff moveq #-1,%d1
55d90: b280 cmpl %d0,%d1
55d92: 672e beqs 55dc2 <msdos_find_name_in_fat_file+0x78c><== NEVER TAKEN
55d94: da82 addl %d2,%d5
return ret;
else if (ret != length)
55d96: b880 cmpl %d0,%d4
55d98: 670e beqs 55da8 <msdos_find_name_in_fat_file+0x772><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
55d9a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
55da0: 2040 moveal %d0,%a0 <== NOT EXECUTED
55da2: 7005 moveq #5,%d0 <== NOT EXECUTED
55da4: 2080 movel %d0,%a0@ <== NOT EXECUTED
55da6: 601a bras 55dc2 <msdos_find_name_in_fat_file+0x78c><== NOT EXECUTED
empty_space_offset++;
55da8: 52ae ffe8 addql #1,%fp@(-24)
empty_space_entry = 0;
read_cluster = true;
55dac: 7001 moveq #1,%d0
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
empty_space_entry = 0;
55dae: 42ae ffe4 clrl %fp@(-28)
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
55db2: beae ffd6 cmpl %fp@(-42),%d7
55db6: 6f00 fda2 blew 55b5a <msdos_find_name_in_fat_file+0x524>
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
55dba: 4287 clrl %d7
55dbc: 6006 bras 55dc4 <msdos_find_name_in_fat_file+0x78e>
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
55dbe: 2e00 movel %d0,%d7 <== NOT EXECUTED
55dc0: 6002 bras 55dc4 <msdos_find_name_in_fat_file+0x78e><== NOT EXECUTED
}
ret = fat_file_write(mt_entry, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
55dc2: 7eff moveq #-1,%d7 <== NOT EXECUTED
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
55dc4: 2007 movel %d7,%d0
55dc6: 4cee 3cfc ff94 moveml %fp@(-108),%d2-%d7/%a2-%a5
55dcc: 4e5e unlk %fp <== NOT EXECUTED
00055dd0 <msdos_find_node_by_cluster_num_in_fat_file>:
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
55dd0: 7001 moveq #1,%d0 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
55dd2: 4e56 ffd8 linkw %fp,#-40 <== NOT EXECUTED
55dd6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
55dda: 2a2e 0008 movel %fp@(8),%d5 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55dde: 2045 moveal %d5,%a0 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
55de0: 266e 000c moveal %fp@(12),%a3 <== NOT EXECUTED
55de4: 286e 0014 moveal %fp@(20),%a4 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55de8: 2a68 0034 moveal %a0@(52),%a5 <== NOT EXECUTED
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
55dec: b0ab 0020 cmpl %a3@(32),%d0 <== NOT EXECUTED
55df0: 6622 bnes 55e14 <msdos_find_node_by_cluster_num_in_fat_file+0x44><== NOT EXECUTED
55df2: 4aab 0024 tstl %a3@(36) <== NOT EXECUTED
55df6: 661c bnes 55e14 <msdos_find_node_by_cluster_num_in_fat_file+0x44><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
55df8: 4280 clrl %d0 <== NOT EXECUTED
55dfa: 102d 000a moveb %a5@(10),%d0 <== NOT EXECUTED
55dfe: 7203 moveq #3,%d1 <== NOT EXECUTED
55e00: c081 andl %d1,%d0 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
55e02: 6710 beqs 55e14 <msdos_find_node_by_cluster_num_in_fat_file+0x44><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
55e04: 242b 0018 movel %a3@(24),%d2 <== NOT EXECUTED
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
55e08: 4284 clrl %d4 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
55e0a: 2e3c 0004 fb66 movel #326502,%d7 <== NOT EXECUTED
55e10: 6000 00dc braw 55eee <msdos_find_node_by_cluster_num_in_fat_file+0x11e><== NOT EXECUTED
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
55e14: 4282 clrl %d2 <== NOT EXECUTED
55e16: 342d 0006 movew %a5@(6),%d2 <== NOT EXECUTED
55e1a: 60ec bras 55e08 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
55e1c: 7c1f moveq #31,%d6 <== NOT EXECUTED
55e1e: bc80 cmpl %d0,%d6 <== NOT EXECUTED
55e20: 6d12 blts 55e34 <msdos_find_node_by_cluster_num_in_fat_file+0x64><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
55e22: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
55e28: 7405 moveq #5,%d2 <== NOT EXECUTED
55e2a: 2040 moveal %d0,%a0 <== NOT EXECUTED
55e2c: 2082 movel %d2,%a0@ <== NOT EXECUTED
55e2e: 74ff moveq #-1,%d2 <== NOT EXECUTED
55e30: 6000 00dc braw 55f0e <msdos_find_node_by_cluster_num_in_fat_file+0x13e><== NOT EXECUTED
assert(ret == bts2rd);
55e34: b480 cmpl %d0,%d2 <== NOT EXECUTED
55e36: 671c beqs 55e54 <msdos_find_node_by_cluster_num_in_fat_file+0x84><== NOT EXECUTED
55e38: 4879 0006 7c12 pea 67c12 <msdos_file_handlers+0xdc> <== NOT EXECUTED
55e3e: 4879 0006 7c57 pea 67c57 <__FUNCTION__.7159> <== NOT EXECUTED
55e44: 4878 069e pea 69e <DBL_MAX_EXP+0x29d> <== NOT EXECUTED
55e48: 4879 0006 7ba3 pea 67ba3 <msdos_file_handlers+0x6d> <== NOT EXECUTED
55e4e: 4eb9 0005 20dc jsr 520dc <__assert_func> <== NOT EXECUTED
55e54: 246d 008c moveal %a5@(140),%a2 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
55e58: 4283 clrl %d3 <== NOT EXECUTED
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
55e5a: 1012 moveb %a2@,%d0 <== NOT EXECUTED
55e5c: 6700 00aa beqw 55f08 <msdos_find_node_by_cluster_num_in_fat_file+0x138><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
/* if this entry is empty - skip it */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
55e60: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
55e66: 0c80 0000 00e5 cmpil #229,%d0 <== NOT EXECUTED
55e6c: 676e beqs 55edc <msdos_find_node_by_cluster_num_in_fat_file+0x10c><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
55e6e: 4281 clrl %d1 <== NOT EXECUTED
55e70: 322a 0014 movew %a2@(20),%d1 <== NOT EXECUTED
55e74: 2001 movel %d1,%d0 <== NOT EXECUTED
55e76: e089 lsrl #8,%d1 <== NOT EXECUTED
55e78: e188 lsll #8,%d0 <== NOT EXECUTED
55e7a: 8081 orl %d1,%d0 <== NOT EXECUTED
55e7c: 4281 clrl %d1 <== NOT EXECUTED
55e7e: 322a 001a movew %a2@(26),%d1 <== NOT EXECUTED
55e82: 4840 swap %d0 <== NOT EXECUTED
55e84: 4240 clrw %d0 <== NOT EXECUTED
55e86: 2041 moveal %d1,%a0 <== NOT EXECUTED
55e88: 2c08 movel %a0,%d6 <== NOT EXECUTED
55e8a: e08e lsrl #8,%d6 <== NOT EXECUTED
55e8c: e189 lsll #8,%d1 <== NOT EXECUTED
55e8e: 8286 orl %d6,%d1 <== NOT EXECUTED
55e90: 0281 0000 ffff andil #65535,%d1 <== NOT EXECUTED
55e96: 8081 orl %d1,%d0 <== NOT EXECUTED
55e98: b0ae 0010 cmpl %fp@(16),%d0 <== NOT EXECUTED
55e9c: 663e bnes 55edc <msdos_find_node_by_cluster_num_in_fat_file+0x10c><== NOT EXECUTED
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
55e9e: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55ea0: 2f04 movel %d4,%sp@- <== NOT EXECUTED
55ea2: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
55ea6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55ea8: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55eaa: 4eb9 0004 fe8c jsr 4fe8c <fat_file_ioctl> <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
55eb0: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
55eb4: 2400 movel %d0,%d2 <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
55eb6: 6656 bnes 55f0e <msdos_find_node_by_cluster_num_in_fat_file+0x13e><== NOT EXECUTED
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
55eb8: 70ff moveq #-1,%d0 <== NOT EXECUTED
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = i;
55eba: 2943 0004 movel %d3,%a4@(4) <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
55ebe: 2940 0008 movel %d0,%a4@(8) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
55ec2: 2940 000c movel %d0,%a4@(12) <== NOT EXECUTED
memcpy(dir_entry, entry,
55ec6: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
55eca: 2f0a movel %a2,%sp@- <== NOT EXECUTED
55ecc: 2f2e 0018 movel %fp@(24),%sp@- <== NOT EXECUTED
55ed0: 4eb9 0005 87d8 jsr 587d8 <memcpy> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
55ed6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55eda: 6032 bras 55f0e <msdos_find_node_by_cluster_num_in_fat_file+0x13e><== NOT EXECUTED
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
55edc: 0683 0000 0020 addil #32,%d3 <== NOT EXECUTED
55ee2: 45ea 0020 lea %a2@(32),%a2 <== NOT EXECUTED
55ee6: b483 cmpl %d3,%d2 <== NOT EXECUTED
55ee8: 6200 ff70 bhiw 55e5a <msdos_find_node_by_cluster_num_in_fat_file+0x8a><== NOT EXECUTED
55eec: d882 addl %d2,%d4 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
55eee: 2f2d 008c movel %a5@(140),%sp@- <== NOT EXECUTED
55ef2: 2047 moveal %d7,%a0 <== NOT EXECUTED
55ef4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55ef6: 2f04 movel %d4,%sp@- <== NOT EXECUTED
55ef8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55efa: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55efc: 4e90 jsr %a0@ <== NOT EXECUTED
55efe: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
55f02: 4a80 tstl %d0 <== NOT EXECUTED
55f04: 6600 ff16 bnew 55e1c <msdos_find_node_by_cluster_num_in_fat_file+0x4c><== NOT EXECUTED
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
55f08: 243c 0000 7d01 movel #32001,%d2 <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
55f0e: 2002 movel %d2,%d0 <== NOT EXECUTED
55f10: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5 <== NOT EXECUTED
55f16: 4e5e unlk %fp <== NOT EXECUTED
0004c542 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c542: 4e56 fd30 linkw %fp,#-720
4c546: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
4c54a: 4879 0006 77aa pea 677aa <_CPU_m68k_BFFFO_table+0x13a>
4c550: 47fa fe2a lea %pc@(4c37c <msdos_format_printf>),%a3
4c554: 4878 0002 pea 2 <DOUBLE_FLOAT>
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c558: 246e 000c moveal %fp@(12),%a2
4c55c: 262e 0008 movel %fp@(8),%d3
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
4c560: 2f0a movel %a2,%sp@-
4c562: 4e93 jsr %a3@
fd = open(devname, O_RDWR);
4c564: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c568: 2f03 movel %d3,%sp@-
4c56a: 4eb9 0004 62b0 jsr 462b0 <open>
if (fd == -1) {
4c570: 4fef 0014 lea %sp@(20),%sp
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
4c574: 2400 movel %d0,%d2
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
rtems_disk_device *dd = NULL;
struct stat stat_buf;
int ret_val = 0;
4c576: 70ff moveq #-1,%d0
4c578: b082 cmpl %d2,%d0
4c57a: 57c6 seq %d6
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c57c: 2f03 movel %d3,%sp@-
4c57e: 4879 0006 77b7 pea 677b7 <_CPU_m68k_BFFFO_table+0x147>
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
rtems_disk_device *dd = NULL;
struct stat stat_buf;
int ret_val = 0;
4c584: 49c6 extbl %d6
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c586: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c58a: 2f0a movel %a2,%sp@-
4c58c: 4e93 jsr %a3@
"stat check: %s\n", devname);
if (ret_val == 0) {
4c58e: 4fef 0010 lea %sp@(16),%sp
4c592: 4a86 tstl %d6
4c594: 6612 bnes 4c5a8 <msdos_format+0x66> <== NEVER TAKEN
rc = fstat(fd, &stat_buf);
4c596: 486e ffb0 pea %fp@(-80)
4c59a: 2f02 movel %d2,%sp@-
4c59c: 4eb9 0005 2258 jsr 52258 <fstat>
4c5a2: 508f addql #8,%sp
ret_val = rc;
4c5a4: 2840 moveal %d0,%a4
4c5a6: 6004 bras 4c5ac <msdos_format+0x6a>
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"stat check: %s\n", devname);
if (ret_val == 0) {
4c5a8: 387c ffff moveaw #-1,%a4 <== NOT EXECUTED
rc = fstat(fd, &stat_buf);
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4c5ac: 2f03 movel %d3,%sp@-
4c5ae: 4879 0006 77c7 pea 677c7 <_CPU_m68k_BFFFO_table+0x157>
4c5b4: 4bfa fdc6 lea %pc@(4c37c <msdos_format_printf>),%a5
4c5b8: 4878 0001 pea 1 <ADD>
4c5bc: 2f0a movel %a2,%sp@-
4c5be: 4e95 jsr %a5@
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
4c5c0: 4fef 0010 lea %sp@(16),%sp
4c5c4: 4a8c tstl %a4
4c5c6: 6632 bnes 4c5fa <msdos_format+0xb8> <== NEVER TAKEN
4c5c8: 202e ffbc movel %fp@(-68),%d0
4c5cc: 0280 0000 f000 andil #61440,%d0
4c5d2: 0c80 0000 6000 cmpil #24576,%d0
4c5d8: 6700 08fe beqw 4ced8 <msdos_format+0x996>
errno = ENOTTY;
4c5dc: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4c5e2: 7e19 moveq #25,%d7 <== NOT EXECUTED
4c5e4: 2040 moveal %d0,%a0 <== NOT EXECUTED
4c5e6: 2087 movel %d7,%a0@ <== NOT EXECUTED
4c5e8: 600c bras 4c5f6 <msdos_format+0xb4> <== NOT EXECUTED
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
if (dd == NULL) {
errno = ENOTTY;
4c5ea: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4c5f0: 7c19 moveq #25,%d6 <== NOT EXECUTED
4c5f2: 2840 moveal %d0,%a4 <== NOT EXECUTED
4c5f4: 2886 movel %d6,%a4@ <== NOT EXECUTED
ret_val = -1;
4c5f6: 387c ffff moveaw #-1,%a4 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
4c5fa: 97cb subal %a3,%a3 <== NOT EXECUTED
4c5fc: 6000 08b0 braw 4ceae <msdos_format+0x96c> <== NOT EXECUTED
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
4c600: 202a 000c movel %a2@(12),%d0
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4c604: 6604 bnes 4c60a <msdos_format+0xc8> <== NEVER TAKEN
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
4c606: 7002 moveq #2,%d0
4c608: 6008 bras 4c612 <msdos_format+0xd0>
}
else if (rqdata->fat_num <= 6) {
4c60a: 7206 moveq #6,%d1 <== NOT EXECUTED
4c60c: b280 cmpl %d0,%d1 <== NOT EXECUTED
4c60e: 6500 01d6 bcsw 4c7e6 <msdos_format+0x2a4> <== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
4c612: 7c01 moveq #1,%d6
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
4c614: 1d40 ff92 moveb %d0,%fp@(-110)
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c618: 4280 clrl %d0
4c61a: 102e ff92 moveb %fp@(-110),%d0
4c61e: 2f00 movel %d0,%sp@-
4c620: 4879 0006 77d6 pea 677d6 <_CPU_m68k_BFFFO_table+0x166>
4c626: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c62a: 2f0a movel %a2,%sp@-
4c62c: 4eba fd4e jsr %pc@(4c37c <msdos_format_printf>)
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
4c630: 4fef 0010 lea %sp@(16),%sp
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
4c634: 2d46 ff6e movel %d6,%fp@(-146)
if ((rqdata != NULL) &&
4c638: 4a8a tstl %a2
4c63a: 673e beqs 4c67a <msdos_format+0x138> <== NEVER TAKEN
4c63c: 4280 clrl %d0
(rqdata->fattype == MSDOS_FMT_FAT12)) {
4c63e: 122a 0014 moveb %a2@(20),%d1
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
4c642: 1001 moveb %d1,%d0
4c644: bc80 cmpl %d0,%d6
4c646: 6604 bnes 4c64c <msdos_format+0x10a> <== ALWAYS TAKEN
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
4c648: 7e01 moveq #1,%d7 <== NOT EXECUTED
4c64a: 6012 bras 4c65e <msdos_format+0x11c> <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
4c64c: 7c02 moveq #2,%d6
4c64e: bc80 cmpl %d0,%d6
4c650: 6604 bnes 4c656 <msdos_format+0x114> <== ALWAYS TAKEN
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
4c652: 7e02 moveq #2,%d7 <== NOT EXECUTED
4c654: 6008 bras 4c65e <msdos_format+0x11c> <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
4c656: 7c03 moveq #3,%d6
4c658: bc80 cmpl %d0,%d6
4c65a: 660a bnes 4c666 <msdos_format+0x124> <== ALWAYS TAKEN
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
4c65c: 7e04 moveq #4,%d7 <== NOT EXECUTED
4c65e: 4283 clrl %d3 <== NOT EXECUTED
4c660: 1d47 ff94 moveb %d7,%fp@(-108) <== NOT EXECUTED
4c664: 6076 bras 4c6dc <msdos_format+0x19a> <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
4c666: 4a01 tstb %d1
4c668: 6710 beqs 4c67a <msdos_format+0x138> <== ALWAYS TAKEN
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
4c66a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4c670: 7a16 moveq #22,%d5 <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
}
else if ((rqdata != NULL) &&
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
4c672: 76ff moveq #-1,%d3 <== NOT EXECUTED
errno = EINVAL;
4c674: 2040 moveal %d0,%a0 <== NOT EXECUTED
4c676: 2085 movel %d5,%a0@ <== NOT EXECUTED
4c678: 6062 bras 4c6dc <msdos_format+0x19a> <== NOT EXECUTED
/*
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
if (fmt_params->totl_sector_cnt
4c67a: 0c83 0000 7fa7 cmpil #32679,%d3
4c680: 620a bhis 4c68c <msdos_format+0x14a> <== NEVER TAKEN
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4c682: 7202 moveq #2,%d1
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
if (fmt_params->totl_sector_cnt
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
4c684: 7001 moveq #1,%d0
4c686: 1d40 ff94 moveb %d0,%fp@(-108)
4c68a: 6046 bras 4c6d2 <msdos_format+0x190>
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
4c68c: 0c83 001f fe9f cmpil #2096799,%d3 <== NOT EXECUTED
4c692: 620e bhis 4c6a2 <msdos_format+0x160> <== NOT EXECUTED
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4c694: 7802 moveq #2,%d4 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
4c696: 7602 moveq #2,%d3 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4c698: 2d44 ff6e movel %d4,%fp@(-146) <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
4c69c: 1d43 ff94 moveb %d3,%fp@(-108) <== NOT EXECUTED
4c6a0: 6034 bras 4c6d6 <msdos_format+0x194> <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
4c6a2: 7e1e moveq #30,%d7 <== NOT EXECUTED
4c6a4: 4286 clrl %d6 <== NOT EXECUTED
4c6a6: 0685 4000 0000 addil #1073741824,%d5 <== NOT EXECUTED
4c6ac: d986 addxl %d6,%d4 <== NOT EXECUTED
4c6ae: 2204 movel %d4,%d1 <== NOT EXECUTED
4c6b0: 2005 movel %d5,%d0 <== NOT EXECUTED
4c6b2: eea8 lsrl %d7,%d0 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
4c6b4: 7801 moveq #1,%d4 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
4c6b6: e589 lsll #2,%d1 <== NOT EXECUTED
4c6b8: 8280 orl %d0,%d1 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
4c6ba: 7004 moveq #4,%d0 <== NOT EXECUTED
4c6bc: 1d40 ff94 moveb %d0,%fp@(-108) <== NOT EXECUTED
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4c6c0: 701f moveq #31,%d0 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4c6c2: 2604 movel %d4,%d3 <== NOT EXECUTED
4c6c4: e1ab lsll %d0,%d3 <== NOT EXECUTED
4c6c6: c681 andl %d1,%d3 <== NOT EXECUTED
4c6c8: 6604 bnes 4c6ce <msdos_format+0x18c> <== NOT EXECUTED
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4c6ca: 5380 subql #1,%d0 <== NOT EXECUTED
4c6cc: 66f4 bnes 4c6c2 <msdos_format+0x180> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
4c6ce: 7201 moveq #1,%d1 <== NOT EXECUTED
4c6d0: e1a9 lsll %d0,%d1 <== NOT EXECUTED
4c6d2: 2d41 ff6e movel %d1,%fp@(-146)
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
4c6d6: 4283 clrl %d3
4c6d8: 4a8a tstl %a2
4c6da: 670a beqs 4c6e6 <msdos_format+0x1a4> <== NEVER TAKEN
(rqdata->sectors_per_cluster > 0)) {
4c6dc: 202a 0008 movel %a2@(8),%d0
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
4c6e0: 6704 beqs 4c6e6 <msdos_format+0x1a4> <== ALWAYS TAKEN
(rqdata->sectors_per_cluster > 0)) {
fmt_params->sectors_per_cluster =
4c6e2: 2d40 ff6e movel %d0,%fp@(-146) <== NOT EXECUTED
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
4c6e6: 282e ff62 movel %fp@(-158),%d4
4c6ea: 203c 0000 0080 movel #128,%d0
4c6f0: 222e ff6e movel %fp@(-146),%d1
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
4c6f4: b081 cmpl %d1,%d0
4c6f6: 6216 bhis 4c70e <msdos_format+0x1cc>
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
4c6f8: 223c 0000 8000 movel #32768,%d1
4c6fe: 4c44 1001 remul %d4,%d1,%d1
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
4c702: b280 cmpl %d0,%d1
4c704: 6404 bccs 4c70a <msdos_format+0x1c8> <== ALWAYS TAKEN
4c706: 2200 movel %d0,%d1 <== NOT EXECUTED
4c708: 6004 bras 4c70e <msdos_format+0x1cc> <== NOT EXECUTED
4c70a: 2200 movel %d0,%d1
<= 32768L/fmt_params->bytes_per_sector) {
/* value is small enough so this value is ok */
onebit = 1;
4c70c: 7001 moveq #1,%d0
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
4c70e: e288 lsrl #1,%d0
4c710: 66e2 bnes 4c6f4 <msdos_format+0x1b2>
4c712: 2d41 ff6e movel %d1,%fp@(-146)
}
}
}
}
if (ret_val == 0) {
4c716: 4a83 tstl %d3
4c718: 6600 01de bnew 4c8f8 <msdos_format+0x3b6>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c71c: 2f01 movel %d1,%sp@-
4c71e: 4879 0006 77ea pea 677ea <_CPU_m68k_BFFFO_table+0x17a>
4c724: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c728: 2f0a movel %a2,%sp@-
4c72a: 4eba fc50 jsr %pc@(4c37c <msdos_format_printf>)
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
4c72e: 4fef 0010 lea %sp@(16),%sp
4c732: 4280 clrl %d0
4c734: 102e ff94 moveb %fp@(-108),%d0
4c738: 7204 moveq #4,%d1
4c73a: b280 cmpl %d0,%d1
4c73c: 6618 bnes 4c756 <msdos_format+0x214> <== ALWAYS TAKEN
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
4c73e: 7820 moveq #32,%d4 <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4c740: 7a06 moveq #6,%d5 <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4c742: 7c01 moveq #1,%d6 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
4c744: 2d44 ff6a movel %d4,%fp@(-150) <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
4c748: 42ae ff7a clrl %fp@(-134) <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4c74c: 2d45 ff8a movel %d5,%fp@(-118) <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4c750: 2d46 ff8e movel %d6,%fp@(-114) <== NOT EXECUTED
4c754: 604a bras 4c7a0 <msdos_format+0x25e> <== NOT EXECUTED
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
4c756: 7e01 moveq #1,%d7
4c758: 2d47 ff6a movel %d7,%fp@(-150)
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
4c75c: 4a8a tstl %a2
4c75e: 670c beqs 4c76c <msdos_format+0x22a> <== NEVER TAKEN
(rqdata->files_per_root_dir > 0)) {
4c760: 222a 0010 movel %a2@(16),%d1
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
4c764: 6706 beqs 4c76c <msdos_format+0x22a> <== ALWAYS TAKEN
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
4c766: 2d41 ff7a movel %d1,%fp@(-134) <== NOT EXECUTED
4c76a: 6018 bras 4c784 <msdos_format+0x242> <== NOT EXECUTED
}
else {
if (fmt_params->fattype == FAT_FAT16) {
4c76c: 7202 moveq #2,%d1
4c76e: b280 cmpl %d0,%d1
4c770: 660c bnes 4c77e <msdos_format+0x23c> <== ALWAYS TAKEN
fmt_params->files_per_root_dir = 512;
4c772: 283c 0000 0200 movel #512,%d4 <== NOT EXECUTED
4c778: 2d44 ff7a movel %d4,%fp@(-134) <== NOT EXECUTED
4c77c: 6006 bras 4c784 <msdos_format+0x242> <== NOT EXECUTED
}
else {
fmt_params->files_per_root_dir = 64;
4c77e: 7a40 moveq #64,%d5
4c780: 2d45 ff7a movel %d5,%fp@(-134)
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
4c784: 202e ff62 movel %fp@(-158),%d0
4c788: d080 addl %d0,%d0
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4c78a: 222e ff7a movel %fp@(-134),%d1
(2*fmt_params->bytes_per_sector/
4c78e: ea88 lsrl #5,%d0
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4c790: 5381 subql #1,%d1
4c792: d280 addl %d0,%d1
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
4c794: 2c01 movel %d1,%d6
4c796: 4c40 6004 remul %d0,%d4,%d6
4c79a: 9284 subl %d4,%d1
4c79c: 2d41 ff7a movel %d1,%fp@(-134)
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
4c7a0: 202e ff7a movel %fp@(-134),%d0
+ fmt_params->bytes_per_sector - 1)
4c7a4: 222e ff62 movel %fp@(-158),%d1
4c7a8: 2041 moveal %d1,%a0
4c7aa: 5388 subql #1,%a0
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4c7ac: 2a3c 0000 8000 movel #32768,%d5
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
4c7b2: eb88 lsll #5,%d0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
4c7b4: 2e2e ff66 movel %fp@(-154),%d7
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
4c7b8: d088 addl %a0,%d0
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
4c7ba: 9eae ff6a subl %fp@(-150),%d7
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
4c7be: 4c41 0000 remul %d1,%d0,%d0
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
4c7c2: 2d47 fd5c movel %d7,%fp@(-676)
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
4c7c6: 4284 clrl %d4
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
4c7c8: 91ae fd5c subl %d0,%fp@(-676)
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
4c7cc: 182e ff94 moveb %fp@(-108),%d4
fmt_params->bytes_per_sector,
fatdata_sect_cnt,
fmt_params->fat_num,
4c7d0: 1c2e ff92 moveb %fp@(-110),%d6
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
4c7d4: 2d40 ff7e movel %d0,%fp@(-130)
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
4c7d8: 202e ff6e movel %fp@(-146),%d0
4c7dc: 2d44 fd58 movel %d4,%fp@(-680)
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4c7e0: 4c41 5005 remul %d1,%d5,%d5
4c7e4: 6008 bras 4c7ee <msdos_format+0x2ac>
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
ret_val = EINVAL;
4c7e6: 7616 moveq #22,%d3 <== NOT EXECUTED
4c7e8: 6000 0110 braw 4c8fa <msdos_format+0x3b8> <== NOT EXECUTED
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
sectors_per_cluster /= 2;
4c7ec: e288 lsrl #1,%d0 <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4c7ee: b085 cmpl %d5,%d0
4c7f0: 62fa bhis 4c7ec <msdos_format+0x2aa> <== NEVER TAKEN
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
4c7f2: 0286 0000 00ff andil #255,%d6
4c7f8: 2246 moveal %d6,%a1
* compute number of data clusters for current data:
* - compute cluster count for data AND fat
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
4c7fa: 2a2e fd5c movel %fp@(-676),%d5
4c7fe: 4c40 5005 remul %d0,%d5,%d5
if (fattype == FAT_FAT12) {
4c802: 7801 moveq #1,%d4
4c804: b8ae fd58 cmpl %fp@(-680),%d4
4c808: 660c bnes 4c816 <msdos_format+0x2d4> <== NEVER TAKEN
fat_capacity = fatdata_cluster_cnt * 3 / 2;
4c80a: 2845 moveal %d5,%a4
4c80c: 49f4 5a00 lea %a4@(00000000,%d5:l:2),%a4
4c810: 280c movel %a4,%d4
4c812: e28c lsrl #1,%d4
4c814: 6012 bras 4c828 <msdos_format+0x2e6>
}
else if (fattype == FAT_FAT16) {
4c816: 7802 moveq #2,%d4 <== NOT EXECUTED
4c818: b8ae fd58 cmpl %fp@(-680),%d4 <== NOT EXECUTED
4c81c: 6606 bnes 4c824 <msdos_format+0x2e2> <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
4c81e: 2805 movel %d5,%d4 <== NOT EXECUTED
4c820: d884 addl %d4,%d4 <== NOT EXECUTED
4c822: 6004 bras 4c828 <msdos_format+0x2e6> <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
4c824: 2805 movel %d5,%d4 <== NOT EXECUTED
4c826: e58c lsll #2,%d4 <== NOT EXECUTED
}
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
4c828: d888 addl %a0,%d4
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
4c82a: 2e09 movel %a1,%d7
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
4c82c: 4c41 4004 remul %d1,%d4,%d4
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
4c830: 4c04 7800 mulsl %d4,%d7
4c834: 2847 moveal %d7,%a4
+ (sectors_per_cluster - 1))
4c836: 49f4 08ff lea %a4@(ffffffff,%d0:l),%a4
/ sectors_per_cluster));
4c83a: 2c0c movel %a4,%d6
4c83c: 4c40 6006 remul %d0,%d6,%d6
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
4c840: 9a86 subl %d6,%d5
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
4c842: 7c01 moveq #1,%d6
4c844: bcae fd58 cmpl %fp@(-680),%d6
4c848: 660a bnes 4c854 <msdos_format+0x312> <== NEVER TAKEN
4c84a: 0c85 0000 0ff5 cmpil #4085,%d5
4c850: 6212 bhis 4c864 <msdos_format+0x322> <== NEVER TAKEN
4c852: 6016 bras 4c86a <msdos_format+0x328>
4c854: 7e02 moveq #2,%d7 <== NOT EXECUTED
4c856: beae fd58 cmpl %fp@(-680),%d7 <== NOT EXECUTED
4c85a: 660e bnes 4c86a <msdos_format+0x328> <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
4c85c: 0c85 0000 fff5 cmpil #65525,%d5 <== NOT EXECUTED
4c862: 6306 blss 4c86a <msdos_format+0x328> <== NOT EXECUTED
sectors_per_cluster *= 2;
4c864: d080 addl %d0,%d0 <== NOT EXECUTED
4c866: 4205 clrb %d5 <== NOT EXECUTED
4c868: 6002 bras 4c86c <msdos_format+0x32a> <== NOT EXECUTED
}
else {
finished = true;
4c86a: 7a01 moveq #1,%d5
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
4c86c: 2c00 movel %d0,%d6
4c86e: 4c01 6800 mulsl %d1,%d6
4c872: 0c86 0000 8000 cmpil #32768,%d6
4c878: 620c bhis 4c886 <msdos_format+0x344> <== NEVER TAKEN
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
4c87a: 4a05 tstb %d5
4c87c: 6700 ff7c beqw 4c7fa <msdos_format+0x2b8>
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
}
else {
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = sectors_per_fat;
4c880: 2d44 ff72 movel %d4,%fp@(-142)
4c884: 6010 bras 4c896 <msdos_format+0x354>
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
4c886: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4c88c: 7816 moveq #22,%d4 <== NOT EXECUTED
4c88e: 76ff moveq #-1,%d3 <== NOT EXECUTED
4c890: 2040 moveal %d0,%a0 <== NOT EXECUTED
\*=========================================================================*/
{
int ret_val = 0;
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
4c892: 4280 clrl %d0 <== NOT EXECUTED
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
4c894: 2084 movel %d4,%a0@ <== NOT EXECUTED
fatdata_sect_cnt,
fmt_params->fat_num,
fmt_params->sectors_per_cluster,
§ors_per_cluster_adj,
&(fmt_params->sectors_per_fat));
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
4c896: 2d40 ff6e movel %d0,%fp@(-146)
}
/*
* determine media code
*/
if (ret_val == 0) {
4c89a: 4a83 tstl %d3
4c89c: 665a bnes 4c8f8 <msdos_format+0x3b6> <== NEVER TAKEN
if ((rqdata != NULL) &&
4c89e: 4a8a tstl %a2
4c8a0: 674e beqs 4c8f0 <msdos_format+0x3ae> <== NEVER TAKEN
(rqdata->media != 0)) {
4c8a2: 182a 0015 moveb %a2@(21),%d4
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4c8a6: 6748 beqs 4c8f0 <msdos_format+0x3ae> <== ALWAYS TAKEN
(rqdata->media != 0)) {
const char valid_media_codes[] =
4c8a8: 4878 0009 pea 9 <DIVIDE_BY_ZERO+0x1> <== NOT EXECUTED
4c8ac: 2a0e movel %fp,%d5 <== NOT EXECUTED
4c8ae: 4879 0006 788d pea 6788d <_CPU_m68k_BFFFO_table+0x21d> <== NOT EXECUTED
4c8b4: 0685 ffff fff6 addil #-10,%d5 <== NOT EXECUTED
4c8ba: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4c8bc: 4eb9 0005 87d8 jsr 587d8 <memcpy> <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
4c8c2: 4878 0009 pea 9 <DIVIDE_BY_ZERO+0x1> <== NOT EXECUTED
4c8c6: 4280 clrl %d0 <== NOT EXECUTED
4c8c8: 1004 moveb %d4,%d0 <== NOT EXECUTED
4c8ca: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c8cc: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4c8ce: 4eb9 0005 8684 jsr 58684 <memchr> <== NOT EXECUTED
4c8d4: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4c8d8: 4a80 tstl %d0 <== NOT EXECUTED
4c8da: 660e bnes 4c8ea <msdos_format+0x3a8> <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
4c8dc: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4c8e2: 7616 moveq #22,%d3 <== NOT EXECUTED
4c8e4: 2840 moveal %d0,%a4 <== NOT EXECUTED
4c8e6: 2883 movel %d3,%a4@ <== NOT EXECUTED
4c8e8: 600e bras 4c8f8 <msdos_format+0x3b6> <== NOT EXECUTED
}
else {
fmt_params->media_code = rqdata->media;
4c8ea: 1d44 ff93 moveb %d4,%fp@(-109) <== NOT EXECUTED
4c8ee: 600a bras 4c8fa <msdos_format+0x3b8> <== NOT EXECUTED
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4c8f0: 70f8 moveq #-8,%d0
4c8f2: 1d40 ff93 moveb %d0,%fp@(-109)
4c8f6: 6002 bras 4c8fa <msdos_format+0x3b8>
}
/*
* determine media code
*/
if (ret_val == 0) {
4c8f8: 76ff moveq #-1,%d3 <== NOT EXECUTED
4c8fa: 4280 clrl %d0
4c8fc: 102e ff92 moveb %fp@(-110),%d0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4c900: 222e ff7e movel %fp@(-130),%d1
4c904: 6716 beqs 4c91c <msdos_format+0x3da> <== NEVER TAKEN
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4c906: 41ee ff72 lea %fp@(-142),%a0
4c90a: 4c10 0800 mulsl %a0@,%d0
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
4c90e: 2d41 ff86 movel %d1,%fp@(-122)
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4c912: d0ae ff6a addl %fp@(-150),%d0
4c916: 2d40 ff82 movel %d0,%fp@(-126)
4c91a: 6016 bras 4c932 <msdos_format+0x3f0>
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4c91c: 49ee ff72 lea %fp@(-142),%a4 <== NOT EXECUTED
4c920: 4c14 0800 mulsl %a4@,%d0 <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4c924: 2d6e ff6e ff86 movel %fp@(-146),%fp@(-122) <== NOT EXECUTED
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4c92a: d0ae ff6a addl %fp@(-150),%d0 <== NOT EXECUTED
4c92e: 2d40 ff82 movel %d0,%fp@(-126) <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
4c932: 4a83 tstl %d3
4c934: 6600 00d4 bnew 4ca0a <msdos_format+0x4c8>
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
4c938: 41f9 0006 68b4 lea 668b4 <__func__.6026+0x2cc>,%a0
if ((rqdata != NULL) &&
4c93e: 4a8a tstl %a2
4c940: 670c beqs 4c94e <msdos_format+0x40c> <== NEVER TAKEN
(rqdata->OEMName != NULL)) {
4c942: 2052 moveal %a2@,%a0
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
4c944: 4a88 tstl %a0
4c946: 6606 bnes 4c94e <msdos_format+0x40c> <== ALWAYS TAKEN
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
4c948: 41f9 0006 68b4 lea 668b4 <__func__.6026+0x2cc>,%a0 <== NOT EXECUTED
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4c94e: 2a79 0006 8a34 moveal 68a34 <__ctype_ptr__>,%a5
4c954: 7009 moveq #9,%d0
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
4c956: 43ee ff95 lea %fp@(-107),%a1
4c95a: 6028 bras 4c984 <msdos_format+0x442>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4c95c: 4281 clrl %d1
4c95e: 49e9 0001 lea %a1@(1),%a4
4c962: 1610 moveb %a0@,%d3
4c964: 1203 moveb %d3,%d1
4c966: 1235 1801 moveb %a5@(00000001,%d1:l),%d1
4c96a: 49c1 extbl %d1
4c96c: 0281 0000 0097 andil #151,%d1
4c972: 6708 beqs 4c97c <msdos_format+0x43a>
*to++ = *from++;
4c974: 5288 addql #1,%a0
4c976: 1283 moveb %d3,%a1@
4c978: 224c moveal %a4,%a1
4c97a: 6006 bras 4c982 <msdos_format+0x440>
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4c97c: 12bc 0020 moveb #32,%a1@
4c980: 224c moveal %a4,%a1
}
*to = '\0';
4c982: 4214 clrb %a4@
4c984: 5380 subql #1,%d0
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
4c986: 66d4 bnes 4c95c <msdos_format+0x41a>
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
4c988: 41f9 0006 75d1 lea 675d1 <rtems_filesystem_default_pathconf+0xab>,%a0
if ((rqdata != NULL) &&
4c98e: 4a8a tstl %a2
4c990: 6716 beqs 4c9a8 <msdos_format+0x466> <== NEVER TAKEN
(rqdata->VolLabel != NULL)) {
4c992: 206a 0004 moveal %a2@(4),%a0
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
4c996: 4a88 tstl %a0
4c998: 6708 beqs 4c9a2 <msdos_format+0x460> <== NEVER TAKEN
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
4c99a: 7001 moveq #1,%d0
4c99c: 1d40 ffaa moveb %d0,%fp@(-86)
4c9a0: 6006 bras 4c9a8 <msdos_format+0x466>
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
4c9a2: 41f9 0006 75d1 lea 675d1 <rtems_filesystem_default_pathconf+0xab>,%a0<== NOT EXECUTED
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4c9a8: 2a79 0006 8a34 moveal 68a34 <__ctype_ptr__>,%a5
4c9ae: 700c moveq #12,%d0
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
4c9b0: 43ee ff9e lea %fp@(-98),%a1
4c9b4: 6028 bras 4c9de <msdos_format+0x49c>
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4c9b6: 4281 clrl %d1
4c9b8: 49e9 0001 lea %a1@(1),%a4
4c9bc: 1610 moveb %a0@,%d3
4c9be: 1203 moveb %d3,%d1
4c9c0: 1235 1801 moveb %a5@(00000001,%d1:l),%d1
4c9c4: 49c1 extbl %d1
4c9c6: 0281 0000 0097 andil #151,%d1
4c9cc: 6708 beqs 4c9d6 <msdos_format+0x494>
*to++ = *from++;
4c9ce: 5288 addql #1,%a0
4c9d0: 1283 moveb %d3,%a1@
4c9d2: 224c moveal %a4,%a1
4c9d4: 6006 bras 4c9dc <msdos_format+0x49a>
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4c9d6: 12bc 0020 moveb #32,%a1@
4c9da: 224c moveal %a4,%a1
}
*to = '\0';
4c9dc: 4214 clrb %a4@
4c9de: 5380 subql #1,%d0
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
4c9e0: 66d4 bnes 4c9b6 <msdos_format+0x474>
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
4c9e2: 486e fff6 pea %fp@(-10)
4c9e6: 4eb9 0005 26d0 jsr 526d0 <rtems_clock_get_tod_timeval>
if (rc == RTEMS_SUCCESSFUL) {
4c9ec: 588f addql #4,%sp
4c9ee: 4a80 tstl %d0
4c9f0: 6608 bnes 4c9fa <msdos_format+0x4b8> <== ALWAYS TAKEN
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
4c9f2: 202e fff6 movel %fp@(-10),%d0 <== NOT EXECUTED
4c9f6: d080 addl %d0,%d0 <== NOT EXECUTED
4c9f8: 6006 bras 4ca00 <msdos_format+0x4be> <== NOT EXECUTED
}
else {
*volid_ptr = rand();
4c9fa: 4eb9 0005 890c jsr 5890c <rand>
4ca00: 2d40 ffac movel %d0,%fp@(-84)
ret_val = msdos_format_determine_fmt_params(dd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
4ca04: 4a8a tstl %a2
4ca06: 660e bnes 4ca16 <msdos_format+0x4d4> <== ALWAYS TAKEN
4ca08: 6034 bras 4ca3e <msdos_format+0x4fc> <== NOT EXECUTED
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
4ca0a: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4ca10: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ca12: 2083 movel %d3,%a0@ <== NOT EXECUTED
4ca14: 606c bras 4ca82 <msdos_format+0x540> <== NOT EXECUTED
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
4ca16: 4a2a 0016 tstb %a2@(22)
4ca1a: 6622 bnes 4ca3e <msdos_format+0x4fc> <== NEVER TAKEN
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
4ca1c: 4878 ffe5 pea ffffffe5 <DBL_MIN_EXP+0x3e2>
4ca20: 2f2e ff62 movel %fp@(-158),%sp@-
4ca24: 2f2e ff66 movel %fp@(-154),%sp@-
4ca28: 42a7 clrl %sp@-
4ca2a: 2f02 movel %d2,%sp@-
4ca2c: 2f0a movel %a2,%sp@-
4ca2e: 4eba f9f8 jsr %pc@(4c428 <msdos_format_fill_sectors>)
}
/*
* create master boot record
*/
if (ret_val == 0) {
4ca32: 4fef 0018 lea %sp@(24),%sp
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
4ca36: 2840 moveal %d0,%a4
}
/*
* create master boot record
*/
if (ret_val == 0) {
4ca38: 4a80 tstl %d0
4ca3a: 6600 0472 bnew 4ceae <msdos_format+0x96c>
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4ca3e: 4879 0006 7803 pea 67803 <_CPU_m68k_BFFFO_table+0x193>
4ca44: 49fa f936 lea %pc@(4c37c <msdos_format_printf>),%a4
4ca48: 4878 0002 pea 2 <DOUBLE_FLOAT>
4ca4c: 2f0a movel %a2,%sp@-
4ca4e: 4e94 jsr %a4@
"read MRB sector\n");
ret_val = msdos_format_read_sec(fd,
4ca50: 262e ff62 movel %fp@(-158),%d3
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4ca54: 42a7 clrl %sp@-
4ca56: 42a7 clrl %sp@-
4ca58: 42a7 clrl %sp@-
4ca5a: 2f02 movel %d2,%sp@-
4ca5c: 4eb9 0004 58b0 jsr 458b0 <lseek>
4ca62: 4fef 001c lea %sp@(28),%sp
4ca66: 4a80 tstl %d0
4ca68: 6b18 bmis 4ca82 <msdos_format+0x540> <== NEVER TAKEN
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
4ca6a: 2f03 movel %d3,%sp@-
4ca6c: 486e fd62 pea %fp@(-670)
4ca70: 2f02 movel %d2,%sp@-
4ca72: 4eb9 0004 6690 jsr 46690 <read>
4ca78: 4fef 000c lea %sp@(12),%sp
4ca7c: 4a80 tstl %d0
4ca7e: 6c00 04be bgew 4cf3e <msdos_format+0x9fc>
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
4ca82: 387c ffff moveaw #-1,%a4 <== NOT EXECUTED
4ca86: 6000 0426 braw 4ceae <msdos_format+0x96c> <== NOT EXECUTED
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
4ca8a: 2a04 movel %d4,%d5 <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
4ca8c: 4284 clrl %d4 <== NOT EXECUTED
4ca8e: 6002 bras 4ca92 <msdos_format+0x550> <== NOT EXECUTED
uint32_t total_sectors_num32 = 0;
4ca90: 4285 clrl %d5
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4ca92: 4878 01be pea 1be <DBL_MANT_DIG+0x189>
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"generate MRB sector\n");
ret_val = msdos_format_gen_mbr(tmp_sec,&fmt_params);
4ca96: 49ee fd62 lea %fp@(-670),%a4
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4ca9a: 4bf9 0005 8848 lea 58848 <memset>,%a5
4caa0: 42a7 clrl %sp@-
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
4caa2: 7c06 moveq #6,%d6
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4caa4: 2f0c movel %a4,%sp@-
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4caa6: 7e01 moveq #1,%d7
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4caa8: 4e95 jsr %a5@
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4caaa: 296e ff99 0007 movel %fp@(-103),%a4@(7)
4cab0: 41ec 0003 lea %a4@(3),%a0
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
4cab4: 4fef 000c lea %sp@(12),%sp
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
4cab8: 4240 clrw %d0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4caba: 20ae ff95 movel %fp@(-107),%a0@
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
4cabe: 3d40 ff60 movew %d0,%fp@(-160)
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
4cac2: 2003 movel %d3,%d0
4cac4: e088 lsrl #8,%d0
4cac6: 1d40 fd6e moveb %d0,%fp@(-658)
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
4caca: 202e ff6a movel %fp@(-150),%d0
4cace: 1d40 fd70 moveb %d0,%fp@(-656)
4cad2: e088 lsrl #8,%d0
4cad4: 1d40 fd71 moveb %d0,%fp@(-655)
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4cad8: 202e ff7a movel %fp@(-134),%d0
4cadc: 1d40 fd73 moveb %d0,%fp@(-653)
4cae0: e088 lsrl #8,%d0
4cae2: 1d40 fd74 moveb %d0,%fp@(-652)
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cae6: 2005 movel %d5,%d0
4cae8: e088 lsrl #8,%d0
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4caea: 1d44 fd75 moveb %d4,%fp@(-651)
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4caee: 1d40 fd83 moveb %d0,%fp@(-637)
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4caf2: e08c lsrl #8,%d4
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4caf4: 2005 movel %d5,%d0
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4caf6: 1d44 fd76 moveb %d4,%fp@(-650)
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cafa: 4240 clrw %d0
4cafc: 4840 swap %d0
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4cafe: 50c4 st %d4
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
4cb00: 7202 moveq #2,%d1
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cb02: 1d40 fd84 moveb %d0,%fp@(-636)
4cb06: 7018 moveq #24,%d0
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4cb08: 1d44 fd7a moveb %d4,%fp@(-646)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cb0c: 1d45 fd82 moveb %d5,%fp@(-638)
4cb10: e0ad lsrl %d0,%d5
if (fmt_params->fattype != FAT_FAT32) {
4cb12: 4284 clrl %d4
4cb14: 182e ff94 moveb %fp@(-108),%d4
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
4cb18: 1d41 fd72 moveb %d1,%fp@(-654)
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
4cb1c: 1d43 fd6d moveb %d3,%fp@(-659)
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4cb20: 1d6e ff71 fd6f moveb %fp@(-143),%fp@(-657)
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
4cb26: 1d6e ff93 fd77 moveb %fp@(-109),%fp@(-649)
4cb2c: 202e ff72 movel %fp@(-142),%d0
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
4cb30: 7204 moveq #4,%d1
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
4cb32: 1d46 fd7c moveb %d6,%fp@(-644)
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4cb36: 1d47 fd7e moveb %d7,%fp@(-642)
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4cb3a: 1d45 fd85 moveb %d5,%fp@(-635)
if (fmt_params->fattype != FAT_FAT32) {
4cb3e: b284 cmpl %d4,%d1
4cb40: 6766 beqs 4cba8 <msdos_format+0x666> <== NEVER TAKEN
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4cb42: 4878 000b pea b <LASTO+0x1>
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4cb46: 7c18 moveq #24,%d6
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4cb48: 486e ff9e pea %fp@(-98)
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4cb4c: 7e01 moveq #1,%d7
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4cb4e: 486c 002b pea %a4@(43)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
4cb52: 1d40 fd78 moveb %d0,%fp@(-648)
4cb56: e088 lsrl #8,%d0
4cb58: 1d40 fd79 moveb %d0,%fp@(-647)
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4cb5c: 202e ffac movel %fp@(-84),%d0
4cb60: 2200 movel %d0,%d1
4cb62: e089 lsrl #8,%d1
4cb64: 1d41 fd8a moveb %d1,%fp@(-630)
4cb68: 2200 movel %d0,%d1
4cb6a: 1d40 fd89 moveb %d0,%fp@(-631)
4cb6e: 4241 clrw %d1
4cb70: 4841 swap %d1
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
4cb72: 7a29 moveq #41,%d5
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4cb74: eca8 lsrl %d6,%d0
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
4cb76: 1d45 fd88 moveb %d5,%fp@(-632)
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
4cb7a: 1d41 fd8b moveb %d1,%fp@(-629)
4cb7e: 1d40 fd8c moveb %d0,%fp@(-628)
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4cb82: 4eb9 0005 87d8 jsr 587d8 <memcpy>
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4cb88: 4fef 000c lea %sp@(12),%sp
4cb8c: 41f9 0006 77a1 lea 677a1 <_CPU_m68k_BFFFO_table+0x131>,%a0
4cb92: be84 cmpl %d4,%d7
4cb94: 6606 bnes 4cb9c <msdos_format+0x65a> <== NEVER TAKEN
4cb96: 41f9 0006 7798 lea 67798 <_CPU_m68k_BFFFO_table+0x128>,%a0
4cb9c: 2d50 fd98 movel %a0@,%fp@(-616)
4cba0: 2d68 0004 fd9c movel %a0@(4),%fp@(-612)
4cba6: 606e bras 4cc16 <msdos_format+0x6d4>
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4cba8: 2200 movel %d0,%d1 <== NOT EXECUTED
4cbaa: e089 lsrl #8,%d1 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4cbac: 4878 000c pea c <OPER1> <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4cbb0: 2e3c 3220 2020 movel #840966176,%d7 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4cbb6: 1d41 fd87 moveb %d1,%fp@(-633) <== NOT EXECUTED
4cbba: 2200 movel %d0,%d1 <== NOT EXECUTED
4cbbc: 4241 clrw %d1 <== NOT EXECUTED
4cbbe: 4841 swap %d1 <== NOT EXECUTED
4cbc0: 1d40 fd86 moveb %d0,%fp@(-634) <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4cbc4: 42a7 clrl %sp@- <== NOT EXECUTED
4cbc6: 486c 0034 pea %a4@(52) <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4cbca: 1d41 fd88 moveb %d1,%fp@(-632) <== NOT EXECUTED
4cbce: 7218 moveq #24,%d1 <== NOT EXECUTED
4cbd0: e2a8 lsrl %d1,%d0 <== NOT EXECUTED
4cbd2: 1d40 fd89 moveb %d0,%fp@(-631) <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4cbd6: 202e ff8a movel %fp@(-118),%d0 <== NOT EXECUTED
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
4cbda: 7802 moveq #2,%d4 <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4cbdc: 1d40 fd94 moveb %d0,%fp@(-620) <== NOT EXECUTED
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
4cbe0: 7a01 moveq #1,%d5 <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4cbe2: e088 lsrl #8,%d0 <== NOT EXECUTED
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
4cbe4: 1d44 fd8e moveb %d4,%fp@(-626) <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
4cbe8: 1d45 fd92 moveb %d5,%fp@(-622) <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4cbec: 1d40 fd95 moveb %d0,%fp@(-619) <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
4cbf0: 7c29 moveq #41,%d6 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4cbf2: 4e95 jsr %a5@ <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
4cbf4: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
4cbf8: 42a7 clrl %sp@- <== NOT EXECUTED
4cbfa: 486c 0047 pea %a4@(71) <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4cbfe: 49ec 0052 lea %a4@(82),%a4 <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
4cc02: 1d46 fda4 moveb %d6,%fp@(-604) <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
4cc06: 4e95 jsr %a5@ <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4cc08: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4cc0c: 28bc 4641 5433 movel #1178686515,%a4@ <== NOT EXECUTED
4cc12: 2947 0004 movel %d7,%a4@(4) <== NOT EXECUTED
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cc16: 4879 0006 7814 pea 67814 <_CPU_m68k_BFFFO_table+0x1a4>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cc1c: 4bfa f7a4 lea %pc@(4c3c2 <msdos_format_write_sec>),%a5
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cc20: 4878 0002 pea 2 <DOUBLE_FLOAT>
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
4cc24: 7a3c moveq #60,%d5
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
4cc26: 7055 moveq #85,%d0
4cc28: 72aa moveq #-86,%d1
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
4cc2a: 78eb moveq #-21,%d4
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cc2c: 2f0a movel %a2,%sp@-
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
FAT_SET_VAL8(mbr,2,0x90);
4cc2e: 7c90 moveq #-112,%d6
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
4cc30: 1d45 fd63 moveb %d5,%fp@(-669)
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
4cc34: 1d40 ff60 moveb %d0,%fp@(-160)
4cc38: 1d41 ff61 moveb %d1,%fp@(-159)
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
4cc3c: 1d44 fd62 moveb %d4,%fp@(-670)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
4cc40: 280e movel %fp,%d4
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cc42: 2a3c 0004 c37c movel #312188,%d5
4cc48: 2045 moveal %d5,%a0
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
4cc4a: 0684 ffff fd62 addil #-670,%d4
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
FAT_SET_VAL8(mbr,2,0x90);
4cc50: 1d46 fd64 moveb %d6,%fp@(-668)
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cc54: 4e90 jsr %a0@
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cc56: 2f04 movel %d4,%sp@-
4cc58: 2f03 movel %d3,%sp@-
4cc5a: 42a7 clrl %sp@-
4cc5c: 2f02 movel %d2,%sp@-
4cc5e: 4e95 jsr %a5@
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4cc60: 4fef 001c lea %sp@(28),%sp
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cc64: 2840 moveal %d0,%a4
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4cc66: 4a80 tstl %d0
4cc68: 6600 0244 bnew 4ceae <msdos_format+0x96c>
(fmt_params.mbr_copy_sec != 0)) {
4cc6c: 2c2e ff8a movel %fp@(-118),%d6
ret_val = msdos_format_write_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4cc70: 6726 beqs 4cc98 <msdos_format+0x756> <== ALWAYS TAKEN
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cc72: 4879 0006 7826 pea 67826 <_CPU_m68k_BFFFO_table+0x1b6> <== NOT EXECUTED
4cc78: 2845 moveal %d5,%a4 <== NOT EXECUTED
4cc7a: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
4cc7e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4cc80: 4e94 jsr %a4@ <== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cc82: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cc84: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4cc86: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cc88: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cc8a: 4e95 jsr %a5@ <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4cc8c: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4cc90: 2840 moveal %d0,%a4 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4cc92: 4a80 tstl %d0 <== NOT EXECUTED
4cc94: 6600 0218 bnew 4ceae <msdos_format+0x96c> <== NOT EXECUTED
(fmt_params.fsinfo_sec != 0)) {
4cc98: 282e ff8e movel %fp@(-114),%d4
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4cc9c: 6700 0086 beqw 4cd24 <msdos_format+0x7e2>
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4cca0: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb> <== NOT EXECUTED
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_gen_fsinfo(tmp_sec);
4cca4: 2a0e movel %fp,%d5 <== NOT EXECUTED
4cca6: 0685 ffff fd62 addil #-670,%d5 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4ccac: 42a7 clrl %sp@- <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4ccae: 7c41 moveq #65,%d6 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4ccb0: 2f05 movel %d5,%sp@- <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4ccb2: 7e72 moveq #114,%d7 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4ccb4: 4eb9 0005 8848 jsr 58848 <memset> <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4ccba: 7052 moveq #82,%d0 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4ccbc: 2f05 movel %d5,%sp@- <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4ccbe: 7261 moveq #97,%d1 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4ccc0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4ccc2: 1d40 fd62 moveb %d0,%fp@(-670) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4ccc6: 2f04 movel %d4,%sp@- <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4ccc8: 1d40 fd63 moveb %d0,%fp@(-669) <== NOT EXECUTED
4cccc: 1d41 fd64 moveb %d1,%fp@(-668) <== NOT EXECUTED
4ccd0: 1d46 fd65 moveb %d6,%fp@(-667) <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4ccd4: 1d46 ff48 moveb %d6,%fp@(-184) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4ccd8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4ccda: 1d41 ff49 moveb %d1,%fp@(-183) <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
4ccde: 50c6 st %d6 <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4cce0: 7055 moveq #85,%d0 <== NOT EXECUTED
4cce2: 72aa moveq #-86,%d1 <== NOT EXECUTED
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4cce4: 1d47 ff46 moveb %d7,%fp@(-186) <== NOT EXECUTED
4cce8: 1d47 ff47 moveb %d7,%fp@(-185) <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4ccec: 1d40 ff60 moveb %d0,%fp@(-160) <== NOT EXECUTED
4ccf0: 1d41 ff61 moveb %d1,%fp@(-159) <== NOT EXECUTED
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
4ccf4: 1d46 ff4a moveb %d6,%fp@(-182) <== NOT EXECUTED
4ccf8: 1d46 ff4b moveb %d6,%fp@(-181) <== NOT EXECUTED
4ccfc: 1d46 ff4c moveb %d6,%fp@(-180) <== NOT EXECUTED
4cd00: 1d46 ff4d moveb %d6,%fp@(-179) <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
4cd04: 1d46 ff4e moveb %d6,%fp@(-178) <== NOT EXECUTED
4cd08: 1d46 ff4f moveb %d6,%fp@(-177) <== NOT EXECUTED
4cd0c: 1d46 ff50 moveb %d6,%fp@(-176) <== NOT EXECUTED
4cd10: 1d46 ff51 moveb %d6,%fp@(-175) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4cd14: 4eba f6ac jsr %pc@(4c3c2 <msdos_format_write_sec>) <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
4cd18: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4cd1c: 2840 moveal %d0,%a4 <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
4cd1e: 4a80 tstl %d0 <== NOT EXECUTED
4cd20: 6600 018c bnew 4ceae <msdos_format+0x96c> <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
4cd24: 42a7 clrl %sp@-
4cd26: 2e2e ff72 movel %fp@(-142),%d7
(rqdata,
4cd2a: 4280 clrl %d0
fd,
fmt_params.rsvd_sector_cnt, /* start sector */
fmt_params.fat_num*fmt_params.sectors_per_fat,/* sector count */
4cd2c: 1a2e ff92 moveb %fp@(-110),%d5
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4cd30: 2f03 movel %d3,%sp@-
4cd32: 283c 0004 c428 movel #312360,%d4
(rqdata,
4cd38: 1005 moveb %d5,%d0
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4cd3a: 4c00 7800 mulsl %d0,%d7
4cd3e: 2044 moveal %d4,%a0
4cd40: 2f07 movel %d7,%sp@-
4cd42: 2f2e ff6a movel %fp@(-150),%sp@-
4cd46: 2f02 movel %d2,%sp@-
4cd48: 2f0a movel %a2,%sp@-
4cd4a: 4e90 jsr %a0@
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
4cd4c: 4fef 0018 lea %sp@(24),%sp
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4cd50: 2840 moveal %d0,%a4
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
4cd52: 4a80 tstl %d0
4cd54: 6600 0158 bnew 4ceae <msdos_format+0x96c>
ret_val = msdos_format_fill_sectors
4cd58: 42a7 clrl %sp@-
(rqdata,
4cd5a: 2a6e ff82 moveal %fp@(-126),%a5
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4cd5e: 2844 moveal %d4,%a4
4cd60: 2f03 movel %d3,%sp@-
4cd62: 2f2e ff86 movel %fp@(-122),%sp@-
4cd66: 2f0d movel %a5,%sp@-
4cd68: 2f02 movel %d2,%sp@-
4cd6a: 2f0a movel %a2,%sp@-
4cd6c: 4e94 jsr %a4@
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
4cd6e: 4fef 0018 lea %sp@(24),%sp
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4cd72: 2840 moveal %d0,%a4
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
4cd74: 4a80 tstl %d0
4cd76: 6600 0136 bnew 4ceae <msdos_format+0x96c>
4cd7a: 4a2e ffaa tstb %fp@(-86)
4cd7e: 6700 012e beqw 4ceae <msdos_format+0x96c>
memset(tmp_sec,0,sizeof(tmp_sec));
4cd82: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
4cd86: 280e movel %fp,%d4
4cd88: 0684 ffff fd62 addil #-670,%d4
4cd8e: 45f9 0005 8848 lea 58848 <memset>,%a2
4cd94: 42a7 clrl %sp@-
4cd96: 2f04 movel %d4,%sp@-
4cd98: 4e92 jsr %a2@
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
4cd9a: 4878 000b pea b <LASTO+0x1>
4cd9e: 486e ff9e pea %fp@(-98)
4cda2: 2f04 movel %d4,%sp@-
4cda4: 4eb9 0005 87d8 jsr 587d8 <memcpy>
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
4cdaa: 7008 moveq #8,%d0
ret_val = msdos_format_write_sec
4cdac: 2f04 movel %d4,%sp@-
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
4cdae: 1d40 fd6d moveb %d0,%fp@(-659)
ret_val = msdos_format_write_sec
4cdb2: 2f03 movel %d3,%sp@-
4cdb4: 2f0d movel %a5,%sp@-
4cdb6: 2f02 movel %d2,%sp@-
4cdb8: 4eba f608 jsr %pc@(4c3c2 <msdos_format_write_sec>)
/*
* write FAT entry 0 as (0xffffff00|Media_type)EOC,
* write FAT entry 1 as EOC
* allocate directory in a FAT32 FS
*/
if ((ret_val == 0) && fmt_params.VolLabel_present){
4cdbc: 4fef 0028 lea %sp@(40),%sp
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
4cdc0: 2840 moveal %d0,%a4
/*
* write FAT entry 0 as (0xffffff00|Media_type)EOC,
* write FAT entry 1 as EOC
* allocate directory in a FAT32 FS
*/
if ((ret_val == 0) && fmt_params.VolLabel_present){
4cdc2: 4a80 tstl %d0
4cdc4: 6600 00e8 bnew 4ceae <msdos_format+0x96c>
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
4cdc8: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
switch(fmt_params.fattype) {
4cdcc: 4283 clrl %d3
*/
if ((ret_val == 0) && fmt_params.VolLabel_present){
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
4cdce: 42a7 clrl %sp@-
4cdd0: 2f04 movel %d4,%sp@-
4cdd2: 4e92 jsr %a2@
switch(fmt_params.fattype) {
4cdd4: 4fef 000c lea %sp@(12),%sp
4cdd8: 162e ff94 moveb %fp@(-108),%d3
4cddc: 7202 moveq #2,%d1
4cdde: b283 cmpl %d3,%d1
4cde0: 6720 beqs 4ce02 <msdos_format+0x8c0> <== NEVER TAKEN
4cde2: 7804 moveq #4,%d4
4cde4: b883 cmpl %d3,%d4
4cde6: 6732 beqs 4ce1a <msdos_format+0x8d8> <== NEVER TAKEN
4cde8: 7c01 moveq #1,%d6
4cdea: bc83 cmpl %d3,%d6
4cdec: 6656 bnes 4ce44 <msdos_format+0x902> <== NEVER TAKEN
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
/* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
4cdee: 7e8f moveq #-113,%d7
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
4cdf0: 50c0 st %d0
memset(tmp_sec,0,sizeof(tmp_sec));
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
4cdf2: 1d6e ff93 fd62 moveb %fp@(-109),%fp@(-670)
/* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
4cdf8: 1d47 fd63 moveb %d7,%fp@(-669)
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
4cdfc: 1d40 fd64 moveb %d0,%fp@(-668)
break;
4ce00: 606e bras 4ce70 <msdos_format+0x92e>
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
FAT_SET_VAL8(tmp_sec,1,0xff);
4ce02: 50c1 st %d1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
4ce04: 76f8 moveq #-8,%d3 <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
4ce06: 1d6e ff93 fd62 moveb %fp@(-109),%fp@(-670) <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
4ce0c: 1d41 fd63 moveb %d1,%fp@(-669) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
4ce10: 1d43 fd64 moveb %d3,%fp@(-668) <== NOT EXECUTED
4ce14: 1d41 fd65 moveb %d1,%fp@(-667) <== NOT EXECUTED
break;
4ce18: 6056 bras 4ce70 <msdos_format+0x92e> <== NOT EXECUTED
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
4ce1a: 50c4 st %d4 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4ce1c: 7cf8 moveq #-8,%d6 <== NOT EXECUTED
4ce1e: 7e0f moveq #15,%d7 <== NOT EXECUTED
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
4ce20: 1d6e ff93 fd62 moveb %fp@(-109),%fp@(-670) <== NOT EXECUTED
4ce26: 1d44 fd63 moveb %d4,%fp@(-669) <== NOT EXECUTED
4ce2a: 1d44 fd64 moveb %d4,%fp@(-668) <== NOT EXECUTED
4ce2e: 1d44 fd65 moveb %d4,%fp@(-667) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4ce32: 1d46 fd66 moveb %d6,%fp@(-666) <== NOT EXECUTED
4ce36: 1d44 fd67 moveb %d4,%fp@(-665) <== NOT EXECUTED
4ce3a: 1d44 fd68 moveb %d4,%fp@(-664) <== NOT EXECUTED
4ce3e: 1d47 fd69 moveb %d7,%fp@(-663) <== NOT EXECUTED
4ce42: 6016 bras 4ce5a <msdos_format+0x918> <== NOT EXECUTED
break;
default:
ret_val = -1;
errno = EINVAL;
4ce44: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
4ce4a: 387c ffff moveaw #-1,%a4 <== NOT EXECUTED
errno = EINVAL;
4ce4e: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ce50: 7216 moveq #22,%d1 <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
4ce52: 7004 moveq #4,%d0 <== NOT EXECUTED
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
errno = EINVAL;
4ce54: 2081 movel %d1,%a0@ <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
4ce56: b083 cmpl %d3,%d0 <== NOT EXECUTED
4ce58: 6616 bnes 4ce70 <msdos_format+0x92e> <== NOT EXECUTED
/*
* only first valid cluster (cluster number 2) belongs
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
4ce5a: 50c3 st %d3 <== NOT EXECUTED
4ce5c: 72f8 moveq #-8,%d1 <== NOT EXECUTED
4ce5e: 780f moveq #15,%d4 <== NOT EXECUTED
4ce60: 1d41 fd6a moveb %d1,%fp@(-662) <== NOT EXECUTED
4ce64: 1d43 fd6b moveb %d3,%fp@(-661) <== NOT EXECUTED
4ce68: 1d43 fd6c moveb %d3,%fp@(-660) <== NOT EXECUTED
4ce6c: 1d44 fd6d moveb %d4,%fp@(-659) <== NOT EXECUTED
ret_val = msdos_format_write_sec
(fd,
fmt_params.rsvd_sector_cnt
+ (i * fmt_params.sectors_per_fat),
fmt_params.bytes_per_sector,
tmp_sec);
4ce70: 280e movel %fp,%d4
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
4ce72: 4283 clrl %d3
ret_val = msdos_format_write_sec
(fd,
fmt_params.rsvd_sector_cnt
+ (i * fmt_params.sectors_per_fat),
fmt_params.bytes_per_sector,
tmp_sec);
4ce74: 0684 ffff fd62 addil #-670,%d4
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
4ce7a: 45fa f546 lea %pc@(4c3c2 <msdos_format_write_sec>),%a2
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
4ce7e: 0285 0000 00ff andil #255,%d5
4ce84: 6020 bras 4cea6 <msdos_format+0x964>
i++) {
ret_val = msdos_format_write_sec
(fd,
fmt_params.rsvd_sector_cnt
+ (i * fmt_params.sectors_per_fat),
4ce86: 202e ff72 movel %fp@(-142),%d0
4ce8a: 4c03 0800 mulsl %d3,%d0
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
4ce8e: 5283 addql #1,%d3
ret_val = msdos_format_write_sec
4ce90: 2f04 movel %d4,%sp@-
4ce92: 2f2e ff62 movel %fp@(-158),%sp@-
4ce96: d0ae ff6a addl %fp@(-150),%d0
4ce9a: 2f00 movel %d0,%sp@-
4ce9c: 2f02 movel %d2,%sp@-
4ce9e: 4e92 jsr %a2@
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
4cea0: 4fef 0010 lea %sp@(16),%sp
ret_val = msdos_format_write_sec
4cea4: 2840 moveal %d0,%a4
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
4cea6: ba83 cmpl %d3,%d5
4cea8: 6f04 bles 4ceae <msdos_format+0x96c>
(i < fmt_params.fat_num) && (ret_val == 0);
4ceaa: 4a8c tstl %a4
4ceac: 67d8 beqs 4ce86 <msdos_format+0x944> <== ALWAYS TAKEN
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
4ceae: 7aff moveq #-1,%d5
4ceb0: ba82 cmpl %d2,%d5
4ceb2: 670a beqs 4cebe <msdos_format+0x97c> <== NEVER TAKEN
close(fd);
4ceb4: 2f02 movel %d2,%sp@-
4ceb6: 4eb9 0004 4ffc jsr 44ffc <close>
4cebc: 588f addql #4,%sp
}
if (dd != NULL) {
4cebe: 4a8b tstl %a3
4cec0: 670a beqs 4cecc <msdos_format+0x98a> <== NEVER TAKEN
rtems_disk_release(dd);
4cec2: 2f0b movel %a3,%sp@-
4cec4: 4eb9 0004 4522 jsr 44522 <rtems_disk_release>
4ceca: 588f addql #4,%sp
}
return ret_val;
}
4cecc: 200c movel %a4,%d0
4cece: 4cee 3cfc fd30 moveml %fp@(-720),%d2-%d7/%a2-%a5
4ced4: 4e5e unlk %fp
4ced6: 4e75 rts
ret_val = -1;
}
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
4ced8: 2f2e ffca movel %fp@(-54),%sp@-
4cedc: 2f2e ffc6 movel %fp@(-58),%sp@-
4cee0: 4eb9 0004 44ba jsr 444ba <rtems_disk_obtain>
if (dd == NULL) {
4cee6: 508f addql #8,%sp
ret_val = -1;
}
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
4cee8: 2640 moveal %d0,%a3
if (dd == NULL) {
4ceea: 4a80 tstl %d0
4ceec: 6700 f6fc beqw 4c5ea <msdos_format+0xa8>
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
uint64_t total_size = 0;
memset(fmt_params,0,sizeof(*fmt_params));
4cef0: 4878 004e pea 4e <DBL_MANT_DIG+0x19>
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
4cef4: 4284 clrl %d4
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
uint64_t total_size = 0;
memset(fmt_params,0,sizeof(*fmt_params));
4cef6: 42a7 clrl %sp@-
4cef8: 486e ff62 pea %fp@(-158)
4cefc: 4eb9 0005 8848 jsr 58848 <memset>
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
4cf02: 262b 001c movel %a3@(28),%d3
total_size = dd->block_size * dd->size;
4cf06: 2203 movel %d3,%d1
/*
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
4cf08: 202b 0020 movel %a3@(32),%d0
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
4cf0c: 4c00 1800 mulsl %d0,%d1
/*
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
4cf10: 2d40 ff62 movel %d0,%fp@(-158)
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
4cf14: 2a01 movel %d1,%d5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cf16: 2f01 movel %d1,%sp@-
4cf18: 2f04 movel %d4,%sp@-
4cf1a: 2f03 movel %d3,%sp@-
4cf1c: 2f00 movel %d0,%sp@-
4cf1e: 4879 0006 7840 pea 67840 <_CPU_m68k_BFFFO_table+0x1d0>
4cf24: 4878 0002 pea 2 <DOUBLE_FLOAT>
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
4cf28: 2d43 ff66 movel %d3,%fp@(-154)
total_size = dd->block_size * dd->size;
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cf2c: 2f0a movel %a2,%sp@-
4cf2e: 4e95 jsr %a5@
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4cf30: 4fef 0028 lea %sp@(40),%sp
4cf34: 4a8a tstl %a2
4cf36: 6600 f6c8 bnew 4c600 <msdos_format+0xbe>
4cf3a: 6000 f6ca braw 4c606 <msdos_format+0xc4> <== NOT EXECUTED
ret_val = msdos_format_read_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4cf3e: 4879 0006 7878 pea 67878 <_CPU_m68k_BFFFO_table+0x208>
4cf44: 4878 0002 pea 2 <DOUBLE_FLOAT>
4cf48: 2f0a movel %a2,%sp@-
4cf4a: 4e94 jsr %a4@
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
4cf4c: 282e ff66 movel %fp@(-154),%d4
4cf50: 4fef 000c lea %sp@(12),%sp
4cf54: 0c84 0000 ffff cmpil #65535,%d4
4cf5a: 6300 fb34 blsw 4ca90 <msdos_format+0x54e>
4cf5e: 6000 fb2a braw 4ca8a <msdos_format+0x548> <== NOT EXECUTED
...
0004c428 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c428: 4e56 ffd0 linkw %fp,#-48
4c42c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4c430: 266e 0018 moveal %fp@(24),%a3
4c434: 262e 0008 movel %fp@(8),%d3
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4c438: 2f0b movel %a3,%sp@-
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c43a: 282e 0010 movel %fp@(16),%d4
4c43e: 2a2e 0014 movel %fp@(20),%d5
4c442: 1c2e 001f moveb %fp@(31),%d6
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4c446: 4eb9 0004 5af0 jsr 45af0 <malloc>
if (fill_buffer == NULL) {
4c44c: 588f addql #4,%sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4c44e: 2400 movel %d0,%d2
if (fill_buffer == NULL) {
4c450: 6614 bnes 4c466 <msdos_format_fill_sectors+0x3e> <== ALWAYS TAKEN
errno = ENOMEM;
4c452: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4c458: 2040 moveal %d0,%a0 <== NOT EXECUTED
4c45a: 700c moveq #12,%d0 <== NOT EXECUTED
4c45c: 2080 movel %d0,%a0@ <== NOT EXECUTED
ret_val = -1;
4c45e: 70ff moveq #-1,%d0 <== NOT EXECUTED
4c460: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
4c464: 6016 bras 4c47c <msdos_format_fill_sectors+0x54> <== NOT EXECUTED
}
else {
memset(fill_buffer,fill_byte,sector_size);
4c466: 2f0b movel %a3,%sp@-
4c468: 49c6 extbl %d6
4c46a: 2f06 movel %d6,%sp@-
4c46c: 2f00 movel %d0,%sp@-
4c46e: 4eb9 0005 8848 jsr 58848 <memset>
4c474: 4fef 000c lea %sp@(12),%sp
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
4c478: 42ae fffc clrl %fp@(-4)
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c47c: 4879 0006 7770 pea 67770 <_CPU_m68k_BFFFO_table+0x100>
4c482: 4bfa fef8 lea %pc@(4c37c <msdos_format_printf>),%a5
4c486: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c48a: 7c64 moveq #100,%d6
4c48c: 4c05 6800 mulsl %d5,%d6
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4c490: 2445 moveal %d5,%a2
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
4c492: 7eff moveq #-1,%d7
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c494: 49fa ff2c lea %pc@(4c3c2 <msdos_format_write_sec>),%a4
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4c498: 2f03 movel %d3,%sp@-
4c49a: 4e95 jsr %a5@
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4c49c: 4fef 000c lea %sp@(12),%sp
4c4a0: 604a bras 4c4ec <msdos_format_fill_sectors+0xc4>
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
4c4a2: 2006 movel %d6,%d0
4c4a4: 4c45 0000 remul %d5,%d0,%d0
if (percent != last_percent) {
4c4a8: be80 cmpl %d0,%d7
4c4aa: 6722 beqs 4c4ce <msdos_format_fill_sectors+0xa6>
if ((percent & 1) == 0)
4c4ac: 0800 0000 btst #0,%d0
4c4b0: 661a bnes 4c4cc <msdos_format_fill_sectors+0xa4>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4c4b2: 4879 0006 6377 pea 66377 <_rodata_start+0x1b7>
4c4b8: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c4bc: 2d40 fff8 movel %d0,%fp@(-8)
4c4c0: 2f03 movel %d3,%sp@-
4c4c2: 4e95 jsr %a5@
4c4c4: 202e fff8 movel %fp@(-8),%d0
4c4c8: 4fef 000c lea %sp@(12),%sp
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
4c4cc: 2e00 movel %d0,%d7
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c4ce: 2f02 movel %d2,%sp@-
start_sector++;
sector_cnt--;
4c4d0: 538a subql #1,%a2
4c4d2: 0686 ffff ff9c addil #-100,%d6
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c4d8: 2f0b movel %a3,%sp@-
4c4da: 2f04 movel %d4,%sp@-
4c4dc: 2f2e 000c movel %fp@(12),%sp@-
start_sector++;
4c4e0: 5284 addql #1,%d4
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c4e2: 4e94 jsr %a4@
start_sector++;
sector_cnt--;
4c4e4: 4fef 0010 lea %sp@(16),%sp
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4c4e8: 2d40 fffc movel %d0,%fp@(-4)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4c4ec: 4aae fffc tstl %fp@(-4)
4c4f0: 6604 bnes 4c4f6 <msdos_format_fill_sectors+0xce> <== NEVER TAKEN
4c4f2: 4a8a tstl %a2
4c4f4: 66ac bnes 4c4a2 <msdos_format_fill_sectors+0x7a>
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
4c4f6: 4879 0006 6c14 pea 66c14 <rtems_filesystem_table+0x314>
4c4fc: 45fa fe7e lea %pc@(4c37c <msdos_format_printf>),%a2
4c500: 4878 0002 pea 2 <DOUBLE_FLOAT>
4c504: 2f03 movel %d3,%sp@-
4c506: 4e92 jsr %a2@
if (ret_val)
4c508: 4fef 000c lea %sp@(12),%sp
4c50c: 4aae fffc tstl %fp@(-4)
4c510: 6714 beqs 4c526 <msdos_format_fill_sectors+0xfe> <== ALWAYS TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4c512: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4c514: 4879 0006 777b pea 6777b <_CPU_m68k_BFFFO_table+0x10b> <== NOT EXECUTED
4c51a: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4c51e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4c520: 4e92 jsr %a2@ <== NOT EXECUTED
4c522: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
4c526: 4a82 tstl %d2
4c528: 670a beqs 4c534 <msdos_format_fill_sectors+0x10c><== NEVER TAKEN
free(fill_buffer);
4c52a: 2f02 movel %d2,%sp@-
4c52c: 4eb9 0004 54d0 jsr 454d0 <free>
4c532: 588f addql #4,%sp
fill_buffer = NULL;
}
return ret_val;
}
4c534: 202e fffc movel %fp@(-4),%d0
4c538: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
4c53e: 4e5e unlk %fp <== NOT EXECUTED
0004c37c <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
4c37c: 4e56 0000 linkw %fp,#0
4c380: 206e 0008 moveal %fp@(8),%a0
va_list args;
va_start (args, format);
if (rqdata != NULL && rqdata->info_level >= info_level)
4c384: 4a88 tstl %a0
4c386: 6736 beqs 4c3be <msdos_format_printf+0x42> <== NEVER TAKEN
4c388: 202e 000c movel %fp@(12),%d0
4c38c: b0a8 001c cmpl %a0@(28),%d0
4c390: 6e2c bgts 4c3be <msdos_format_printf+0x42> <== ALWAYS TAKEN
{
vfprintf (stdout, format, args);
4c392: 486e 0014 pea %fp@(20) <== NOT EXECUTED
4c396: 2079 0006 8a38 moveal 68a38 <_impure_ptr>,%a0 <== NOT EXECUTED
4c39c: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
4c3a0: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
4c3a4: 4eb9 0005 f384 jsr 5f384 <vfprintf> <== NOT EXECUTED
fflush (stdout);
4c3aa: 2079 0006 8a38 moveal 68a38 <_impure_ptr>,%a0 <== NOT EXECUTED
4c3b0: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
4c3b4: 4eb9 0005 81f0 jsr 581f0 <fflush> <== NOT EXECUTED
4c3ba: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
va_end (args);
}
4c3be: 4e5e unlk %fp <== NOT EXECUTED
0004c3c2 <msdos_format_write_sec>:
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4c3c2: 4280 clrl %d0
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c3c4: 4e56 0000 linkw %fp,#0
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4c3c8: 222e 000c movel %fp@(12),%d1
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4c3cc: 2f03 movel %d3,%sp@-
4c3ce: 262e 0010 movel %fp@(16),%d3
4c3d2: 2f02 movel %d2,%sp@-
4c3d4: 242e 0008 movel %fp@(8),%d2
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4c3d8: 42a7 clrl %sp@-
4c3da: 2f03 movel %d3,%sp@-
4c3dc: 42a7 clrl %sp@-
4c3de: 2f01 movel %d1,%sp@-
4c3e0: 2f00 movel %d0,%sp@-
4c3e2: 4eb9 0006 4744 jsr 64744 <__muldi3>
4c3e8: 4fef 000c lea %sp@(12),%sp
4c3ec: 2e81 movel %d1,%sp@
4c3ee: 2f00 movel %d0,%sp@-
4c3f0: 2f02 movel %d2,%sp@-
4c3f2: 4eb9 0004 58b0 jsr 458b0 <lseek>
4c3f8: 4fef 0010 lea %sp@(16),%sp
4c3fc: 4a80 tstl %d0
4c3fe: 6b1a bmis 4c41a <msdos_format_write_sec+0x58> <== NEVER TAKEN
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
4c400: 2f03 movel %d3,%sp@-
4c402: 2f2e 0014 movel %fp@(20),%sp@-
4c406: 2f02 movel %d2,%sp@-
4c408: 4eb9 0004 8830 jsr 48830 <write>
4c40e: 4fef 000c lea %sp@(12),%sp
4c412: 4a80 tstl %d0
4c414: 5dc0 slt %d0
4c416: 49c0 extbl %d0
4c418: 6002 bras 4c41c <msdos_format_write_sec+0x5a>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4c41a: 70ff moveq #-1,%d0 <== NOT EXECUTED
ret_val = -1;
}
}
return ret_val;
}
4c41c: 242e fff8 movel %fp@(-8),%d2
4c420: 262e fffc movel %fp@(-4),%d3
4c424: 4e5e unlk %fp <== NOT EXECUTED
00054e48 <msdos_free_node_info>:
* RC_OK on success, or -1 code if error occured
*
*/
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
54e48: 4e56 0000 linkw %fp,#0
54e4c: 2f0b movel %a3,%sp@-
54e4e: 2f0a movel %a2,%sp@-
54e50: 246e 0008 moveal %fp@(8),%a2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
54e54: 206a 0010 moveal %a2@(16),%a0
54e58: 2668 0034 moveal %a0@(52),%a3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
54e5c: 42a7 clrl %sp@-
54e5e: 42a7 clrl %sp@-
54e60: 2f2b 0088 movel %a3@(136),%sp@-
54e64: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
54e6a: 4fef 000c lea %sp@(12),%sp
54e6e: 4a80 tstl %d0
54e70: 6712 beqs 54e84 <msdos_free_node_info+0x3c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
54e72: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
54e78: 347c ffff moveaw #-1,%a2 <== NOT EXECUTED
54e7c: 2040 moveal %d0,%a0 <== NOT EXECUTED
54e7e: 7005 moveq #5,%d0 <== NOT EXECUTED
54e80: 2080 movel %d0,%a0@ <== NOT EXECUTED
54e82: 601c bras 54ea0 <msdos_free_node_info+0x58> <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
54e84: 2f12 movel %a2@,%sp@-
54e86: 2f2a 0010 movel %a2@(16),%sp@-
54e8a: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close>
rtems_semaphore_release(fs_info->vol_sema);
54e90: 2f2b 0088 movel %a3@(136),%sp@-
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
54e94: 2440 moveal %d0,%a2
rtems_semaphore_release(fs_info->vol_sema);
54e96: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
54e9c: 4fef 000c lea %sp@(12),%sp
}
54ea0: 200a movel %a2,%d0
54ea2: 246e fff8 moveal %fp@(-8),%a2
54ea6: 266e fffc moveal %fp@(-4),%a3
54eaa: 4e5e unlk %fp
...
00055f1a <msdos_get_dotdot_dir_info_cluster_num_and_offset>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
55f1a: 4e56 ff98 linkw %fp,#-104 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
55f1e: 204e moveal %fp,%a0 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
55f20: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@ <== NOT EXECUTED
55f24: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
55f28: 42a0 clrl %a0@- <== NOT EXECUTED
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55f2a: 2c2a 0034 movel %a2@(52),%d6 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
55f2e: 266e 0010 moveal %fp@(16),%a3 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
55f32: 2f08 movel %a0,%sp@- <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
55f34: 262e 000c movel %fp@(12),%d3 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
55f38: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55f3a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
55f3c: 4eb9 0004 fa28 jsr 4fa28 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
55f42: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
55f46: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
55f48: 6600 0224 bnew 5616e <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x254><== NOT EXECUTED
return rc;
fat_fd->cln = cln;
55f4c: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
55f50: 7001 moveq #1,%d0 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
55f52: 227c 0020 0000 moveal #2097152,%a1 <== NOT EXECUTED
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
55f58: 2143 001c movel %d3,%a0@(28) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
55f5c: 2140 0010 movel %d0,%a0@(16) <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
55f60: 2149 0014 movel %a1,%a0@(20) <== NOT EXECUTED
fat_fd->map.file_cln = 0;
55f64: 42a8 0032 clrl %a0@(50) <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
55f68: 2143 0036 movel %d3,%a0@(54) <== NOT EXECUTED
rc = fat_file_size(mt_entry, fat_fd);
55f6c: 2f08 movel %a0,%sp@- <== NOT EXECUTED
55f6e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
55f70: 4eb9 0005 03b6 jsr 503b6 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
55f76: 508f addql #8,%sp <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
55f78: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
55f7a: 6600 0184 bnew 56100 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e6><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
55f7e: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
55f82: 4bee ffbc lea %fp@(-68),%a5 <== NOT EXECUTED
55f86: 2a3c 0005 8848 movel #362568,%d5 <== NOT EXECUTED
55f8c: 2045 moveal %d5,%a0 <== NOT EXECUTED
55f8e: 42a7 clrl %sp@- <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
55f90: 283c 0005 4fe8 movel #348136,%d4 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
55f96: 2f0d movel %a5,%sp@- <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
55f98: 263c 0005 5636 movel #349750,%d3 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
55f9e: 4e90 jsr %a0@ <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
55fa0: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
55fa4: 2244 moveal %d4,%a1 <== NOT EXECUTED
55fa6: 2f0d movel %a5,%sp@- <== NOT EXECUTED
55fa8: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
55fac: 4879 0006 6377 pea 66377 <_rodata_start+0x1b7> <== NOT EXECUTED
55fb2: 4e91 jsr %a1@ <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
55fb4: 2043 moveal %d3,%a0 <== NOT EXECUTED
55fb6: 2f0d movel %a5,%sp@- <== NOT EXECUTED
55fb8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55fba: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
55fbe: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
55fc2: 4879 0006 6377 pea 66377 <_rodata_start+0x1b7> <== NOT EXECUTED
55fc8: 42a7 clrl %sp@- <== NOT EXECUTED
55fca: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
55fce: 2f0a movel %a2,%sp@- <== NOT EXECUTED
55fd0: 4e90 jsr %a0@ <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
55fd2: 4fef 003c lea %sp@(60),%sp <== NOT EXECUTED
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
55fd6: 2400 movel %d0,%d2 <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
55fd8: 6600 0126 bnew 56100 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e6><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
55fdc: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
55fe0: 49ee ffdc lea %fp@(-36),%a4 <== NOT EXECUTED
55fe4: 2245 moveal %d5,%a1 <== NOT EXECUTED
55fe6: 42a7 clrl %sp@- <== NOT EXECUTED
55fe8: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55fea: 4e91 jsr %a1@ <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
55fec: 4878 000b pea b <LASTO+0x1> <== NOT EXECUTED
55ff0: 2044 moveal %d4,%a0 <== NOT EXECUTED
55ff2: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55ff4: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
55ff8: 4879 0006 6376 pea 66376 <_rodata_start+0x1b6> <== NOT EXECUTED
55ffe: 4e90 jsr %a0@ <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
56000: 2243 moveal %d3,%a1 <== NOT EXECUTED
56002: 2f0c movel %a4,%sp@- <== NOT EXECUTED
56004: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56006: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5600a: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
5600e: 4879 0006 6376 pea 66376 <_rodata_start+0x1b6> <== NOT EXECUTED
56014: 42a7 clrl %sp@- <== NOT EXECUTED
56016: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
5601a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5601c: 4e91 jsr %a1@ <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
5601e: 4fef 003c lea %sp@(60),%sp <== NOT EXECUTED
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
56022: 2400 movel %d0,%d2 <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
56024: 6600 00da bnew 56100 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e6><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
56028: 362d 001a movew %a5@(26),%d3 <== NOT EXECUTED
5602c: 382d 0014 movew %a5@(20),%d4 <== NOT EXECUTED
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
56030: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56034: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56036: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
if ( rc != RC_OK )
5603c: 508f addql #8,%sp <== NOT EXECUTED
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
5603e: 2400 movel %d0,%d2 <== NOT EXECUTED
if ( rc != RC_OK )
56040: 6600 012c bnew 5616e <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x254><== NOT EXECUTED
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
56044: 4281 clrl %d1 <== NOT EXECUTED
56046: 4282 clrl %d2 <== NOT EXECUTED
56048: 322c 0014 movew %a4@(20),%d1 <== NOT EXECUTED
5604c: 342c 001a movew %a4@(26),%d2 <== NOT EXECUTED
56050: 2001 movel %d1,%d0 <== NOT EXECUTED
56052: e089 lsrl #8,%d1 <== NOT EXECUTED
56054: e188 lsll #8,%d0 <== NOT EXECUTED
56056: 8081 orl %d1,%d0 <== NOT EXECUTED
56058: 2202 movel %d2,%d1 <== NOT EXECUTED
5605a: e08a lsrl #8,%d2 <== NOT EXECUTED
5605c: e189 lsll #8,%d1 <== NOT EXECUTED
5605e: 4840 swap %d0 <== NOT EXECUTED
56060: 4240 clrw %d0 <== NOT EXECUTED
56062: 8282 orl %d2,%d1 <== NOT EXECUTED
56064: 0281 0000 ffff andil #65535,%d1 <== NOT EXECUTED
5606a: 8081 orl %d1,%d0 <== NOT EXECUTED
5606c: 6612 bnes 56080 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x166><== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
5606e: 70ff moveq #-1,%d0 <== NOT EXECUTED
/*
* we handle root dir for all FAT types in the same way with the
* ordinary directories ( through fat_file_* calls )
*/
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
56070: 7a01 moveq #1,%d5 <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
56072: 42ab 0004 clrl %a3@(4) <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
56076: 2740 0008 movel %d0,%a3@(8) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
5607a: 2740 000c movel %d0,%a3@(12) <== NOT EXECUTED
5607e: 2685 movel %d5,%a3@ <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
56080: 486e fffc pea %fp@(-4) <== NOT EXECUTED
56084: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56086: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56088: 4eb9 0004 fa28 jsr 4fa28 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
5608e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
56092: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
56094: 6600 00d8 bnew 5616e <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x254><== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
56098: 4281 clrl %d1 <== NOT EXECUTED
5609a: 4282 clrl %d2 <== NOT EXECUTED
5609c: 322e fff0 movew %fp@(-16),%d1 <== NOT EXECUTED
560a0: 342e fff6 movew %fp@(-10),%d2 <== NOT EXECUTED
560a4: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
560a8: 2001 movel %d1,%d0 <== NOT EXECUTED
560aa: e089 lsrl #8,%d1 <== NOT EXECUTED
560ac: e188 lsll #8,%d0 <== NOT EXECUTED
560ae: 8081 orl %d1,%d0 <== NOT EXECUTED
560b0: 2202 movel %d2,%d1 <== NOT EXECUTED
560b2: e08a lsrl #8,%d2 <== NOT EXECUTED
560b4: e189 lsll #8,%d1 <== NOT EXECUTED
560b6: 4840 swap %d0 <== NOT EXECUTED
560b8: 4240 clrw %d0 <== NOT EXECUTED
560ba: 8282 orl %d2,%d1 <== NOT EXECUTED
560bc: 0281 0000 ffff andil #65535,%d1 <== NOT EXECUTED
560c2: 8081 orl %d1,%d0 <== NOT EXECUTED
560c4: 660c bnes 560d2 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1b8><== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
560c6: 2246 moveal %d6,%a1 <== NOT EXECUTED
560c8: 43e9 0034 lea %a1@(52),%a1 <== NOT EXECUTED
560cc: 2151 001c movel %a1@,%a0@(28) <== NOT EXECUTED
560d0: 6004 bras 560d6 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1bc><== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
560d2: 2140 001c movel %d0,%a0@(28) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
560d6: 7001 moveq #1,%d0 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
560d8: 227c 0020 0000 moveal #2097152,%a1 <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
560de: 2168 001c 0036 movel %a0@(28),%a0@(54) <== NOT EXECUTED
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
560e4: 2140 0010 movel %d0,%a0@(16) <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
560e8: 2149 0014 movel %a1,%a0@(20) <== NOT EXECUTED
fat_fd->map.file_cln = 0;
560ec: 42a8 0032 clrl %a0@(50) <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
560f0: 2f08 movel %a0,%sp@- <== NOT EXECUTED
560f2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
560f4: 4eb9 0005 03b6 jsr 503b6 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
560fa: 508f addql #8,%sp <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
560fc: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc != RC_OK)
560fe: 670e beqs 5610e <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1f4><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
56100: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56104: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56106: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
5610c: 605e bras 5616c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x252><== NOT EXECUTED
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
5610e: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
56112: 0284 0000 ffff andil #65535,%d4 <== NOT EXECUTED
56118: 0283 0000 ffff andil #65535,%d3 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
5611e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56120: 2004 movel %d4,%d0 <== NOT EXECUTED
56122: 2203 movel %d3,%d1 <== NOT EXECUTED
56124: e08c lsrl #8,%d4 <== NOT EXECUTED
56126: e08b lsrl #8,%d3 <== NOT EXECUTED
56128: e188 lsll #8,%d0 <== NOT EXECUTED
5612a: e189 lsll #8,%d1 <== NOT EXECUTED
5612c: 8084 orl %d4,%d0 <== NOT EXECUTED
5612e: 8283 orl %d3,%d1 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
56130: 4840 swap %d0 <== NOT EXECUTED
56132: 4240 clrw %d0 <== NOT EXECUTED
56134: 0281 0000 ffff andil #65535,%d1 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
5613a: 8081 orl %d1,%d0 <== NOT EXECUTED
5613c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5613e: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56142: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56144: 4eb9 0005 5dd0 jsr 55dd0 <msdos_find_node_by_cluster_num_in_fat_file><== NOT EXECUTED
dir_pos, dir_entry);
if (rc != RC_OK)
5614a: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
5614e: 41f9 0004 fdc6 lea 4fdc6 <fat_file_close>,%a0 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
56154: 2400 movel %d0,%d2 <== NOT EXECUTED
dir_pos, dir_entry);
if (rc != RC_OK)
56156: 670a beqs 56162 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x248><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
56158: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
5615c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5615e: 4e90 jsr %a0@ <== NOT EXECUTED
56160: 600a bras 5616c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x252><== NOT EXECUTED
return rc;
}
rc = fat_file_close(mt_entry, fat_fd);
56162: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56166: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56168: 4e90 jsr %a0@ <== NOT EXECUTED
5616a: 2400 movel %d0,%d2 <== NOT EXECUTED
return rc;
5616c: 508f addql #8,%sp <== NOT EXECUTED
}
5616e: 2002 movel %d2,%d0 <== NOT EXECUTED
56170: 4cee 3c7c ff98 moveml %fp@(-104),%d2-%d6/%a2-%a5 <== NOT EXECUTED
56176: 4e5e unlk %fp <== NOT EXECUTED
0005617a <msdos_get_name_node>:
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
5617a: 4280 clrl %d0
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
5617c: 4e56 ffe8 linkw %fp,#-24
56180: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
56184: 266e 0020 moveal %fp@(32),%a3
56188: 246e 001c moveal %fp@(28),%a2
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
5618c: 2f0b movel %a3,%sp@-
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
5618e: 262e 0010 movel %fp@(16),%d3
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
56192: 2f0a movel %a2,%sp@-
56194: 2f2e 0018 movel %fp@(24),%sp@-
56198: 2f2e 0014 movel %fp@(20),%sp@-
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
5619c: 286e 0008 moveal %fp@(8),%a4
561a0: 182e 000f moveb %fp@(15),%d4
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
561a4: 2f03 movel %d3,%sp@-
561a6: 1004 moveb %d4,%d0
561a8: 2f00 movel %d0,%sp@-
561aa: 2f14 movel %a4@,%sp@-
561ac: 2f2c 0010 movel %a4@(16),%sp@-
561b0: 4eb9 0005 5636 jsr 55636 <msdos_find_name_in_fat_file>
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
561b6: 4fef 0020 lea %sp@(32),%sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
561ba: 2400 movel %d0,%d2
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
561bc: 670a beqs 561c8 <msdos_get_name_node+0x4e>
561be: 0c80 0000 7d01 cmpil #32001,%d0
561c4: 6600 008c bnew 56252 <msdos_get_name_node+0xd8>
return rc;
if (!create_node)
561c8: 4a04 tstb %d4
561ca: 6600 0086 bnew 56252 <msdos_get_name_node+0xd8>
{
/* if we search for valid name and name not found -> return */
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
561ce: 0c82 0000 7d01 cmpil #32001,%d2
561d4: 677c beqs 56252 <msdos_get_name_node+0xd8>
* if we have deal with ".." - it is a special case :(((
*
* Really, we should return cluster num and offset not of ".." slot, but
* slot which correspondes to real directory name.
*/
if (rc == RC_OK)
561d6: 4a82 tstl %d2
561d8: 6678 bnes 56252 <msdos_get_name_node+0xd8> <== NEVER TAKEN
{
if (strncmp(name, "..", 2) == 0)
561da: 4878 0002 pea 2 <DOUBLE_FLOAT>
561de: 4879 0006 6376 pea 66376 <_rodata_start+0x1b6>
561e4: 2f03 movel %d3,%sp@-
561e6: 4eb9 0005 95d8 jsr 595d8 <strncmp>
561ec: 4fef 000c lea %sp@(12),%sp
561f0: 4a80 tstl %d0
561f2: 665e bnes 56252 <msdos_get_name_node+0xd8>
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
561f4: 4281 clrl %d1
561f6: 4283 clrl %d3
561f8: 322b 0014 movew %a3@(20),%d1
561fc: 362b 001a movew %a3@(26),%d3
56200: 2001 movel %d1,%d0
56202: e089 lsrl #8,%d1
56204: e188 lsll #8,%d0
56206: 8081 orl %d1,%d0
56208: 2203 movel %d3,%d1
5620a: e08b lsrl #8,%d3
5620c: e189 lsll #8,%d1
5620e: 4840 swap %d0
56210: 4240 clrw %d0
56212: 8283 orl %d3,%d1
56214: 0281 0000 ffff andil #65535,%d1
5621a: 8081 orl %d1,%d0
/* are we right under root dir ? */
if (dotdot_cln == 0)
5621c: 6614 bnes 56232 <msdos_get_name_node+0xb8> <== NEVER TAKEN
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
5621e: 70ff moveq #-1,%d0
56220: 2540 0008 movel %d0,%a2@(8)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
56224: 2540 000c movel %d0,%a2@(12)
/*
* we can relax about first_char field - it never should be
* used for root dir
*/
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
56228: 7001 moveq #1,%d0
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
5622a: 42aa 0004 clrl %a2@(4)
5622e: 2480 movel %d0,%a2@
56230: 6020 bras 56252 <msdos_get_name_node+0xd8>
}
else
{
rc =
56232: 2d4b 0014 movel %a3,%fp@(20) <== NOT EXECUTED
56236: 2d4a 0010 movel %a2,%fp@(16) <== NOT EXECUTED
5623a: 2d40 000c movel %d0,%fp@(12) <== NOT EXECUTED
5623e: 2d6c 0010 0008 movel %a4@(16),%fp@(8) <== NOT EXECUTED
}
}
}
}
return rc;
}
56244: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 <== NOT EXECUTED
5624a: 4e5e unlk %fp <== NOT EXECUTED
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
5624c: 4ef9 0005 5f1a jmp 55f1a <msdos_get_dotdot_dir_info_cluster_num_and_offset><== NOT EXECUTED
}
}
}
}
return rc;
}
56252: 2002 movel %d2,%d0
56254: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
5625a: 4e5e unlk %fp <== NOT EXECUTED
0005514c <msdos_get_token>:
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
5514c: 4e56 ffdc linkw %fp,#-36
55150: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
55154: 2a6e 0010 moveal %fp@(16),%a5
55158: 286e 0014 moveal %fp@(20),%a4
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
5515c: 4295 clrl %a5@
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
5515e: 246e 0008 moveal %fp@(8),%a2
55162: 262e 000c movel %fp@(12),%d3
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
*ret_token_len = 0;
55166: 4294 clrl %a4@
if (pathlen == 0)
55168: 4a83 tstl %d3
5516a: 6700 0096 beqw 55202 <msdos_get_token+0xb6>
5516e: 264a moveal %a2,%a3
55170: 4282 clrl %d2
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
55172: 2a3c 0004 6a68 movel #289384,%d5
{
if ( !msdos_is_valid_name_char(path[i]) )
55178: 283c 0005 4f7c movel #348028,%d4
5517e: 601e bras 5519e <msdos_get_token+0x52>
55180: 2046 moveal %d6,%a0
int i = 0;
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
55182: 528b addql #1,%a3
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
{
if ( !msdos_is_valid_name_char(path[i]) )
55184: 1c10 moveb %a0@,%d6
55186: 2044 moveal %d4,%a0
55188: 49c6 extbl %d6
5518a: 2f06 movel %d6,%sp@-
5518c: 4e90 jsr %a0@
5518e: 588f addql #4,%sp
55190: 4a80 tstl %d0
55192: 6772 beqs 55206 <msdos_get_token+0xba> <== NEVER TAKEN
return MSDOS_INVALID_TOKEN;
++i;
55194: 5282 addql #1,%d2
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
55196: 0c82 0000 0104 cmpil #260,%d2
5519c: 6768 beqs 55206 <msdos_get_token+0xba> <== NEVER TAKEN
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
5519e: 2045 moveal %d5,%a0
* RETURNS:
* token type, token and token length
*
*/
msdos_token_types_t
msdos_get_token(const char *path,
551a0: 2c0b movel %a3,%d6
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
551a2: 1013 moveb %a3@,%d0
551a4: 49c0 extbl %d0
551a6: 2f00 movel %d0,%sp@-
551a8: 4e90 jsr %a0@
551aa: 588f addql #4,%sp
551ac: 4a80 tstl %d0
551ae: 6604 bnes 551b4 <msdos_get_token+0x68>
551b0: b682 cmpl %d2,%d3
551b2: 6ecc bgts 55180 <msdos_get_token+0x34>
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
}
*ret_token = path;
551b4: 2a8a movel %a2,%a5@
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
551b6: 4a82 tstl %d2
551b8: 6608 bnes 551c2 <msdos_get_token+0x76>
{
if ( (*path != '\0') && pathlen )
551ba: 4a12 tstb %a2@
551bc: 6608 bnes 551c6 <msdos_get_token+0x7a>
{
i++;
type = MSDOS_CURRENT_DIR;
}
else
type = MSDOS_NO_MORE_PATH;
551be: 4280 clrl %d0
551c0: 6008 bras 551ca <msdos_get_token+0x7e>
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
msdos_token_types_t type = MSDOS_NAME;
551c2: 7003 moveq #3,%d0
551c4: 6004 bras 551ca <msdos_get_token+0x7e>
*/
if ( i == 0 )
{
if ( (*path != '\0') && pathlen )
{
i++;
551c6: 7401 moveq #1,%d2
type = MSDOS_CURRENT_DIR;
551c8: 7001 moveq #1,%d0
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
551ca: 2882 movel %d2,%a4@
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
551cc: 7203 moveq #3,%d1
551ce: b280 cmpl %d0,%d1
551d0: 663e bnes 55210 <msdos_get_token+0xc4>
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
551d2: 123c 0002 moveb #2,%d1
551d6: b282 cmpl %d2,%d1
551d8: 6616 bnes 551f0 <msdos_get_token+0xa4>
551da: 742e moveq #46,%d2
551dc: 1212 moveb %a2@,%d1
551de: 49c1 extbl %d1
551e0: b481 cmpl %d1,%d2
551e2: 662c bnes 55210 <msdos_get_token+0xc4> <== NEVER TAKEN
551e4: 122a 0001 moveb %a2@(1),%d1
551e8: 49c1 extbl %d1
551ea: b481 cmpl %d1,%d2
551ec: 6622 bnes 55210 <msdos_get_token+0xc4> <== NEVER TAKEN
551ee: 601a bras 5520a <msdos_get_token+0xbe>
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
551f0: 7201 moveq #1,%d1
551f2: b282 cmpl %d2,%d1
551f4: 661a bnes 55210 <msdos_get_token+0xc4>
551f6: 742e moveq #46,%d2
551f8: 1212 moveb %a2@,%d1
551fa: 49c1 extbl %d1
551fc: b481 cmpl %d1,%d2
551fe: 6610 bnes 55210 <msdos_get_token+0xc4> <== NEVER TAKEN
55200: 600c bras 5520e <msdos_get_token+0xc2>
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
return MSDOS_NO_MORE_PATH;
55202: 4280 clrl %d0
55204: 600a bras 55210 <msdos_get_token+0xc4>
{
if ( !msdos_is_valid_name_char(path[i]) )
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
55206: 7004 moveq #4,%d0 <== NOT EXECUTED
55208: 6006 bras 55210 <msdos_get_token+0xc4> <== NOT EXECUTED
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
{
type = MSDOS_UP_DIR;
return type;
5520a: 7002 moveq #2,%d0
5520c: 6002 bras 55210 <msdos_get_token+0xc4>
}
if ((i == 1) && ((*ret_token)[0] == '.'))
{
type = MSDOS_CURRENT_DIR;
return type;
5520e: 7001 moveq #1,%d0
}
}
return type;
}
55210: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
55216: 4e5e unlk %fp <== NOT EXECUTED
0004cf88 <msdos_initialize_support>:
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
4cf88: 4e56 ffd8 linkw %fp,#-40
4cf8c: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
4cf90: 4878 0090 pea 90 <DBL_MANT_DIG+0x5b>
4cf94: 4878 0001 pea 1 <ADD>
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
4cf98: 266e 0008 moveal %fp@(8),%a3
4cf9c: 262e 0014 movel %fp@(20),%d3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
4cfa0: 42ae fffc clrl %fp@(-4)
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
4cfa4: 4eb9 0004 4e3c jsr 44e3c <calloc>
if (!fs_info)
4cfaa: 508f addql #8,%sp
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
4cfac: 2440 moveal %d0,%a2
if (!fs_info)
4cfae: 4a80 tstl %d0
4cfb0: 6610 bnes 4cfc2 <msdos_initialize_support+0x3a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
4cfb2: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4cfb8: 740c moveq #12,%d2 <== NOT EXECUTED
4cfba: 2040 moveal %d0,%a0 <== NOT EXECUTED
4cfbc: 2082 movel %d2,%a0@ <== NOT EXECUTED
4cfbe: 6000 0124 braw 4d0e4 <msdos_initialize_support+0x15c> <== NOT EXECUTED
temp_mt_entry->fs_info = fs_info;
4cfc2: 2740 0034 movel %d0,%a3@(52)
rc = fat_init_volume_info(temp_mt_entry);
4cfc6: 2f0b movel %a3,%sp@-
4cfc8: 4eb9 0005 0cac jsr 50cac <fat_init_volume_info>
if (rc != RC_OK)
4cfce: 588f addql #4,%sp
if (!fs_info)
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
rc = fat_init_volume_info(temp_mt_entry);
4cfd0: 2400 movel %d0,%d2
if (rc != RC_OK)
4cfd2: 670e beqs 4cfe2 <msdos_initialize_support+0x5a> <== ALWAYS TAKEN
{
free(fs_info);
4cfd4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4cfd6: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rc;
4cfdc: 588f addql #4,%sp <== NOT EXECUTED
4cfde: 6000 016e braw 4d14e <msdos_initialize_support+0x1c6> <== NOT EXECUTED
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
4cfe2: 486e fffc pea %fp@(-4)
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4cfe6: 70ff moveq #-1,%d0
4cfe8: 486e ffec pea %fp@(-20)
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
4cfec: 256e 0010 0084 movel %fp@(16),%a2@(132)
4cff2: 2d40 fff4 movel %d0,%fp@(-12)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4cff6: 2d40 fff8 movel %d0,%fp@(-8)
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
4cffa: 7001 moveq #1,%d0
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
4cffc: 2f0b movel %a3,%sp@-
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
fs_info->directory_handlers = directory_handlers;
4cffe: 2543 0080 movel %d3,%a2@(128)
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
4d002: 42ae fff0 clrl %fp@(-16)
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
4d006: 2d40 ffec movel %d0,%fp@(-20)
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
4d00a: 4eb9 0004 fa28 jsr 4fa28 <fat_file_open>
if (rc != RC_OK)
4d010: 4fef 000c lea %sp@(12),%sp
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
4d014: 2400 movel %d0,%d2
if (rc != RC_OK)
4d016: 6716 beqs 4d02e <msdos_initialize_support+0xa6> <== ALWAYS TAKEN
{
fat_shutdown_drive(temp_mt_entry);
4d018: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d01a: 4eb9 0005 0ba4 jsr 50ba4 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
4d020: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d022: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rc;
4d028: 508f addql #8,%sp <== NOT EXECUTED
4d02a: 6000 0122 braw 4d14e <msdos_initialize_support+0x1c6> <== NOT EXECUTED
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
4d02e: 206e fffc moveal %fp@(-4),%a0
4d032: 7001 moveq #1,%d0
4d034: 2140 0010 movel %d0,%a0@(16)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4d038: 7020 moveq #32,%d0
4d03a: 4840 swap %d0
4d03c: 2140 0014 movel %d0,%a0@(20)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4d040: 202a 0034 movel %a2@(52),%d0
fat_fd->map.file_cln = 0;
4d044: 42a8 0032 clrl %a0@(50)
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4d048: 2140 001c movel %d0,%a0@(28)
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
4d04c: 2140 0036 movel %d0,%a0@(54)
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
4d050: 6616 bnes 4d068 <msdos_initialize_support+0xe0> <== NEVER TAKEN
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
4d052: 4280 clrl %d0
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
4d054: 222a 0024 movel %a2@(36),%d1
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
4d058: 302a 0006 movew %a2@(6),%d0
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
4d05c: 2141 0018 movel %d1,%a0@(24)
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
4d060: b280 cmpl %d0,%d1
4d062: 6340 blss 4d0a4 <msdos_initialize_support+0x11c> <== NEVER TAKEN
4d064: 2001 movel %d1,%d0
4d066: 603c bras 4d0a4 <msdos_initialize_support+0x11c>
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
4d068: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4d06a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d06c: 4eb9 0005 03b6 jsr 503b6 <fat_file_size> <== NOT EXECUTED
if ( rc != RC_OK )
4d072: 508f addql #8,%sp <== NOT EXECUTED
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
4d074: 2800 movel %d0,%d4 <== NOT EXECUTED
if ( rc != RC_OK )
4d076: 6726 beqs 4d09e <msdos_initialize_support+0x116> <== NOT EXECUTED
{
fat_file_close(temp_mt_entry, fat_fd);
4d078: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
free(fs_info);
return rc;
4d07c: 2404 movel %d4,%d2 <== NOT EXECUTED
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
if ( rc != RC_OK )
{
fat_file_close(temp_mt_entry, fat_fd);
4d07e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d080: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
4d086: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d088: 4eb9 0005 0ba4 jsr 50ba4 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
4d08e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d090: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rc;
4d096: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d09a: 6000 00b2 braw 4d14e <msdos_initialize_support+0x1c6> <== NOT EXECUTED
}
cl_buf_size = fs_info->fat.vol.bpc;
4d09e: 4280 clrl %d0 <== NOT EXECUTED
4d0a0: 302a 0006 movew %a2@(6),%d0 <== NOT EXECUTED
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
4d0a4: 4878 0001 pea 1 <ADD>
4d0a8: 2f00 movel %d0,%sp@-
4d0aa: 4eb9 0004 4e3c jsr 44e3c <calloc>
if (fs_info->cl_buf == NULL)
4d0b0: 508f addql #8,%sp
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
4d0b2: 2540 008c movel %d0,%a2@(140)
if (fs_info->cl_buf == NULL)
4d0b6: 6630 bnes 4d0e8 <msdos_initialize_support+0x160> <== ALWAYS TAKEN
{
fat_file_close(temp_mt_entry, fat_fd);
4d0b8: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4d0bc: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d0be: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
4d0c4: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d0c6: 4eb9 0005 0ba4 jsr 50ba4 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
4d0cc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d0ce: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4d0d4: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4d0da: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d0de: 720c moveq #12,%d1 <== NOT EXECUTED
4d0e0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d0e2: 2081 movel %d1,%a0@ <== NOT EXECUTED
4d0e4: 74ff moveq #-1,%d2 <== NOT EXECUTED
4d0e6: 6066 bras 4d14e <msdos_initialize_support+0x1c6> <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
4d0e8: 486a 0088 pea %a2@(136)
4d0ec: 42a7 clrl %sp@-
4d0ee: 4878 0010 pea 10 <INVALID_OPERATION>
4d0f2: 4878 0001 pea 1 <ADD>
4d0f6: 4878 0003 pea 3 <DIVIDE>
4d0fa: 4eb9 0004 8cd4 jsr 48cd4 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
4d100: 4fef 0014 lea %sp@(20),%sp
4d104: 4a80 tstl %d0
4d106: 6736 beqs 4d13e <msdos_initialize_support+0x1b6> <== ALWAYS TAKEN
{
fat_file_close(temp_mt_entry, fat_fd);
4d108: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4d10c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d10e: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
4d114: 2f0b movel %a3,%sp@- <== NOT EXECUTED
free(fs_info->cl_buf);
4d116: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
{
fat_file_close(temp_mt_entry, fat_fd);
fat_shutdown_drive(temp_mt_entry);
4d11c: 4eb9 0005 0ba4 jsr 50ba4 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info->cl_buf);
4d122: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED
4d126: 4e93 jsr %a3@ <== NOT EXECUTED
free(fs_info);
4d128: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d12a: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4d12c: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4d132: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4d136: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d138: 7005 moveq #5,%d0 <== NOT EXECUTED
4d13a: 2080 movel %d0,%a0@ <== NOT EXECUTED
4d13c: 60a6 bras 4d0e4 <msdos_initialize_support+0x15c> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
4d13e: 2743 0024 movel %d3,%a3@(36)
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
4d142: 276e fffc 001c movel %fp@(-4),%a3@(28)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
4d148: 276e 000c 0028 movel %fp@(12),%a3@(40)
return rc;
}
4d14e: 2002 movel %d2,%d0
4d150: 4cee 0c1c ffd8 moveml %fp@(-40),%d2-%d4/%a2-%a3
4d156: 4e5e unlk %fp
...
00054f7c <msdos_is_valid_name_char>:
* MSDOS_NAME_LONG - Valid in a long name only.
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
54f7c: 4e56 fff4 linkw %fp,#-12
54f80: 48d7 040c moveml %d2-%d3/%a2,%sp@
54f84: 162e 000b moveb %fp@(11),%d3
if (strchr(" +,;=[]", ch) != NULL)
54f88: 45f9 0005 8e8c lea 58e8c <strchr>,%a2
54f8e: 1403 moveb %d3,%d2
54f90: 49c2 extbl %d2
54f92: 2f02 movel %d2,%sp@-
54f94: 4879 0006 7b6e pea 67b6e <msdos_file_handlers+0x38>
54f9a: 4e92 jsr %a2@
54f9c: 508f addql #8,%sp
54f9e: 4a80 tstl %d0
54fa0: 6636 bnes 54fd8 <msdos_is_valid_name_char+0x5c> <== NEVER TAKEN
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
54fa2: 103c 002e moveb #46,%d0
54fa6: b082 cmpl %d2,%d0
54fa8: 6732 beqs 54fdc <msdos_is_valid_name_char+0x60>
54faa: 2079 0006 8a34 moveal 68a34 <__ctype_ptr__>,%a0
54fb0: 7207 moveq #7,%d1
54fb2: 0283 0000 00ff andil #255,%d3
54fb8: 1030 3801 moveb %a0@(00000001,%d3:l),%d0
54fbc: 49c0 extbl %d0
54fbe: c081 andl %d1,%d0
54fc0: 661a bnes 54fdc <msdos_is_valid_name_char+0x60>
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
54fc2: 2f02 movel %d2,%sp@-
54fc4: 4879 0006 7b76 pea 67b76 <msdos_file_handlers+0x40>
54fca: 4e92 jsr %a2@
54fcc: 508f addql #8,%sp
return MSDOS_NAME_SHORT;
54fce: 4a80 tstl %d0
54fd0: 56c0 sne %d0
54fd2: 49c0 extbl %d0
54fd4: 4480 negl %d0
54fd6: 6006 bras 54fde <msdos_is_valid_name_char+0x62>
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
54fd8: 7002 moveq #2,%d0 <== NOT EXECUTED
54fda: 6002 bras 54fde <msdos_is_valid_name_char+0x62> <== NOT EXECUTED
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
54fdc: 7001 moveq #1,%d0
return MSDOS_NAME_INVALID;
}
54fde: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
54fe4: 4e5e unlk %fp <== NOT EXECUTED
00054fe8 <msdos_long_to_short>:
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
54fe8: 4e56 ffd4 linkw %fp,#-44
54fec: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
54ff0: 2f2e 0014 movel %fp@(20),%sp@-
54ff4: 4878 0020 pea 20 <OPER2+0xc>
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
54ff8: 266e 0010 moveal %fp@(16),%a3
54ffc: 246e 0008 moveal %fp@(8),%a2
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
55000: 2f0b movel %a3,%sp@-
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
55002: 282e 000c movel %fp@(12),%d4
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
55006: 4eb9 0005 8848 jsr 58848 <memset>
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
5500c: 4fef 000c lea %sp@(12),%sp
55010: 722e moveq #46,%d1
55012: 1012 moveb %a2@,%d0
55014: 49c0 extbl %d0
55016: b280 cmpl %d0,%d1
55018: 6620 bnes 5503a <msdos_long_to_short+0x52>
5501a: 7401 moveq #1,%d2
5501c: b484 cmpl %d4,%d2
5501e: 6608 bnes 55028 <msdos_long_to_short+0x40> <== ALWAYS TAKEN
{
sfn[0] = '.';
55020: 16bc 002e moveb #46,%a3@ <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
55024: 6000 0102 braw 55128 <msdos_long_to_short+0x140> <== NOT EXECUTED
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
55028: 722e moveq #46,%d1
5502a: 102a 0001 moveb %a2@(1),%d0
5502e: 49c0 extbl %d0
55030: b280 cmpl %d0,%d1
55032: 6606 bnes 5503a <msdos_long_to_short+0x52> <== NEVER TAKEN
55034: 7402 moveq #2,%d2
55036: b484 cmpl %d4,%d2
55038: 6708 beqs 55042 <msdos_long_to_short+0x5a> <== ALWAYS TAKEN
5503a: 284a moveal %a2,%a4
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
5503c: 204a moveal %a2,%a0
5503e: 4280 clrl %d0
55040: 6026 bras 55068 <msdos_long_to_short+0x80>
{
sfn[0] = sfn[1] = '.';
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
55042: 7401 moveq #1,%d2
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
55044: 702e moveq #46,%d0
55046: 16bc 002e moveb #46,%a3@
5504a: 1740 0001 moveb %d0,%a3@(1)
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
5504e: 6000 00d8 braw 55128 <msdos_long_to_short+0x140>
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
55052: 7420 moveq #32,%d2
55054: 1218 moveb %a0@+,%d1
55056: 49c1 extbl %d1
55058: b481 cmpl %d1,%d2
5505a: 670a beqs 55066 <msdos_long_to_short+0x7e> <== NEVER TAKEN
5505c: 143c 002e moveb #46,%d2
55060: b481 cmpl %d1,%d2
55062: 6600 009a bnew 550fe <msdos_long_to_short+0x116>
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
55066: 5280 addql #1,%d0 <== NOT EXECUTED
55068: b880 cmpl %d0,%d4
5506a: 6ee6 bgts 55052 <msdos_long_to_short+0x6a> <== ALWAYS TAKEN
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
5506c: 6600 0090 bnew 550fe <msdos_long_to_short+0x116> <== NOT EXECUTED
55070: 6000 00b4 braw 55126 <msdos_long_to_short+0x13e> <== NOT EXECUTED
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
55074: 2d41 fffc movel %d1,%fp@(-4)
55078: 1006 moveb %d6,%d0
5507a: 49c0 extbl %d0
5507c: 2f00 movel %d0,%sp@-
5507e: 4e95 jsr %a5@
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
55080: 222e fffc movel %fp@(-4),%d1
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
55084: 588f addql #4,%sp
55086: 2400 movel %d0,%d2
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
55088: 6700 009e beqw 55128 <msdos_long_to_short+0x140>
5508c: 7002 moveq #2,%d0
5508e: b082 cmpl %d2,%d0
55090: 6700 00a8 beqw 5513a <msdos_long_to_short+0x152>
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
55094: 103c 002e moveb #46,%d0
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
55098: 74ff moveq #-1,%d2
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
5509a: bd80 eorl %d6,%d0
5509c: 4a00 tstb %d0
5509e: 57c0 seq %d0
550a0: 4480 negl %d0
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
550a2: b485 cmpl %d5,%d2
550a4: 6712 beqs 550b8 <msdos_long_to_short+0xd0> <== ALWAYS TAKEN
{
if (is_dot || ((count - dot_at) > 3))
550a6: 4a00 tstb %d0 <== NOT EXECUTED
550a8: 6600 008a bnew 55134 <msdos_long_to_short+0x14c> <== NOT EXECUTED
550ac: 2003 movel %d3,%d0 <== NOT EXECUTED
550ae: 9085 subl %d5,%d0 <== NOT EXECUTED
550b0: 7403 moveq #3,%d2 <== NOT EXECUTED
550b2: b480 cmpl %d0,%d2 <== NOT EXECUTED
550b4: 6c14 bges 550ca <msdos_long_to_short+0xe2> <== NOT EXECUTED
550b6: 607c bras 55134 <msdos_long_to_short+0x14c> <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
550b8: 7408 moveq #8,%d2
550ba: b483 cmpl %d3,%d2
550bc: 6608 bnes 550c6 <msdos_long_to_short+0xde>
550be: 4a00 tstb %d0
550c0: 6772 beqs 55134 <msdos_long_to_short+0x14c> <== ALWAYS TAKEN
550c2: 7a08 moveq #8,%d5 <== NOT EXECUTED
550c4: 6034 bras 550fa <msdos_long_to_short+0x112> <== NOT EXECUTED
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
550c6: 4a00 tstb %d0
550c8: 6626 bnes 550f0 <msdos_long_to_short+0x108> <== NEVER TAKEN
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
550ca: 2006 movel %d6,%d0
550cc: 0680 ffff ffbf addil #-65,%d0
550d2: 7419 moveq #25,%d2
550d4: 0280 0000 00ff andil #255,%d0
550da: b480 cmpl %d0,%d2
550dc: 6416 bccs 550f4 <msdos_long_to_short+0x10c> <== NEVER TAKEN
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
550de: 0686 ffff ff9f addil #-97,%d6
550e4: 0286 0000 00ff andil #255,%d6
550ea: b486 cmpl %d6,%d2
550ec: 640a bccs 550f8 <msdos_long_to_short+0x110>
550ee: 600a bras 550fa <msdos_long_to_short+0x112>
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
550f0: 2a03 movel %d3,%d5 <== NOT EXECUTED
550f2: 6006 bras 550fa <msdos_long_to_short+0x112> <== NOT EXECUTED
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
550f4: 7e01 moveq #1,%d7 <== NOT EXECUTED
550f6: 6002 bras 550fa <msdos_long_to_short+0x112> <== NOT EXECUTED
else if ((*name >= 'a') && (*name <= 'z'))
lowercase = true;
550f8: 7201 moveq #1,%d1
count++;
550fa: 5283 addql #1,%d3
550fc: 600c bras 5510a <msdos_long_to_short+0x122>
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
550fe: 4283 clrl %d3
55100: 7aff moveq #-1,%d5
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
55102: 4bfa fe78 lea %pc@(54f7c <msdos_is_valid_name_char>),%a5
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
55106: 4207 clrb %d7
55108: 4201 clrb %d1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
5510a: 1c1c moveb %a4@+,%d6
5510c: 6706 beqs 55114 <msdos_long_to_short+0x12c>
5510e: b883 cmpl %d3,%d4
55110: 6e00 ff62 bgtw 55074 <msdos_long_to_short+0x8c>
count++;
name++;
}
if (lowercase && uppercase)
55114: 4a01 tstb %d1
55116: 6720 beqs 55138 <msdos_long_to_short+0x150> <== NEVER TAKEN
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
55118: 4a07 tstb %d7
5511a: 56c2 sne %d2
5511c: 7001 moveq #1,%d0
5511e: 49c2 extbl %d2
55120: 9082 subl %d2,%d0
55122: 2400 movel %d0,%d2
55124: 6014 bras 5513a <msdos_long_to_short+0x152>
if (i == lfn_len)
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
55126: 4282 clrl %d2 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
55128: 2002 movel %d2,%d0
5512a: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
55130: 4e5e unlk %fp
55132: 4e75 rts
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
55134: 7402 moveq #2,%d2
55136: 6002 bras 5513a <msdos_long_to_short+0x152>
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
55138: 7401 moveq #1,%d2 <== NOT EXECUTED
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
5513a: 2f0b movel %a3,%sp@-
5513c: 2f04 movel %d4,%sp@-
5513e: 2f0a movel %a2,%sp@-
55140: 4eb9 0005 74f6 jsr 574f6 <msdos_filename_unix2dos>
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
55146: 4fef 000c lea %sp@(12),%sp
5514a: 60dc bras 55128 <msdos_long_to_short+0x140>
0004d15c <msdos_mknod>:
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
4d15c: 4e56 ffec linkw %fp,#-20
4d160: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
4d164: 266e 0018 moveal %fp@(24),%a3
4d168: 282e 000c movel %fp@(12),%d4
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4d16c: 2004 movel %d4,%d0
rtems_filesystem_location_info_t *pathloc
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
4d16e: 206b 0010 moveal %a3@(16),%a0
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4d172: 0280 0000 f000 andil #61440,%d0
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
4d178: 262e 0008 movel %fp@(8),%d3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
4d17c: 2468 0034 moveal %a0@(52),%a2
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4d180: 0c80 0000 4000 cmpil #16384,%d0
4d186: 6716 beqs 4d19e <msdos_mknod+0x42>
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
4d188: 0c80 0000 8000 cmpil #32768,%d0
4d18e: 6712 beqs 4d1a2 <msdos_mknod+0x46> <== ALWAYS TAKEN
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
4d190: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4d196: 7216 moveq #22,%d1 <== NOT EXECUTED
4d198: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d19a: 2081 movel %d1,%a0@ <== NOT EXECUTED
4d19c: 6028 bras 4d1c6 <msdos_mknod+0x6a> <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
4d19e: 7401 moveq #1,%d2
4d1a0: 6002 bras 4d1a4 <msdos_mknod+0x48>
}
else if (S_ISREG(mode))
{
type = MSDOS_REGULAR_FILE;
4d1a2: 7405 moveq #5,%d2
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4d1a4: 42a7 clrl %sp@-
4d1a6: 42a7 clrl %sp@-
4d1a8: 2f2a 0088 movel %a2@(136),%sp@-
4d1ac: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4d1b2: 4fef 000c lea %sp@(12),%sp
4d1b6: 4a80 tstl %d0
4d1b8: 6710 beqs 4d1ca <msdos_mknod+0x6e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
4d1ba: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4d1c0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d1c2: 7005 moveq #5,%d0 <== NOT EXECUTED
4d1c4: 2080 movel %d0,%a0@ <== NOT EXECUTED
4d1c6: 74ff moveq #-1,%d2 <== NOT EXECUTED
4d1c8: 602a bras 4d1f4 <msdos_mknod+0x98> <== NOT EXECUTED
/* Create an MSDOS node */
rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
4d1ca: 2f03 movel %d3,%sp@-
4d1cc: 4eb9 0005 95bc jsr 595bc <strlen>
4d1d2: 4297 clrl %sp@
4d1d4: 2f04 movel %d4,%sp@-
4d1d6: 2f00 movel %d0,%sp@-
4d1d8: 2f03 movel %d3,%sp@-
4d1da: 2f02 movel %d2,%sp@-
4d1dc: 2f0b movel %a3,%sp@-
4d1de: 4eb9 0005 4084 jsr 54084 <msdos_creat_node>
rtems_semaphore_release(fs_info->vol_sema);
4d1e4: 2f2a 0088 movel %a2@(136),%sp@-
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
/* Create an MSDOS node */
rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
4d1e8: 2400 movel %d0,%d2
rtems_semaphore_release(fs_info->vol_sema);
4d1ea: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
return rc;
4d1f0: 4fef 001c lea %sp@(28),%sp
}
4d1f4: 2002 movel %d2,%d0
4d1f6: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
4d1fc: 4e5e unlk %fp <== NOT EXECUTED
0004d214 <msdos_rename>:
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
4d214: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
4d218: 48d7 3c04 moveml %d2/%a2-%a5,%sp@ <== NOT EXECUTED
4d21c: 2a6e 0010 moveal %fp@(16),%a5 <== NOT EXECUTED
4d220: 266e 000c moveal %fp@(12),%a3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
4d224: 206d 0010 moveal %a5@(16),%a0 <== NOT EXECUTED
fat_file_fd_t *old_fat_fd = old_loc->node_access;
4d228: 2853 moveal %a3@,%a4 <== NOT EXECUTED
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
4d22a: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
4d22e: 242e 0014 movel %fp@(20),%d2 <== NOT EXECUTED
int len;
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
4d232: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d234: 4eb9 0005 95bc jsr 595bc <strlen> <== NOT EXECUTED
4d23a: 588f addql #4,%sp <== NOT EXECUTED
4d23c: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4d240: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
4d244: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d246: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d248: 4eb9 0005 514c jsr 5514c <msdos_get_token> <== NOT EXECUTED
4d24e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d252: 7203 moveq #3,%d1 <== NOT EXECUTED
4d254: b280 cmpl %d0,%d1 <== NOT EXECUTED
4d256: 670e beqs 4d266 <msdos_rename+0x52> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
4d258: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4d25e: 725b moveq #91,%d1 <== NOT EXECUTED
4d260: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d262: 2081 movel %d1,%a0@ <== NOT EXECUTED
4d264: 6022 bras 4d288 <msdos_rename+0x74> <== NOT EXECUTED
}
/*
* lock volume
*/
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4d266: 42a7 clrl %sp@- <== NOT EXECUTED
4d268: 42a7 clrl %sp@- <== NOT EXECUTED
4d26a: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
4d26e: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4d274: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4d278: 4a80 tstl %d0 <== NOT EXECUTED
4d27a: 6710 beqs 4d28c <msdos_rename+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4d27c: 4eb9 0005 7e64 jsr 57e64 <__errno> <== NOT EXECUTED
4d282: 2040 moveal %d0,%a0 <== NOT EXECUTED
4d284: 7005 moveq #5,%d0 <== NOT EXECUTED
4d286: 2080 movel %d0,%a0@ <== NOT EXECUTED
4d288: 74ff moveq #-1,%d2 <== NOT EXECUTED
4d28a: 6052 bras 4d2de <msdos_rename+0xca> <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
4d28c: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4d28e: 2f3c 0000 8000 movel #32768,%sp@- <== NOT EXECUTED
4d294: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4d298: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d29a: 4878 0003 pea 3 <DIVIDE> <== NOT EXECUTED
4d29e: 2f0d movel %a5,%sp@- <== NOT EXECUTED
4d2a0: 4eb9 0005 4084 jsr 54084 <msdos_creat_node> <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,len,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
4d2a6: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
4d2aa: 2400 movel %d0,%d2 <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,len,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
4d2ac: 670e beqs 4d2bc <msdos_rename+0xa8> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
4d2ae: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
4d2b2: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
4d2b8: 588f addql #4,%sp <== NOT EXECUTED
4d2ba: 6022 bras 4d2de <msdos_rename+0xca> <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
4d2bc: 4878 00e5 pea e5 <DBL_MANT_DIG+0xb0> <== NOT EXECUTED
4d2c0: 486c 0020 pea %a4@(32) <== NOT EXECUTED
4d2c4: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
4d2c8: 4eb9 0005 5416 jsr 55416 <msdos_set_first_char4file_name> <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
rtems_semaphore_release(fs_info->vol_sema);
4d2ce: 2f2a 0088 movel %a2@(136),%sp@- <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
4d2d2: 2400 movel %d0,%d2 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
rtems_semaphore_release(fs_info->vol_sema);
4d2d4: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
4d2da: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
4d2de: 2002 movel %d2,%d0 <== NOT EXECUTED
4d2e0: 4cee 3c04 ffe4 moveml %fp@(-28),%d2/%a2-%a5 <== NOT EXECUTED
4d2e6: 4e5e unlk %fp <== NOT EXECUTED
...
0005521a <msdos_set_dir_wrt_time_and_date>:
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
5521a: 4e56 ffe0 linkw %fp,#-32
5521e: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
55222: 246e 0008 moveal %fp@(8),%a2
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
55226: 49ee fffc lea %fp@(-4),%a4
5522a: 260e movel %fp,%d3
5522c: 5583 subql #2,%d3
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
5522e: 4282 clrl %d2
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0, ret3 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
55230: 2a6a 0034 moveal %a2@(52),%a5
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
55234: 2f0c movel %a4,%sp@-
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
55236: 266e 000c moveal %fp@(12),%a3
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
5523a: 2f03 movel %d3,%sp@-
5523c: 2f2b 003e movel %a3@(62),%sp@-
55240: 4eb9 0005 7318 jsr 57318 <msdos_date_unix2dos>
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55246: 2f2b 0020 movel %a3@(32),%sp@-
5524a: 2f2a 0034 movel %a2@(52),%sp@-
5524e: 4eba fcf4 jsr %pc@(54f44 <fat_cluster_num_to_sector_num.isra.0>)
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55252: 222b 0024 movel %a3@(36),%d1
55256: 142d 0002 moveb %a5@(2),%d2
5525a: 2801 movel %d1,%d4
5525c: e4ac lsrl %d2,%d4
5525e: 2404 movel %d4,%d2
55260: d480 addl %d0,%d2
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55262: 4280 clrl %d0
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55264: 508f addql #8,%sp
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55266: 3015 movew %a5@,%d0
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55268: 2f0c movel %a4,%sp@-
5526a: 4878 0002 pea 2 <DOUBLE_FLOAT>
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
5526e: 2640 moveal %d0,%a3
55270: 538b subql #1,%a3
55272: 200b movel %a3,%d0
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55274: 49f9 0005 084a lea 5084a <_fat_block_write>,%a4
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
5527a: c081 andl %d1,%d0
time_val = CT_LE_W(time_val);
5527c: 4281 clrl %d1
5527e: 322e fffc movew %fp@(-4),%d1
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55282: 2640 moveal %d0,%a3
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55284: 486b 0016 pea %a3@(22)
static inline uint16_t m68k_swap_u16(
uint16_t value
)
{
return (((value & 0xff) << 8) | ((value >> 8) & 0xff));
55288: 2001 movel %d1,%d0
5528a: e089 lsrl #8,%d1
5528c: e188 lsll #8,%d0
5528e: 2f02 movel %d2,%sp@-
55290: 8081 orl %d1,%d0
55292: 2f0a movel %a2,%sp@-
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
55294: 3d40 fffc movew %d0,%fp@(-4)
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
55298: 4e94 jsr %a4@
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
5529a: 4fef 001c lea %sp@(28),%sp
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
5529e: 4281 clrl %d1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
552a0: 2800 movel %d0,%d4
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
552a2: 2e83 movel %d3,%sp@
552a4: 4878 0002 pea 2 <DOUBLE_FLOAT>
552a8: 486b 0018 pea %a3@(24)
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
552ac: 322e fffe movew %fp@(-2),%d1
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
552b0: 2f02 movel %d2,%sp@-
552b2: 2001 movel %d1,%d0
552b4: e089 lsrl #8,%d1
552b6: e188 lsll #8,%d0
552b8: 2f0a movel %a2,%sp@-
552ba: 8081 orl %d1,%d0
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
552bc: 3d40 fffe movew %d0,%fp@(-2)
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
552c0: 4e94 jsr %a4@
552c2: 2a40 moveal %d0,%a5
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
552c4: 2f03 movel %d3,%sp@-
552c6: 4878 0002 pea 2 <DOUBLE_FLOAT>
552ca: 486b 0012 pea %a3@(18)
552ce: 2f02 movel %d2,%sp@-
552d0: 2f0a movel %a2,%sp@-
552d2: 4e94 jsr %a4@
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
552d4: 4fef 0028 lea %sp@(40),%sp
552d8: 4a84 tstl %d4
552da: 6d0c blts 552e8 <msdos_set_dir_wrt_time_and_date+0xce><== NEVER TAKEN
552dc: 4a8d tstl %a5
552de: 6d08 blts 552e8 <msdos_set_dir_wrt_time_and_date+0xce><== NEVER TAKEN
return -1;
552e0: 4a80 tstl %d0
552e2: 5dc0 slt %d0
552e4: 49c0 extbl %d0
552e6: 6002 bras 552ea <msdos_set_dir_wrt_time_and_date+0xd0>
552e8: 70ff moveq #-1,%d0 <== NOT EXECUTED
return RC_OK;
}
552ea: 4cee 3c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a5
552f0: 4e5e unlk %fp <== NOT EXECUTED
00055416 <msdos_set_first_char4file_name>:
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
55416: 4e56 ffcc linkw %fp,#-52 <== NOT EXECUTED
5541a: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
5541e: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
55422: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
55426: 2028 0008 movel %a0@(8),%d0 <== NOT EXECUTED
5542a: 2228 000c movel %a0@(12),%d1 <== NOT EXECUTED
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
5542e: 246b 0034 moveal %a3@(52),%a2 <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
55432: 2410 movel %a0@,%d2 <== NOT EXECUTED
55434: 2e28 0004 movel %a0@(4),%d7 <== NOT EXECUTED
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
55438: 1d6e 0013 fff6 moveb %fp@(19),%fp@(-10) <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
5543e: 2d40 fff8 movel %d0,%fp@(-8) <== NOT EXECUTED
55442: 2d41 fffc movel %d1,%fp@(-4) <== NOT EXECUTED
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
55446: b4aa 0034 cmpl %a2@(52),%d2 <== NOT EXECUTED
5544a: 6612 bnes 5545e <msdos_set_first_char4file_name+0x48><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
5544c: 4280 clrl %d0 <== NOT EXECUTED
5544e: 102a 000a moveb %a2@(10),%d0 <== NOT EXECUTED
55452: 7203 moveq #3,%d1 <== NOT EXECUTED
55454: c081 andl %d1,%d0 <== NOT EXECUTED
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
55456: 6706 beqs 5545e <msdos_set_first_char4file_name+0x48><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
55458: 262a 0024 movel %a2@(36),%d3 <== NOT EXECUTED
5545c: 6006 bras 55464 <msdos_set_first_char4file_name+0x4e><== NOT EXECUTED
else
dir_block_size = fs_info->fat.vol.bpc;
5545e: 4283 clrl %d3 <== NOT EXECUTED
55460: 362a 0006 movew %a2@(6),%d3 <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
55464: 78ff moveq #-1,%d4 <== NOT EXECUTED
55466: b8a8 0008 cmpl %a0@(8),%d4 <== NOT EXECUTED
5546a: 660e bnes 5547a <msdos_set_first_char4file_name+0x64><== NOT EXECUTED
start = dir_pos->sname;
5546c: 2010 movel %a0@,%d0 <== NOT EXECUTED
5546e: 2228 0004 movel %a0@(4),%d1 <== NOT EXECUTED
55472: 2d40 fff8 movel %d0,%fp@(-8) <== NOT EXECUTED
55476: 2d41 fffc movel %d1,%fp@(-4) <== NOT EXECUTED
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
&fchar);
5547a: 2a0e movel %fp,%d5 <== NOT EXECUTED
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
5547c: 2c3c 0005 4f44 movel #347972,%d6 <== NOT EXECUTED
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
&fchar);
55482: 0685 ffff fff6 addil #-10,%d5 <== NOT EXECUTED
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
55488: 4bf9 0005 084a lea 5084a <_fat_block_write>,%a5 <== NOT EXECUTED
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
5548e: 49f9 0005 67b8 lea 567b8 <fat_get_fat_cluster>,%a4 <== NOT EXECUTED
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
55494: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
55498: 2046 moveal %d6,%a0 <== NOT EXECUTED
5549a: 2f2b 0034 movel %a3@(52),%sp@- <== NOT EXECUTED
5549e: 4e90 jsr %a0@ <== NOT EXECUTED
554a0: 508f addql #8,%sp <== NOT EXECUTED
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
554a2: 4281 clrl %d1 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
554a4: 2f05 movel %d5,%sp@- <== NOT EXECUTED
554a6: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
554aa: 282e fffc movel %fp@(-4),%d4 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
554ae: 3212 movew %a2@,%d1 <== NOT EXECUTED
554b0: 2041 moveal %d1,%a0 <== NOT EXECUTED
554b2: 5388 subql #1,%a0 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
554b4: 2208 movel %a0,%d1 <== NOT EXECUTED
554b6: 2040 moveal %d0,%a0 <== NOT EXECUTED
554b8: c284 andl %d4,%d1 <== NOT EXECUTED
554ba: 2f01 movel %d1,%sp@- <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
554bc: 4281 clrl %d1 <== NOT EXECUTED
554be: 122a 0002 moveb %a2@(2),%d1 <== NOT EXECUTED
554c2: e2ac lsrl %d1,%d4 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
554c4: 4870 4800 pea %a0@(00000000,%d4:l) <== NOT EXECUTED
554c8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
554ca: 4e95 jsr %a5@ <== NOT EXECUTED
&fchar);
if (ret < 0)
554cc: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
554d0: 4a80 tstl %d0 <== NOT EXECUTED
554d2: 6d4c blts 55520 <msdos_set_first_char4file_name+0x10a><== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
554d4: 222e fff8 movel %fp@(-8),%d1 <== NOT EXECUTED
554d8: b481 cmpl %d1,%d2 <== NOT EXECUTED
554da: 6606 bnes 554e2 <msdos_set_first_char4file_name+0xcc><== NOT EXECUTED
554dc: beae fffc cmpl %fp@(-4),%d7 <== NOT EXECUTED
554e0: 6742 beqs 55524 <msdos_set_first_char4file_name+0x10e><== NOT EXECUTED
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
554e2: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
554e6: 0680 0000 0020 addil #32,%d0 <== NOT EXECUTED
554ec: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
if (start.ofs >= dir_block_size)
554f0: b680 cmpl %d0,%d3 <== NOT EXECUTED
554f2: 62a0 bhis 55494 <msdos_set_first_char4file_name+0x7e><== NOT EXECUTED
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
554f4: b4aa 0034 cmpl %a2@(52),%d2 <== NOT EXECUTED
554f8: 660c bnes 55506 <msdos_set_first_char4file_name+0xf0><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
554fa: 4280 clrl %d0 <== NOT EXECUTED
554fc: 102a 000a moveb %a2@(10),%d0 <== NOT EXECUTED
55500: 7803 moveq #3,%d4 <== NOT EXECUTED
55502: c084 andl %d4,%d0 <== NOT EXECUTED
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
55504: 661e bnes 55524 <msdos_set_first_char4file_name+0x10e><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
55506: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
5550a: 2f01 movel %d1,%sp@- <== NOT EXECUTED
5550c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5550e: 4e94 jsr %a4@ <== NOT EXECUTED
if ( rc != RC_OK )
55510: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55514: 4a80 tstl %d0 <== NOT EXECUTED
55516: 660e bnes 55526 <msdos_set_first_char4file_name+0x110><== NOT EXECUTED
return rc;
start.ofs = 0;
55518: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
5551c: 6000 ff76 braw 55494 <msdos_set_first_char4file_name+0x7e><== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
&fchar);
if (ret < 0)
return -1;
55520: 70ff moveq #-1,%d0 <== NOT EXECUTED
55522: 6002 bras 55526 <msdos_set_first_char4file_name+0x110><== NOT EXECUTED
return rc;
start.ofs = 0;
}
}
return RC_OK;
55524: 4280 clrl %d0 <== NOT EXECUTED
}
55526: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5 <== NOT EXECUTED
5552c: 4e5e unlk %fp <== NOT EXECUTED
000552f4 <msdos_set_first_cluster_num>:
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
552f4: 4e56 ffe4 linkw %fp,#-28
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
552f8: 4240 clrw %d0
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
552fa: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
552fe: 286e 000c moveal %fp@(12),%a4
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55302: 4282 clrl %d2
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
55304: 246e 0008 moveal %fp@(8),%a2
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
55308: 262c 001c movel %a4@(28),%d3
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
5530c: 266a 0034 moveal %a2@(52),%a3
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55310: 2f2c 0020 movel %a4@(32),%sp@-
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
55314: 3d40 fffc movew %d0,%fp@(-4)
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55318: 2f0b movel %a3,%sp@-
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
uint16_t le_cl_hi = 0;
5531a: 3d40 fffe movew %d0,%fp@(-2)
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
5531e: 4eba fc24 jsr %pc@(54f44 <fat_cluster_num_to_sector_num.isra.0>)
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55322: 222c 0024 movel %a4@(36),%d1
55326: 142b 0002 moveb %a3@(2),%d2
5532a: 2801 movel %d1,%d4
5532c: e4ac lsrl %d2,%d4
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
5532e: 4282 clrl %d2
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
55330: 508f addql #8,%sp
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
55332: 2840 moveal %d0,%a4
55334: d9c4 addal %d4,%a4
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55336: 3413 movew %a3@,%d2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
55338: 486e fffc pea %fp@(-4)
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
5533c: 5382 subql #1,%d2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
5533e: 4878 0002 pea 2 <DOUBLE_FLOAT>
55342: 47f9 0005 084a lea 5084a <_fat_block_write>,%a3
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
55348: c481 andl %d1,%d2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
5534a: 4281 clrl %d1
5534c: 3203 movew %d3,%d1
ret1 = _fat_block_write(mt_entry, sec,
5534e: 2042 moveal %d2,%a0
55350: 4868 001a pea %a0@(26)
55354: 2001 movel %d1,%d0
55356: e089 lsrl #8,%d1
55358: e188 lsll #8,%d0
5535a: 2f0c movel %a4,%sp@-
5535c: 8081 orl %d1,%d0
5535e: 2f0a movel %a2,%sp@-
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
55360: 3d40 fffc movew %d0,%fp@(-4)
ret1 = _fat_block_write(mt_entry, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
55364: 4243 clrw %d3
55366: 4843 swap %d3
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
55368: 4e93 jsr %a3@
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
5536a: 204e moveal %fp,%a0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
5536c: 2800 movel %d0,%d4
5536e: 2003 movel %d3,%d0
55370: e08b lsrl #8,%d3
55372: e188 lsll #8,%d0
55374: 8083 orl %d3,%d0
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
55376: 3100 movew %d0,%a0@-
ret2 = _fat_block_write(mt_entry, sec,
55378: 2f08 movel %a0,%sp@-
5537a: 4878 0002 pea 2 <DOUBLE_FLOAT>
5537e: 2042 moveal %d2,%a0
55380: 4868 0014 pea %a0@(20)
55384: 2f0c movel %a4,%sp@-
55386: 2f0a movel %a2,%sp@-
55388: 4e93 jsr %a3@
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
5538a: 4fef 0028 lea %sp@(40),%sp
5538e: 4a84 tstl %d4
55390: 6d08 blts 5539a <msdos_set_first_cluster_num+0xa6><== NEVER TAKEN
return -1;
55392: 4a80 tstl %d0
55394: 5dc0 slt %d0
55396: 49c0 extbl %d0
55398: 6002 bras 5539c <msdos_set_first_cluster_num+0xa8>
5539a: 70ff moveq #-1,%d0 <== NOT EXECUTED
return RC_OK;
}
5539c: 4cee 1c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a4
553a2: 4e5e unlk %fp <== NOT EXECUTED
00054eb0 <msdos_shut_down>:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
54eb0: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
54eb4: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
54eb8: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
54ebc: 266a 0034 moveal %a2@(52),%a3 <== NOT EXECUTED
fat_file_fd_t *fat_fd = temp_mt_entry->mt_fs_root.node_access;
/* close fat-file which correspondes to root directory */
if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)
54ec0: 2f2a 001c movel %a2@(28),%sp@- <== NOT EXECUTED
54ec4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
54ec6: 4eb9 0004 fdc6 jsr 4fdc6 <fat_file_close> <== NOT EXECUTED
54ecc: 508f addql #8,%sp <== NOT EXECUTED
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
int rc = RC_OK;
54ece: 4a80 tstl %d0 <== NOT EXECUTED
54ed0: 56c2 sne %d2 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
54ed2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
int rc = RC_OK;
54ed4: 49c2 extbl %d2 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
54ed6: 4eb9 0005 0ba4 jsr 50ba4 <fat_shutdown_drive> <== NOT EXECUTED
54edc: 588f addql #4,%sp <== NOT EXECUTED
54ede: 4a80 tstl %d0 <== NOT EXECUTED
54ee0: 6702 beqs 54ee4 <msdos_shut_down+0x34> <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
54ee2: 74ff moveq #-1,%d2 <== NOT EXECUTED
}
rtems_semaphore_delete(fs_info->vol_sema);
54ee4: 2f2b 0088 movel %a3@(136),%sp@- <== NOT EXECUTED
54ee8: 4eb9 0004 8e74 jsr 48e74 <rtems_semaphore_delete> <== NOT EXECUTED
free(fs_info->cl_buf);
54eee: 2f2b 008c movel %a3@(140),%sp@- <== NOT EXECUTED
54ef2: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
54ef8: 4e93 jsr %a3@ <== NOT EXECUTED
free(temp_mt_entry->fs_info);
54efa: 2f2a 0034 movel %a2@(52),%sp@- <== NOT EXECUTED
54efe: 4e93 jsr %a3@ <== NOT EXECUTED
return rc;
}
54f00: 2002 movel %d2,%d0 <== NOT EXECUTED
54f02: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3 <== NOT EXECUTED
54f08: 4e5e unlk %fp <== NOT EXECUTED
00043546 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
43546: 4e56 fff4 linkw %fp,#-12
4354a: 48d7 040c moveml %d2-%d3/%a2,%sp@
4354e: 262e 0008 movel %fp@(8),%d3
43552: 246e 000c moveal %fp@(12),%a2
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
43556: b5c3 cmpal %d3,%a2
43558: 6608 bnes 43562 <newlib_delete_hook+0x1c>
ptr = _REENT;
4355a: 2439 0005 c1b4 movel 5c1b4 <_impure_ptr>,%d2
43560: 6004 bras 43566 <newlib_delete_hook+0x20>
} else {
ptr = deleted_task->libc_reent;
43562: 242a 00f8 movel %a2@(248),%d2
}
if (ptr && ptr != _global_impure_ptr) {
43566: 4a82 tstl %d2
43568: 6722 beqs 4358c <newlib_delete_hook+0x46> <== NEVER TAKEN
4356a: b4b9 0005 b6fa cmpl 5b6fa <_global_impure_ptr>,%d2
43570: 671a beqs 4358c <newlib_delete_hook+0x46>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
43572: 4879 0004 3358 pea 43358 <newlib_free_buffers>
43578: 2f02 movel %d2,%sp@-
4357a: 4eb9 0004 c784 jsr 4c784 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
43580: 2f02 movel %d2,%sp@-
43582: 4eb9 0004 8b3c jsr 48b3c <_Workspace_Free>
43588: 4fef 000c lea %sp@(12),%sp
#endif
}
deleted_task->libc_reent = NULL;
4358c: 42aa 00f8 clrl %a2@(248)
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
43590: b5c3 cmpal %d3,%a2
43592: 6606 bnes 4359a <newlib_delete_hook+0x54>
_REENT = 0;
43594: 42b9 0005 c1b4 clrl 5c1b4 <_impure_ptr>
}
}
4359a: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
435a0: 4e5e unlk %fp <== NOT EXECUTED
00043358 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
43358: 4e56 0000 linkw %fp,#0
4335c: 2f0a movel %a2,%sp@-
4335e: 246e 0008 moveal %fp@(8),%a2
switch ( fileno(fp) ) {
43362: 2f0a movel %a2,%sp@-
43364: 4eb9 0004 c3f8 jsr 4c3f8 <fileno>
4336a: 588f addql #4,%sp
4336c: 7202 moveq #2,%d1
4336e: b280 cmpl %d0,%d1
43370: 6528 bcss 4339a <newlib_free_buffers+0x42> <== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
43372: 302a 000c movew %a2@(12),%d0
43376: 48c0 extl %d0
43378: 4a00 tstb %d0
4337a: 6c28 bges 433a4 <newlib_free_buffers+0x4c> <== ALWAYS TAKEN
free( fp->_bf._base );
4337c: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
43380: 4eb9 0004 2b68 jsr 42b68 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
43386: 302a 000c movew %a2@(12),%d0 <== NOT EXECUTED
4338a: 0880 0007 bclr #7,%d0 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
4338e: 4292 clrl %a2@ <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
43390: 3540 000c movew %d0,%a2@(12) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
43394: 42aa 0010 clrl %a2@(16) <== NOT EXECUTED
43398: 6008 bras 433a2 <newlib_free_buffers+0x4a> <== NOT EXECUTED
}
break;
default:
fclose(fp);
4339a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4339c: 4eb9 0004 c168 jsr 4c168 <fclose> <== NOT EXECUTED
433a2: 588f addql #4,%sp <== NOT EXECUTED
}
return 0;
}
433a4: 246e fffc moveal %fp@(-4),%a2
433a8: 4280 clrl %d0
433aa: 4e5e unlk %fp <== NOT EXECUTED
000413c2 <notify>:
void
notify (s)
char *s;
{
413c2: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
413c6: 2f2e 0008 movel %fp@(8),%sp@- <== NOT EXECUTED
413ca: 4879 0006 8456 pea 68456 <rtems_filesystem_table+0x30e> <== NOT EXECUTED
413d0: 4eb9 0005 b404 jsr 5b404 <printf> <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
413d6: 508f addql #8,%sp <== NOT EXECUTED
413d8: 203c 0006 847d movel #427133,%d0 <== NOT EXECUTED
413de: 2d40 0008 movel %d0,%fp@(8) <== NOT EXECUTED
}
413e2: 4e5e unlk %fp <== NOT EXECUTED
void
notify (s)
char *s;
{
printf ("%s test appears to be inconsistent...\n", s);
printf (" PLEASE NOTIFY KARPINKSI!\n");
413e4: 4ef9 0005 b4fe jmp 5b4fe <puts> <== NOT EXECUTED
00043614 <open>:
int open(
const char *pathname,
int flags,
...
)
{
43614: 4e56 ffc8 linkw %fp,#-56
43618: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4361c: 242e 000c movel %fp@(12),%d2
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
43620: 2002 movel %d2,%d0
43622: 5280 addql #1,%d0
int open(
const char *pathname,
int flags,
...
)
{
43624: 262e 0008 movel %fp@(8),%d3
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
43628: 0800 0000 btst #0,%d0
4362c: 6704 beqs 43632 <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_READ;
4362e: 7804 moveq #4,%d4
43630: 6002 bras 43634 <open+0x20>
int eval_flags;
/*
* Set the Evaluation flags
*/
eval_flags = 0;
43632: 4284 clrl %d4
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
43634: 0800 0001 btst #1,%d0
43638: 6704 beqs 4363e <open+0x2a>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
4363a: 7002 moveq #2,%d0
4363c: 8880 orl %d0,%d4
va_start(ap, flags);
mode = va_arg( ap, int );
4363e: 2c2e 0010 movel %fp@(16),%d6
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
43642: 4eb9 0004 9d64 jsr 49d64 <rtems_libio_allocate>
43648: 2440 moveal %d0,%a2
if ( iop == 0 ) {
4364a: 4a80 tstl %d0
4364c: 6700 0158 beqw 437a6 <open+0x192>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
43650: 2f03 movel %d3,%sp@-
43652: 4bf9 0004 d3a0 lea 4d3a0 <strlen>,%a5
43658: 7a01 moveq #1,%d5
4365a: 49f9 0004 2a88 lea 42a88 <rtems_filesystem_evaluate_path>,%a4
43660: 4e95 jsr %a5@
43662: 2e85 movel %d5,%sp@
43664: 2a0e movel %fp,%d5
43666: 0685 ffff ffec addil #-20,%d5
4366c: 2f05 movel %d5,%sp@-
4366e: 2f04 movel %d4,%sp@-
43670: 2f00 movel %d0,%sp@-
43672: 2f03 movel %d3,%sp@-
43674: 4e94 jsr %a4@
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
43676: 4fef 0014 lea %sp@(20),%sp
4367a: 72ff moveq #-1,%d1
4367c: b280 cmpl %d0,%d1
4367e: 665e bnes 436de <open+0xca>
if ( errno != ENOENT ) {
43680: 47f9 0004 c034 lea 4c034 <__errno>,%a3
43686: 4e93 jsr %a3@
43688: 7202 moveq #2,%d1
4368a: 2040 moveal %d0,%a0
4368c: b290 cmpl %a0@,%d1
4368e: 6624 bnes 436b4 <open+0xa0>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
43690: 0802 0009 btst #9,%d2
43694: 6700 0114 beqw 437aa <open+0x196>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
43698: 42a7 clrl %sp@-
4369a: 2006 movel %d6,%d0
4369c: 42a7 clrl %sp@-
4369e: 08c0 000f bset #15,%d0
436a2: 2f00 movel %d0,%sp@-
436a4: 2f03 movel %d3,%sp@-
436a6: 4eb9 0004 2f20 jsr 42f20 <mknod>
if ( rc ) {
436ac: 4fef 0010 lea %sp@(16),%sp
436b0: 4a80 tstl %d0
436b2: 670c beqs 436c0 <open+0xac> <== ALWAYS TAKEN
rc = errno;
436b4: 4e93 jsr %a3@
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
436b6: 4285 clrl %d5
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
436b8: 2040 moveal %d0,%a0
436ba: 2410 movel %a0@,%d2
goto done;
436bc: 6000 00fc braw 437ba <open+0x1a6>
/*
* After we do the mknod(), we have to evaluate the path to get the
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
436c0: 2f03 movel %d3,%sp@-
436c2: 4e95 jsr %a5@
436c4: 7201 moveq #1,%d1
436c6: 2e81 movel %d1,%sp@
436c8: 2f05 movel %d5,%sp@-
436ca: 42a7 clrl %sp@-
436cc: 2f00 movel %d0,%sp@-
436ce: 2f03 movel %d3,%sp@-
436d0: 4e94 jsr %a4@
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
436d2: 4fef 0014 lea %sp@(20),%sp
436d6: 4a80 tstl %d0
436d8: 6600 00d6 bnew 437b0 <open+0x19c>
436dc: 6012 bras 436f0 <open+0xdc>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
436de: 2002 movel %d2,%d0
436e0: 0280 0000 0a00 andil #2560,%d0
436e6: 0c80 0000 0a00 cmpil #2560,%d0
436ec: 6700 00c8 beqw 437b6 <open+0x1a2>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
436f0: 282a 0014 movel %a2@(20),%d4
iop->pathinfo = loc;
436f4: 2a0e movel %fp,%d5
436f6: 0685 ffff ffec addil #-20,%d5
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
436fc: 2f02 movel %d2,%sp@-
436fe: 4eb9 0004 9cd6 jsr 49cd6 <rtems_libio_fcntl_flags>
43704: 8084 orl %d4,%d0
43706: 2540 0014 movel %d0,%a2@(20)
iop->pathinfo = loc;
4370a: 4878 0014 pea 14 <OPER2>
4370e: 2f05 movel %d5,%sp@-
43710: 486a 0018 pea %a2@(24)
43714: 4eb9 0004 c854 jsr 4c854 <memcpy>
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
4371a: 206a 0020 moveal %a2@(32),%a0
4371e: 2f06 movel %d6,%sp@-
43720: 2f02 movel %d2,%sp@-
43722: 2f03 movel %d3,%sp@-
43724: 2f0a movel %a2,%sp@-
43726: 2050 moveal %a0@,%a0
43728: 4e90 jsr %a0@
if ( rc ) {
4372a: 4fef 0020 lea %sp@(32),%sp
4372e: 4a80 tstl %d0
43730: 670c beqs 4373e <open+0x12a>
rc = errno;
43732: 4eb9 0004 c034 jsr 4c034 <__errno>
43738: 2040 moveal %d0,%a0
4373a: 2410 movel %a0@,%d2
goto done;
4373c: 607c bras 437ba <open+0x1a6>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
4373e: 0802 000a btst #10,%d2
43742: 6700 00a4 beqw 437e8 <open+0x1d4>
rc = ftruncate( iop - rtems_libio_iops, 0 );
43746: 200a movel %a2,%d0
43748: 90b9 0005 d6d8 subl 5d6d8 <rtems_libio_iops>,%d0
4374e: 223c b6db 6db7 movel #-1227133513,%d1
43754: e680 asrl #3,%d0
43756: 4c00 1800 mulsl %d0,%d1
4375a: 42a7 clrl %sp@-
4375c: 42a7 clrl %sp@-
4375e: 2f01 movel %d1,%sp@-
43760: 4eb9 0004 9bf4 jsr 49bf4 <ftruncate>
if ( rc ) {
43766: 4fef 000c lea %sp@(12),%sp
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
4376a: 2400 movel %d0,%d2
if ( rc ) {
4376c: 677a beqs 437e8 <open+0x1d4>
if(errno) rc = errno;
4376e: 47f9 0004 c034 lea 4c034 <__errno>,%a3
43774: 4e93 jsr %a3@
43776: 2040 moveal %d0,%a0
43778: 4a90 tstl %a0@
4377a: 6706 beqs 43782 <open+0x16e> <== NEVER TAKEN
4377c: 4e93 jsr %a3@
4377e: 2040 moveal %d0,%a0
43780: 2410 movel %a0@,%d2
close( iop - rtems_libio_iops );
43782: 200a movel %a2,%d0
43784: 90b9 0005 d6d8 subl 5d6d8 <rtems_libio_iops>,%d0
4378a: 223c b6db 6db7 movel #-1227133513,%d1
43790: e680 asrl #3,%d0
43792: 4c00 1800 mulsl %d0,%d1
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
43796: 4285 clrl %d5
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
/* those are released by close(): */
iop = 0;
43798: 95ca subal %a2,%a2
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
4379a: 2f01 movel %d1,%sp@-
4379c: 4eb9 0004 9b70 jsr 49b70 <close>
437a2: 588f addql #4,%sp
437a4: 6014 bras 437ba <open+0x1a6>
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
437a6: 7417 moveq #23,%d2
437a8: 6030 bras 437da <open+0x1c6>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
437aa: 4285 clrl %d5
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
437ac: 7402 moveq #2,%d2
437ae: 600e bras 437be <open+0x1aa>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
437b0: 4285 clrl %d5
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
437b2: 740d moveq #13,%d2
437b4: 6008 bras 437be <open+0x1aa>
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
437b6: 7411 moveq #17,%d2
437b8: 6004 bras 437be <open+0x1aa>
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
437ba: 4a82 tstl %d2
437bc: 672a beqs 437e8 <open+0x1d4> <== NEVER TAKEN
if ( iop )
437be: 4a8a tstl %a2
437c0: 670a beqs 437cc <open+0x1b8>
rtems_libio_free( iop );
437c2: 2f0a movel %a2,%sp@-
437c4: 4eb9 0004 9df6 jsr 49df6 <rtems_libio_free>
437ca: 588f addql #4,%sp
if ( loc_to_free )
437cc: 4a85 tstl %d5
437ce: 670a beqs 437da <open+0x1c6>
rtems_filesystem_freenode( loc_to_free );
437d0: 2f05 movel %d5,%sp@-
437d2: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
437d8: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( rc );
437da: 4eb9 0004 c034 jsr 4c034 <__errno>
437e0: 2040 moveal %d0,%a0
437e2: 70ff moveq #-1,%d0
437e4: 2082 movel %d2,%a0@
437e6: 6014 bras 437fc <open+0x1e8>
}
return iop - rtems_libio_iops;
437e8: 200a movel %a2,%d0
437ea: 90b9 0005 d6d8 subl 5d6d8 <rtems_libio_iops>,%d0
437f0: 223c b6db 6db7 movel #-1227133513,%d1
437f6: e680 asrl #3,%d0
437f8: 4c01 0800 mulsl %d1,%d0
}
437fc: 4cee 3c7c ffc8 moveml %fp@(-56),%d2-%d6/%a2-%a5
43802: 4e5e unlk %fp <== NOT EXECUTED
000435a4 <open_dev_console>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void open_dev_console(void)
{
435a4: 4e56 0000 linkw %fp,#0
435a8: 2f0a movel %a2,%sp@-
int stderr_fd;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
435aa: 45f9 0004 3614 lea 43614 <open>,%a2
435b0: 42a7 clrl %sp@-
435b2: 42a7 clrl %sp@-
435b4: 4879 0005 ab98 pea 5ab98 <CSWTCH.48+0x100>
435ba: 4e92 jsr %a2@
435bc: 4fef 000c lea %sp@(12),%sp
435c0: 72ff moveq #-1,%d1
435c2: b280 cmpl %d0,%d1
435c4: 6744 beqs 4360a <open_dev_console+0x66>
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
435c6: 42a7 clrl %sp@-
435c8: 4878 0001 pea 1 <ADD>
435cc: 4879 0005 ab98 pea 5ab98 <CSWTCH.48+0x100>
435d2: 4e92 jsr %a2@
435d4: 4fef 000c lea %sp@(12),%sp
435d8: 72ff moveq #-1,%d1
435da: b280 cmpl %d0,%d1
435dc: 6608 bnes 435e6 <open_dev_console+0x42>
rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */
435de: 2f3c 5554 4431 movel #1431585841,%sp@-
435e4: 601e bras 43604 <open_dev_console+0x60>
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
435e6: 42a7 clrl %sp@-
435e8: 4878 0001 pea 1 <ADD>
435ec: 4879 0005 ab98 pea 5ab98 <CSWTCH.48+0x100>
435f2: 4e92 jsr %a2@
435f4: 4fef 000c lea %sp@(12),%sp
435f8: 72ff moveq #-1,%d1
435fa: b280 cmpl %d0,%d1
435fc: 660c bnes 4360a <open_dev_console+0x66> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 0x55544432 ); /* error STD2 */
435fe: 2f3c 5554 4432 movel #1431585842,%sp@- <== NOT EXECUTED
43604: 4eb9 0004 60a0 jsr 460a0 <rtems_fatal_error_occurred>
}
4360a: 246e fffc moveal %fp@(-4),%a2
4360e: 4e5e unlk %fp
...
0004431e <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4431e: 4e56 fff0 linkw %fp,#-16
44322: 48d7 040c moveml %d2-%d3/%a2,%sp@
44326: 246e 000c moveal %fp@(12),%a2
4432a: 242e 0008 movel %fp@(8),%d2
int i;
if (tty->termios.c_oflag & OPOST) {
4432e: 202a 0034 movel %a2@(52),%d0
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
44332: 1d42 fffe moveb %d2,%fp@(-2)
int i;
if (tty->termios.c_oflag & OPOST) {
44336: 0800 0000 btst #0,%d0
4433a: 6700 0106 beqw 44442 <oproc+0x124>
switch (c) {
4433e: 4281 clrl %d1
44340: 1202 moveb %d2,%d1
44342: 7609 moveq #9,%d3
44344: b681 cmpl %d1,%d3
44346: 6778 beqs 443c0 <oproc+0xa2>
44348: 650e bcss 44358 <oproc+0x3a>
4434a: 163c 0008 moveb #8,%d3
4434e: b681 cmpl %d1,%d3
44350: 6600 00aa bnew 443fc <oproc+0xde>
44354: 6000 0098 braw 443ee <oproc+0xd0> <== NOT EXECUTED
44358: 760a moveq #10,%d3
4435a: b681 cmpl %d1,%d3
4435c: 670c beqs 4436a <oproc+0x4c>
4435e: 163c 000d moveb #13,%d3
44362: b681 cmpl %d1,%d3
44364: 6600 0096 bnew 443fc <oproc+0xde>
44368: 602e bras 44398 <oproc+0x7a> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
4436a: 0800 0005 btst #5,%d0
4436e: 6704 beqs 44374 <oproc+0x56> <== ALWAYS TAKEN
tty->column = 0;
44370: 42aa 0028 clrl %a2@(40) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
44374: 44c0 movew %d0,%ccr
44376: 6600 00ca bnew 44442 <oproc+0x124>
rtems_termios_puts ("\r", 1, tty);
4437a: 2f0a movel %a2,%sp@-
4437c: 4878 0001 pea 1 <ADD>
44380: 4879 0005 b1f2 pea 5b1f2 <rtems_filesystem_default_pathconf+0xa6>
44386: 4eb9 0004 4230 jsr 44230 <rtems_termios_puts>
tty->column = 0;
4438c: 4fef 000c lea %sp@(12),%sp
44390: 42aa 0028 clrl %a2@(40)
44394: 6000 00ac braw 44442 <oproc+0x124>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
44398: 0800 0004 btst #4,%d0 <== NOT EXECUTED
4439c: 6708 beqs 443a6 <oproc+0x88> <== NOT EXECUTED
4439e: 4aaa 0028 tstl %a2@(40) <== NOT EXECUTED
443a2: 6700 00b2 beqw 44456 <oproc+0x138> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
443a6: 44c0 movew %d0,%ccr <== NOT EXECUTED
443a8: 6a0e bpls 443b8 <oproc+0x9a> <== NOT EXECUTED
c = '\n';
443aa: 720a moveq #10,%d1 <== NOT EXECUTED
443ac: 1d41 fffe moveb %d1,%fp@(-2) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
443b0: 0800 0005 btst #5,%d0 <== NOT EXECUTED
443b4: 6700 008c beqw 44442 <oproc+0x124> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
443b8: 42aa 0028 clrl %a2@(40) <== NOT EXECUTED
break;
443bc: 6000 0084 braw 44442 <oproc+0x124> <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
443c0: 222a 0028 movel %a2@(40),%d1
443c4: 7407 moveq #7,%d2
443c6: 307c 0008 moveaw #8,%a0
443ca: c481 andl %d1,%d2
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
443cc: 0280 0000 1800 andil #6144,%d0
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
443d2: 91c2 subal %d2,%a0
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
443d4: d288 addl %a0,%d1
443d6: 2541 0028 movel %d1,%a2@(40)
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
443da: 0c80 0000 1800 cmpil #6144,%d0
443e0: 6660 bnes 44442 <oproc+0x124> <== NEVER TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
443e2: 2f0a movel %a2,%sp@-
443e4: 2f08 movel %a0,%sp@-
443e6: 4879 0005 b1f4 pea 5b1f4 <rtems_filesystem_default_pathconf+0xa8>
443ec: 605e bras 4444c <oproc+0x12e>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
443ee: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED
443f2: 6f4e bles 44442 <oproc+0x124> <== NOT EXECUTED
tty->column--;
443f4: 5380 subql #1,%d0 <== NOT EXECUTED
443f6: 2540 0028 movel %d0,%a2@(40) <== NOT EXECUTED
443fa: 6046 bras 44442 <oproc+0x124> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
443fc: 0800 0001 btst #1,%d0
44400: 6724 beqs 44426 <oproc+0x108> <== ALWAYS TAKEN
c = toupper(c);
44402: 4280 clrl %d0 <== NOT EXECUTED
44404: 1002 moveb %d2,%d0 <== NOT EXECUTED
44406: 7403 moveq #3,%d2 <== NOT EXECUTED
44408: 7602 moveq #2,%d3 <== NOT EXECUTED
4440a: 2079 0005 c1b0 moveal 5c1b0 <__ctype_ptr__>,%a0 <== NOT EXECUTED
44410: 1230 0801 moveb %a0@(00000001,%d0:l),%d1 <== NOT EXECUTED
44414: 49c1 extbl %d1 <== NOT EXECUTED
44416: c282 andl %d2,%d1 <== NOT EXECUTED
44418: b681 cmpl %d1,%d3 <== NOT EXECUTED
4441a: 6606 bnes 44422 <oproc+0x104> <== NOT EXECUTED
4441c: 0680 ffff ffe0 addil #-32,%d0 <== NOT EXECUTED
44422: 1d40 fffe moveb %d0,%fp@(-2) <== NOT EXECUTED
if (!iscntrl(c))
44426: 4280 clrl %d0
44428: 102e fffe moveb %fp@(-2),%d0
4442c: 2079 0005 c1b0 moveal 5c1b0 <__ctype_ptr__>,%a0
44432: 1030 0801 moveb %a0@(00000001,%d0:l),%d0
44436: 49c0 extbl %d0
44438: 0800 0005 btst #5,%d0
4443c: 6604 bnes 44442 <oproc+0x124>
tty->column++;
4443e: 52aa 0028 addql #1,%a2@(40)
break;
}
}
rtems_termios_puts (&c, 1, tty);
44442: 2f0a movel %a2,%sp@-
44444: 4878 0001 pea 1 <ADD>
44448: 486e fffe pea %fp@(-2)
4444c: 4eb9 0004 4230 jsr 44230 <rtems_termios_puts>
44452: 4fef 000c lea %sp@(12),%sp
}
44456: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
4445c: 4e5e unlk %fp <== NOT EXECUTED
0004a82c <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
4a82c: 4e56 ffe4 linkw %fp,#-28
4a830: 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)
4a834: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
4a838: 4879 0005 c7cc pea 5c7cc <_CPU_m68k_BFFFO_table+0x100>
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
4a83e: 246e 0008 moveal %fp@(8),%a2
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
4a842: 4eb9 0004 bcb8 jsr 4bcb8 <rtems_mkdir>
4a848: 508f addql #8,%sp
4a84a: 4a80 tstl %d0
4a84c: 6600 00e8 bnew 4a936 <pipe_create+0x10a>
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
4a850: 4878 000a pea a <LASTO>
4a854: 260e movel %fp,%d3
4a856: 4879 0005 c7d1 pea 5c7d1 <_CPU_m68k_BFFFO_table+0x105>
4a85c: 0683 ffff fff1 addil #-15,%d3
4a862: 2f03 movel %d3,%sp@-
4a864: 4eb9 0004 da60 jsr 4da60 <memcpy>
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4a86a: 3039 0005 e2cc movew 5e2cc <rtems_pipe_no>,%d0
4a870: 2200 movel %d0,%d1
4a872: 5281 addql #1,%d1
4a874: 3f00 movew %d0,%sp@-
4a876: 33c1 0005 e2cc movew %d1,5e2cc <rtems_pipe_no>
4a87c: 4267 clrw %sp@-
4a87e: 4879 0005 c7dc pea 5c7dc <_CPU_m68k_BFFFO_table+0x110>
4a884: 486e fffb pea %fp@(-5)
4a888: 4eb9 0004 dedc jsr 4dedc <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4a88e: 4878 0180 pea 180 <DBL_MANT_DIG+0x14b>
4a892: 2f03 movel %d3,%sp@-
4a894: 4eb9 0004 ba74 jsr 4ba74 <mkfifo>
4a89a: 4fef 0020 lea %sp@(32),%sp
4a89e: 4a80 tstl %d0
4a8a0: 670a beqs 4a8ac <pipe_create+0x80>
if (errno != EEXIST){
4a8a2: 4eb9 0004 d240 jsr 4d240 <__errno>
4a8a8: 6000 008c braw 4a936 <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);
4a8ac: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
4a8b0: 2f03 movel %d3,%sp@-
4a8b2: 4eb9 0004 46a0 jsr 446a0 <open>
if (filsdes[0] < 0) {
4a8b8: 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);
4a8ba: 2480 movel %d0,%a2@
if (filsdes[0] < 0) {
4a8bc: 6c0e bges 4a8cc <pipe_create+0xa0>
err = errno;
4a8be: 4eb9 0004 d240 jsr 4d240 <__errno>
4a8c4: 2040 moveal %d0,%a0
4a8c6: 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);
4a8c8: 2f03 movel %d3,%sp@-
4a8ca: 6054 bras 4a920 <pipe_create+0xf4>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
4a8cc: b0b9 0005 d2c2 cmpl 5d2c2 <rtems_libio_number_iops>,%d0
4a8d2: 6412 bccs 4a8e6 <pipe_create+0xba> <== NEVER TAKEN
4a8d4: 2200 movel %d0,%d1
4a8d6: ed88 lsll #6,%d0
4a8d8: e789 lsll #3,%d1
4a8da: 2079 0005 e9c0 moveal 5e9c0 <rtems_libio_iops>,%a0
4a8e0: 9081 subl %d1,%d0
4a8e2: d1c0 addal %d0,%a0
4a8e4: 6002 bras 4a8e8 <pipe_create+0xbc>
4a8e6: 91c8 subal %a0,%a0 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
4a8e8: 70fe moveq #-2,%d0
4a8ea: c1a8 0014 andl %d0,%a0@(20)
filsdes[1] = open(fifopath, O_WRONLY);
4a8ee: 4878 0001 pea 1 <ADD>
4a8f2: 486e fff1 pea %fp@(-15)
4a8f6: 4eb9 0004 46a0 jsr 446a0 <open>
if (filsdes[1] < 0) {
4a8fc: 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);
4a8fe: 2540 0004 movel %d0,%a2@(4)
if (filsdes[1] < 0) {
4a902: 6c16 bges 4a91a <pipe_create+0xee>
err = errno;
4a904: 4eb9 0004 d240 jsr 4d240 <__errno>
4a90a: 2040 moveal %d0,%a0
4a90c: 2410 movel %a0@,%d2
close(filsdes[0]);
4a90e: 2f12 movel %a2@,%sp@-
4a910: 4eb9 0004 35c8 jsr 435c8 <close>
4a916: 588f addql #4,%sp
4a918: 6002 bras 4a91c <pipe_create+0xf0>
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
4a91a: 4282 clrl %d2
if (filsdes[1] < 0) {
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
4a91c: 486e fff1 pea %fp@(-15)
4a920: 4eb9 0004 6248 jsr 46248 <unlink>
4a926: 588f addql #4,%sp
}
if(err != 0)
4a928: 4a82 tstl %d2
4a92a: 670e beqs 4a93a <pipe_create+0x10e>
rtems_set_errno_and_return_minus_one(err);
4a92c: 4eb9 0004 d240 jsr 4d240 <__errno>
4a932: 2040 moveal %d0,%a0
4a934: 2082 movel %d2,%a0@
4a936: 70ff moveq #-1,%d0
4a938: 6002 bras 4a93c <pipe_create+0x110>
return 0;
4a93a: 4280 clrl %d0
}
4a93c: 4cee 040c ffe4 moveml %fp@(-28),%d2-%d3/%a2
4a942: 4e5e unlk %fp
...
0004bb76 <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4bb76: 4e56 0000 linkw %fp,#0
if (cmd == FIONREAD) {
4bb7a: 203c 4004 667f movel #1074030207,%d0
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4bb80: 2f0b movel %a3,%sp@-
4bb82: 266e 0010 moveal %fp@(16),%a3
4bb86: 2f0a movel %a2,%sp@-
4bb88: 246e 0008 moveal %fp@(8),%a2
if (cmd == FIONREAD) {
4bb8c: b0ae 000c cmpl %fp@(12),%d0
4bb90: 662e bnes 4bbc0 <pipe_ioctl+0x4a>
if (buffer == NULL)
4bb92: 4a8b tstl %a3
4bb94: 672e beqs 4bbc4 <pipe_ioctl+0x4e>
return -EFAULT;
if (! PIPE_LOCK(pipe))
4bb96: 42a7 clrl %sp@-
4bb98: 42a7 clrl %sp@-
4bb9a: 2f2a 0028 movel %a2@(40),%sp@-
4bb9e: 4eb9 0004 7550 jsr 47550 <rtems_semaphore_obtain>
4bba4: 4fef 000c lea %sp@(12),%sp
4bba8: 4a80 tstl %d0
4bbaa: 661c bnes 4bbc8 <pipe_ioctl+0x52> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4bbac: 26aa 000c movel %a2@(12),%a3@
PIPE_UNLOCK(pipe);
4bbb0: 2f2a 0028 movel %a2@(40),%sp@-
4bbb4: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
return 0;
4bbba: 588f addql #4,%sp
4bbbc: 4280 clrl %d0
4bbbe: 600a bras 4bbca <pipe_ioctl+0x54>
}
return -EINVAL;
4bbc0: 70ea moveq #-22,%d0
4bbc2: 6006 bras 4bbca <pipe_ioctl+0x54>
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
4bbc4: 70f2 moveq #-14,%d0
4bbc6: 6002 bras 4bbca <pipe_ioctl+0x54>
if (! PIPE_LOCK(pipe))
return -EINTR;
4bbc8: 70fc moveq #-4,%d0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
4bbca: 246e fff8 moveal %fp@(-8),%a2
4bbce: 266e fffc moveal %fp@(-4),%a3
4bbd2: 4e5e unlk %fp <== NOT EXECUTED
0004b8a4 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4b8a4: 4e56 ffd4 linkw %fp,#-44
4b8a8: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4b8ac: 42a7 clrl %sp@-
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4b8ae: 246e 0008 moveal %fp@(8),%a2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4b8b2: 2e3c 0004 7550 movel #292176,%d7
4b8b8: 2047 moveal %d7,%a0
4b8ba: 42a7 clrl %sp@-
4b8bc: 2f2a 0028 movel %a2@(40),%sp@-
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4b8c0: 286e 000c moveal %fp@(12),%a4
4b8c4: 2a2e 0010 movel %fp@(16),%d5
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4b8c8: 4e90 jsr %a0@
4b8ca: 4fef 000c lea %sp@(12),%sp
4b8ce: 4a80 tstl %d0
4b8d0: 6600 011a bnew 4b9ec <pipe_read+0x148>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
4b8d4: 2c0e movel %fp,%d6
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4b8d6: 4282 clrl %d2
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4b8d8: 47f9 0004 e6d0 lea 4e6d0 <memcpy>,%a3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
4b8de: 5986 subql #4,%d6
4b8e0: 4bf9 0004 c688 lea 4c688 <rtems_barrier_release>,%a5
4b8e6: 6000 00e2 braw 4b9ca <pipe_read+0x126>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4b8ea: 4aaa 0014 tstl %a2@(20)
4b8ee: 6700 00e0 beqw 4b9d0 <pipe_read+0x12c>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4b8f2: 206e 0014 moveal %fp@(20),%a0
4b8f6: 7001 moveq #1,%d0
4b8f8: c0a8 0014 andl %a0@(20),%d0
4b8fc: 6600 00d6 bnew 4b9d4 <pipe_read+0x130>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
4b900: 52aa 0018 addql #1,%a2@(24)
PIPE_UNLOCK(pipe);
4b904: 2f2a 0028 movel %a2@(40),%sp@-
4b908: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
4b90e: 42a7 clrl %sp@-
4b910: 2f2a 002c movel %a2@(44),%sp@-
4b914: 4eb9 0004 c6ec jsr 4c6ec <rtems_barrier_wait>
4b91a: 4fef 000c lea %sp@(12),%sp
4b91e: 4a80 tstl %d0
4b920: 6604 bnes 4b926 <pipe_read+0x82> <== NEVER TAKEN
4b922: 4283 clrl %d3
4b924: 6002 bras 4b928 <pipe_read+0x84>
ret = -EINTR;
4b926: 76fc moveq #-4,%d3 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
4b928: 42a7 clrl %sp@-
4b92a: 2047 moveal %d7,%a0
4b92c: 42a7 clrl %sp@-
4b92e: 2f2a 0028 movel %a2@(40),%sp@-
4b932: 4e90 jsr %a0@
4b934: 4fef 000c lea %sp@(12),%sp
4b938: 4a80 tstl %d0
4b93a: 6600 00a8 bnew 4b9e4 <pipe_read+0x140>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
4b93e: 53aa 0018 subql #1,%a2@(24)
if (ret != 0)
4b942: 4a83 tstl %d3
4b944: 6600 0090 bnew 4b9d6 <pipe_read+0x132>
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
4b948: 262a 000c movel %a2@(12),%d3
4b94c: 679c beqs 4b8ea <pipe_read+0x46> <== NEVER TAKEN
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
4b94e: 2005 movel %d5,%d0
4b950: 9082 subl %d2,%d0
4b952: b083 cmpl %d3,%d0
4b954: 6402 bccs 4b958 <pipe_read+0xb4>
4b956: 2600 movel %d0,%d3
chunk1 = pipe->Size - pipe->Start;
4b958: 222a 0008 movel %a2@(8),%d1
4b95c: 200c movel %a4,%d0
4b95e: d082 addl %d2,%d0
4b960: 282a 0004 movel %a2@(4),%d4
4b964: 9881 subl %d1,%d4
4b966: d292 addl %a2@,%d1
if (chunk > chunk1) {
4b968: b883 cmpl %d3,%d4
4b96a: 6c20 bges 4b98c <pipe_read+0xe8>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4b96c: 2f04 movel %d4,%sp@-
4b96e: 2f01 movel %d1,%sp@-
4b970: 2f00 movel %d0,%sp@-
4b972: 4e93 jsr %a3@
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4b974: 2203 movel %d3,%d1
4b976: 9284 subl %d4,%d1
4b978: 2002 movel %d2,%d0
4b97a: d084 addl %d4,%d0
4b97c: 2f01 movel %d1,%sp@-
4b97e: 2f12 movel %a2@,%sp@-
4b980: 4874 0800 pea %a4@(00000000,%d0:l)
4b984: 4e93 jsr %a3@
4b986: 4fef 0018 lea %sp@(24),%sp
4b98a: 600c bras 4b998 <pipe_read+0xf4>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4b98c: 2f03 movel %d3,%sp@-
4b98e: 2f01 movel %d1,%sp@-
4b990: 2f00 movel %d0,%sp@-
4b992: 4e93 jsr %a3@
4b994: 4fef 000c lea %sp@(12),%sp
pipe->Start += chunk;
4b998: 2003 movel %d3,%d0
4b99a: d0aa 0008 addl %a2@(8),%d0
pipe->Start %= pipe->Size;
4b99e: 4c6a 0001 0004 remul %a2@(4),%d1,%d0
pipe->Length -= chunk;
4b9a4: 202a 000c movel %a2@(12),%d0
4b9a8: 9083 subl %d3,%d0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
4b9aa: 2541 0008 movel %d1,%a2@(8)
pipe->Length -= chunk;
4b9ae: 2540 000c movel %d0,%a2@(12)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
4b9b2: 6604 bnes 4b9b8 <pipe_read+0x114>
pipe->Start = 0;
4b9b4: 42aa 0008 clrl %a2@(8)
if (pipe->waitingWriters > 0)
4b9b8: 4aaa 001c tstl %a2@(28)
4b9bc: 670a beqs 4b9c8 <pipe_read+0x124>
PIPE_WAKEUPWRITERS(pipe);
4b9be: 2f06 movel %d6,%sp@-
4b9c0: 2f2a 0030 movel %a2@(48),%sp@-
4b9c4: 4e95 jsr %a5@
4b9c6: 508f addql #8,%sp
read += chunk;
4b9c8: d483 addl %d3,%d2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
4b9ca: ba82 cmpl %d2,%d5
4b9cc: 6200 ff7a bhiw 4b948 <pipe_read+0xa4>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4b9d0: 4283 clrl %d3
4b9d2: 6002 bras 4b9d6 <pipe_read+0x132>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
4b9d4: 76f5 moveq #-11,%d3
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
4b9d6: 2f2a 0028 movel %a2@(40),%sp@-
4b9da: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
4b9e0: 588f addql #4,%sp
4b9e2: 6002 bras 4b9e6 <pipe_read+0x142>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
4b9e4: 76fc moveq #-4,%d3 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
4b9e6: 4a82 tstl %d2
4b9e8: 6e08 bgts 4b9f2 <pipe_read+0x14e>
4b9ea: 6004 bras 4b9f0 <pipe_read+0x14c>
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
4b9ec: 74fc moveq #-4,%d2 <== NOT EXECUTED
4b9ee: 6002 bras 4b9f2 <pipe_read+0x14e> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
return read;
return ret;
4b9f0: 2403 movel %d3,%d2
}
4b9f2: 2002 movel %d2,%d0
4b9f4: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4b9fa: 4e5e unlk %fp <== NOT EXECUTED
0004b488 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b488: 4e56 fff0 linkw %fp,#-16
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b48c: 206e 000c moveal %fp@(12),%a0
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4b490: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4b494: 266e 0008 moveal %fp@(8),%a3
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b498: 7406 moveq #6,%d2
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
4b49a: 2453 moveal %a3@,%a2
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
4b49c: c4a8 0014 andl %a0@(20),%d2
if (mode & LIBIO_FLAGS_READ)
4b4a0: 0802 0001 btst #1,%d2
4b4a4: 6704 beqs 4b4aa <pipe_release+0x22>
pipe->Readers --;
4b4a6: 53aa 0010 subql #1,%a2@(16)
if (mode & LIBIO_FLAGS_WRITE)
4b4aa: 44c2 movew %d2,%ccr
4b4ac: 6604 bnes 4b4b2 <pipe_release+0x2a>
pipe->Writers --;
4b4ae: 53aa 0014 subql #1,%a2@(20)
PIPE_UNLOCK(pipe);
4b4b2: 2f2a 0028 movel %a2@(40),%sp@-
4b4b6: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
4b4bc: 588f addql #4,%sp
4b4be: 4aaa 0010 tstl %a2@(16)
4b4c2: 6622 bnes 4b4e6 <pipe_release+0x5e>
4b4c4: 4aaa 0014 tstl %a2@(20)
4b4c8: 660c bnes 4b4d6 <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);
4b4ca: 2f0a movel %a2,%sp@-
4b4cc: 4eba ff72 jsr %pc@(4b440 <pipe_free>)
*pipep = NULL;
4b4d0: 588f addql #4,%sp
4b4d2: 4293 clrl %a3@
4b4d4: 602c bras 4b502 <pipe_release+0x7a>
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4b4d6: 7004 moveq #4,%d0
4b4d8: b082 cmpl %d2,%d0
4b4da: 670a beqs 4b4e6 <pipe_release+0x5e> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
4b4dc: 486e fffc pea %fp@(-4)
4b4e0: 2f2a 0030 movel %a2@(48),%sp@-
4b4e4: 6014 bras 4b4fa <pipe_release+0x72>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
4b4e6: 4aaa 0014 tstl %a2@(20)
4b4ea: 6616 bnes 4b502 <pipe_release+0x7a> <== NEVER TAKEN
4b4ec: 7002 moveq #2,%d0
4b4ee: b082 cmpl %d2,%d0
4b4f0: 6710 beqs 4b502 <pipe_release+0x7a> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
4b4f2: 486e fffc pea %fp@(-4)
4b4f6: 2f2a 002c movel %a2@(44),%sp@-
4b4fa: 4eb9 0004 c688 jsr 4c688 <rtems_barrier_release>
4b500: 508f addql #8,%sp
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
4b502: 2f39 0005 f03c movel 5f03c <pipe_semaphore>,%sp@-
4b508: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
4b50e: 588f addql #4,%sp
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
4b510: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4b516: 4e5e unlk %fp <== NOT EXECUTED
0004b9fe <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4b9fe: 4e56 ffd4 linkw %fp,#-44
4ba02: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4ba06: 246e 0008 moveal %fp@(8),%a2
4ba0a: 286e 000c moveal %fp@(12),%a4
4ba0e: 282e 0010 movel %fp@(16),%d4
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4ba12: 6700 014c beqw 4bb60 <pipe_write+0x162>
return 0;
if (! PIPE_LOCK(pipe))
4ba16: 42a7 clrl %sp@-
4ba18: 42a7 clrl %sp@-
4ba1a: 2f2a 0028 movel %a2@(40),%sp@-
4ba1e: 4eb9 0004 7550 jsr 47550 <rtems_semaphore_obtain>
4ba24: 4fef 000c lea %sp@(12),%sp
4ba28: 4a80 tstl %d0
4ba2a: 6600 0138 bnew 4bb64 <pipe_write+0x166>
return -EINTR;
if (pipe->Readers == 0) {
4ba2e: 4aaa 0010 tstl %a2@(16)
4ba32: 6700 010a beqw 4bb3e <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;
4ba36: b8aa 0004 cmpl %a2@(4),%d4
4ba3a: 6204 bhis 4ba40 <pipe_write+0x42> <== NEVER TAKEN
4ba3c: 2a04 movel %d4,%d5
4ba3e: 6002 bras 4ba42 <pipe_write+0x44>
4ba40: 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;
4ba42: 4282 clrl %d2
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
4ba44: 2e3c 0004 c6ec movel #313068,%d7
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4ba4a: 47f9 0004 e6d0 lea 4e6d0 <memcpy>,%a3
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
4ba50: 4bf9 0004 c688 lea 4c688 <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)) {
4ba56: 2c3c 0004 7550 movel #292176,%d6
4ba5c: 6000 00d8 braw 4bb36 <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)) {
4ba60: 206e 0014 moveal %fp@(20),%a0
4ba64: 7001 moveq #1,%d0
4ba66: c0a8 0014 andl %a0@(20),%d0
4ba6a: 6600 00d8 bnew 4bb44 <pipe_write+0x146>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
4ba6e: 52aa 001c addql #1,%a2@(28)
PIPE_UNLOCK(pipe);
4ba72: 2f2a 0028 movel %a2@(40),%sp@-
4ba76: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
4ba7c: 2047 moveal %d7,%a0
4ba7e: 42a7 clrl %sp@-
4ba80: 2f2a 0030 movel %a2@(48),%sp@-
4ba84: 4e90 jsr %a0@
4ba86: 4fef 000c lea %sp@(12),%sp
4ba8a: 4a80 tstl %d0
4ba8c: 6604 bnes 4ba92 <pipe_write+0x94> <== NEVER TAKEN
4ba8e: 4283 clrl %d3
4ba90: 6002 bras 4ba94 <pipe_write+0x96>
ret = -EINTR;
4ba92: 76fc moveq #-4,%d3 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
4ba94: 42a7 clrl %sp@-
4ba96: 2046 moveal %d6,%a0
4ba98: 42a7 clrl %sp@-
4ba9a: 2f2a 0028 movel %a2@(40),%sp@-
4ba9e: 4e90 jsr %a0@
4baa0: 4fef 000c lea %sp@(12),%sp
4baa4: 4a80 tstl %d0
4baa6: 6600 00b0 bnew 4bb58 <pipe_write+0x15a>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
4baaa: 53aa 001c subql #1,%a2@(28)
if (ret != 0)
4baae: 4a83 tstl %d3
4bab0: 6600 0098 bnew 4bb4a <pipe_write+0x14c>
goto out_locked;
if (pipe->Readers == 0) {
4bab4: 4aaa 0010 tstl %a2@(16)
4bab8: 6700 008e beqw 4bb48 <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) {
4babc: 202a 0004 movel %a2@(4),%d0
4bac0: 2600 movel %d0,%d3
4bac2: 222a 000c movel %a2@(12),%d1
4bac6: 9681 subl %d1,%d3
4bac8: ba83 cmpl %d3,%d5
4baca: 6294 bhis 4ba60 <pipe_write+0x62>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
4bacc: 2044 moveal %d4,%a0
4bace: 91c2 subal %d2,%a0
4bad0: b1c3 cmpal %d3,%a0
4bad2: 6402 bccs 4bad6 <pipe_write+0xd8>
4bad4: 2608 movel %a0,%d3
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4bad6: 2a01 movel %d1,%d5
4bad8: daaa 0008 addl %a2@(8),%d5
4badc: 4c40 5001 remul %d0,%d1,%d5
4bae0: 2a00 movel %d0,%d5
4bae2: 9a81 subl %d1,%d5
4bae4: 2012 movel %a2@,%d0
4bae6: d081 addl %d1,%d0
4bae8: 220c movel %a4,%d1
4baea: d282 addl %d2,%d1
if (chunk > chunk1) {
4baec: ba83 cmpl %d3,%d5
4baee: 6c20 bges 4bb10 <pipe_write+0x112>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4baf0: 2f05 movel %d5,%sp@-
4baf2: 2f01 movel %d1,%sp@-
4baf4: 2f00 movel %d0,%sp@-
4baf6: 4e93 jsr %a3@
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4baf8: 2203 movel %d3,%d1
4bafa: 9285 subl %d5,%d1
4bafc: 2005 movel %d5,%d0
4bafe: d082 addl %d2,%d0
4bb00: 2f01 movel %d1,%sp@-
4bb02: 4874 0800 pea %a4@(00000000,%d0:l)
4bb06: 2f12 movel %a2@,%sp@-
4bb08: 4e93 jsr %a3@
4bb0a: 4fef 0018 lea %sp@(24),%sp
4bb0e: 600c bras 4bb1c <pipe_write+0x11e>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4bb10: 2f03 movel %d3,%sp@-
4bb12: 2f01 movel %d1,%sp@-
4bb14: 2f00 movel %d0,%sp@-
4bb16: 4e93 jsr %a3@
4bb18: 4fef 000c lea %sp@(12),%sp
pipe->Length += chunk;
4bb1c: d7aa 000c addl %d3,%a2@(12)
if (pipe->waitingReaders > 0)
4bb20: 4aaa 0018 tstl %a2@(24)
4bb24: 670c beqs 4bb32 <pipe_write+0x134>
PIPE_WAKEUPREADERS(pipe);
4bb26: 486e fffc pea %fp@(-4)
4bb2a: 2f2a 002c movel %a2@(44),%sp@-
4bb2e: 4e95 jsr %a5@
4bb30: 508f addql #8,%sp
written += chunk;
4bb32: d483 addl %d3,%d2
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
4bb34: 7a01 moveq #1,%d5
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
4bb36: b882 cmpl %d2,%d4
4bb38: 6282 bhis 4babc <pipe_write+0xbe>
4bb3a: 4283 clrl %d3
4bb3c: 600c bras 4bb4a <pipe_write+0x14c>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
4bb3e: 76e0 moveq #-32,%d3
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
int chunk, chunk1, written = 0, ret = 0;
4bb40: 4282 clrl %d2
4bb42: 6006 bras 4bb4a <pipe_write+0x14c>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
4bb44: 76f5 moveq #-11,%d3
4bb46: 6002 bras 4bb4a <pipe_write+0x14c>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
4bb48: 76e0 moveq #-32,%d3 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
4bb4a: 2f2a 0028 movel %a2@(40),%sp@-
4bb4e: 4eb9 0004 765c jsr 4765c <rtems_semaphore_release>
4bb54: 588f addql #4,%sp
4bb56: 6002 bras 4bb5a <pipe_write+0x15c>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
4bb58: 76fc moveq #-4,%d3 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4bb5a: 4a82 tstl %d2
4bb5c: 6e0c bgts 4bb6a <pipe_write+0x16c>
4bb5e: 6008 bras 4bb68 <pipe_write+0x16a>
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
4bb60: 4282 clrl %d2 <== NOT EXECUTED
4bb62: 6006 bras 4bb6a <pipe_write+0x16c> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
4bb64: 74fc moveq #-4,%d2 <== NOT EXECUTED
4bb66: 6002 bras 4bb6a <pipe_write+0x16c> <== NOT EXECUTED
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
return written;
return ret;
4bb68: 2403 movel %d3,%d2
}
4bb6a: 2002 movel %d2,%d0
4bb6c: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4bb72: 4e5e unlk %fp <== NOT EXECUTED
00046cac <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
46cac: 4e56 0000 linkw %fp,#0
46cb0: 202e 000c movel %fp@(12),%d0
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
46cb4: 2200 movel %d0,%d1
46cb6: 5381 subql #1,%d1
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
46cb8: 52b9 0006 2cd4 addql #1,62cd4 <rtems_malloc_statistics+0x8>
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
46cbe: c280 andl %d0,%d1
46cc0: 6610 bnes 46cd2 <posix_memalign+0x26> <== NEVER TAKEN
46cc2: 123c 0003 moveb #3,%d1
46cc6: b280 cmpl %d0,%d1
46cc8: 6408 bccs 46cd2 <posix_memalign+0x26>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
46cca: 4e5e unlk %fp
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
46ccc: 4ef9 0004 6e4c jmp 46e4c <rtems_memalign>
}
46cd2: 7016 moveq #22,%d0
46cd4: 4e5e unlk %fp <== NOT EXECUTED
00049c48 <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
49c48: 4e56 ffec linkw %fp,#-20
49c4c: 48d7 043c moveml %d2-%d5/%a2,%sp@
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
49c50: 4878 0010 pea 10 <INVALID_OPERATION>
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
49c54: 242e 0008 movel %fp@(8),%d2
49c58: 282e 000c movel %fp@(12),%d4
49c5c: 262e 0010 movel %fp@(16),%d3
49c60: 1a2e 0017 moveb %fp@(23),%d5
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
49c64: 4eb9 0004 391c jsr 4391c <malloc>
if (rd == NULL) {
49c6a: 588f addql #4,%sp
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
49c6c: 2440 moveal %d0,%a2
if (rd == NULL) {
49c6e: 4a80 tstl %d0
49c70: 6740 beqs 49cb2 <ramdisk_allocate+0x6a> <== NEVER TAKEN
return NULL;
}
if (area_begin == NULL) {
49c72: 4a82 tstl %d2
49c74: 6622 bnes 49c98 <ramdisk_allocate+0x50> <== NEVER TAKEN
area_begin = calloc(block_count, block_size);
49c76: 2f04 movel %d4,%sp@-
49c78: 2f03 movel %d3,%sp@-
49c7a: 4eb9 0004 3294 jsr 43294 <calloc>
if (area_begin == NULL) {
49c80: 508f addql #8,%sp
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
49c82: 2400 movel %d0,%d2
if (area_begin == NULL) {
49c84: 660e bnes 49c94 <ramdisk_allocate+0x4c> <== ALWAYS TAKEN
free(rd);
49c86: 2f0a movel %a2,%sp@- <== NOT EXECUTED
return NULL;
49c88: 95ca subal %a2,%a2 <== NOT EXECUTED
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
if (area_begin == NULL) {
free(rd);
49c8a: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
return NULL;
49c90: 588f addql #4,%sp <== NOT EXECUTED
49c92: 601e bras 49cb2 <ramdisk_allocate+0x6a> <== NOT EXECUTED
}
rd->malloced = true;
49c94: 7001 moveq #1,%d0
49c96: 6002 bras 49c9a <ramdisk_allocate+0x52>
} else {
rd->malloced = false;
49c98: 4200 clrb %d0 <== NOT EXECUTED
}
rd->block_size = block_size;
49c9a: 2484 movel %d4,%a2@
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
49c9c: 1540 000d moveb %d0,%a2@(13)
}
rd->block_size = block_size;
rd->block_num = block_count;
49ca0: 2543 0004 movel %d3,%a2@(4)
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
49ca4: 7001 moveq #1,%d0
rd->malloced = false;
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
rd->trace = trace;
49ca6: 1545 000e moveb %d5,%a2@(14)
} else {
rd->malloced = false;
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
49caa: 2542 0008 movel %d2,%a2@(8)
rd->trace = trace;
rd->initialized = true;
49cae: 1540 000c moveb %d0,%a2@(12)
return rd;
}
49cb2: 200a movel %a2,%d0
49cb4: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
49cba: 4e5e unlk %fp <== NOT EXECUTED
00049cbe <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
49cbe: 4e56 0000 linkw %fp,#0
49cc2: 2f0a movel %a2,%sp@-
49cc4: 246e 0008 moveal %fp@(8),%a2
if (rd != NULL) {
49cc8: 4a8a tstl %a2
49cca: 6722 beqs 49cee <ramdisk_free+0x30> <== NEVER TAKEN
if (rd->malloced) {
49ccc: 4a2a 000d tstb %a2@(13)
49cd0: 670c beqs 49cde <ramdisk_free+0x20> <== NEVER TAKEN
free(rd->area);
49cd2: 2f2a 0008 movel %a2@(8),%sp@-
49cd6: 4eb9 0004 3630 jsr 43630 <free>
49cdc: 588f addql #4,%sp
}
free(rd);
49cde: 2d4a 0008 movel %a2,%fp@(8)
}
}
49ce2: 246e fffc moveal %fp@(-4),%a2
49ce6: 4e5e unlk %fp
{
if (rd != NULL) {
if (rd->malloced) {
free(rd->area);
}
free(rd);
49ce8: 4ef9 0004 3630 jmp 43630 <free>
}
}
49cee: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
49cf2: 4e5e unlk %fp <== NOT EXECUTED
00049b5c <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
49b5c: 4e56 ffe8 linkw %fp,#-24
49b60: 206e 0008 moveal %fp@(8),%a0
49b64: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
49b68: 202e 000c movel %fp@(12),%d0
49b6c: 246e 0010 moveal %fp@(16),%a2
switch (req)
49b70: 0c80 c018 4201 cmpil #-1072152063,%d0
49b76: 6600 00ac bnew 49c24 <ramdisk_ioctl+0xc8>
break;
}
errno = EINVAL;
return -1;
}
49b7a: 2868 002c moveal %a0@(44),%a4
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
49b7e: 2012 movel %a2@,%d0
49b80: 670a beqs 49b8c <ramdisk_ioctl+0x30>
49b82: 7201 moveq #1,%d1
49b84: b280 cmpl %d0,%d1
49b86: 6600 008c bnew 49c14 <ramdisk_ioctl+0xb8>
49b8a: 603a bras 49bc6 <ramdisk_ioctl+0x6a>
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
49b8c: 262c 0008 movel %a4@(8),%d3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49b90: 47ea 0018 lea %a2@(24),%a3
49b94: 4282 clrl %d2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
49b96: 4bf9 0004 fe5c lea 4fe5c <memcpy>,%a5
49b9c: 6020 bras 49bbe <ramdisk_ioctl+0x62>
49b9e: 2013 movel %a3@,%d0
49ba0: 4c14 0800 mulsl %a4@,%d0
49ba4: 2043 moveal %d3,%a0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49ba6: 5282 addql #1,%d2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
49ba8: 2f2b 0004 movel %a3@(4),%sp@-
49bac: 4870 0800 pea %a0@(00000000,%d0:l)
49bb0: 2f2b 0008 movel %a3@(8),%sp@-
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49bb4: 47eb 0010 lea %a3@(16),%a3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
49bb8: 4e95 jsr %a5@
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49bba: 4fef 000c lea %sp@(12),%sp
49bbe: b4aa 0010 cmpl %a2@(16),%d2
49bc2: 65da bcss 49b9e <ramdisk_ioctl+0x42>
49bc4: 6038 bras 49bfe <ramdisk_ioctl+0xa2>
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
49bc6: 262c 0008 movel %a4@(8),%d3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49bca: 47ea 0018 lea %a2@(24),%a3
49bce: 4282 clrl %d2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
49bd0: 4bf9 0004 fe5c lea 4fe5c <memcpy>,%a5
49bd6: 6020 bras 49bf8 <ramdisk_ioctl+0x9c>
49bd8: 2013 movel %a3@,%d0
49bda: 4c14 0800 mulsl %a4@,%d0
49bde: 2043 moveal %d3,%a0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49be0: 5282 addql #1,%d2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
49be2: 2f2b 0004 movel %a3@(4),%sp@-
49be6: 2f2b 0008 movel %a3@(8),%sp@-
49bea: 4870 0800 pea %a0@(00000000,%d0:l)
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49bee: 47eb 0010 lea %a3@(16),%a3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
49bf2: 4e95 jsr %a5@
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
49bf4: 4fef 000c lea %sp@(12),%sp
49bf8: b4aa 0010 cmpl %a2@(16),%d2
49bfc: 65da bcss 49bd8 <ramdisk_ioctl+0x7c>
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
49bfe: 42aa 000c clrl %a2@(12)
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
49c02: 42a7 clrl %sp@-
49c04: 2f2a 0008 movel %a2@(8),%sp@-
49c08: 206a 0004 moveal %a2@(4),%a0
49c0c: 4e90 jsr %a0@
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
49c0e: 508f addql #8,%sp
49c10: 4280 clrl %d0
49c12: 602a bras 49c3e <ramdisk_ioctl+0xe2>
default:
errno = EINVAL;
49c14: 4eb9 0004 f63c jsr 4f63c <__errno> <== NOT EXECUTED
49c1a: 2040 moveal %d0,%a0 <== NOT EXECUTED
49c1c: 7016 moveq #22,%d0 <== NOT EXECUTED
49c1e: 2080 movel %d0,%a0@ <== NOT EXECUTED
return -1;
49c20: 70ff moveq #-1,%d0 <== NOT EXECUTED
49c22: 601a bras 49c3e <ramdisk_ioctl+0xe2> <== NOT EXECUTED
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
49c24: 2d4a 0010 movel %a2,%fp@(16)
49c28: 2d40 000c movel %d0,%fp@(12)
break;
}
errno = EINVAL;
return -1;
}
49c2c: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
49c32: 2d48 0008 movel %a0,%fp@(8)
break;
}
errno = EINVAL;
return -1;
}
49c36: 4e5e unlk %fp
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
49c38: 4ef9 0004 c04e jmp 4c04e <rtems_blkdev_ioctl>
break;
}
errno = EINVAL;
return -1;
}
49c3e: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
49c44: 4e5e unlk %fp <== NOT EXECUTED
00049cf6 <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
49cf6: 4e56 ffe8 linkw %fp,#-24
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
49cfa: 204e moveal %fp,%a0
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
49cfc: 48d7 007c moveml %d2-%d6,%sp@
49d00: 2a2e 0008 movel %fp@(8),%d5
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
49d04: 42a0 clrl %a0@-
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
49d06: 2c2e 000c movel %fp@(12),%d6
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
49d0a: 2f08 movel %a0,%sp@-
49d0c: 4879 0005 e6e2 pea 5e6e2 <ramdisk_ops>
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
49d12: 142e 0013 moveb %fp@(19),%d2
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
49d16: 42a7 clrl %sp@-
49d18: 4eb9 0004 6e18 jsr 46e18 <rtems_io_register_driver>
if (sc != RTEMS_SUCCESSFUL) {
49d1e: 4fef 000c lea %sp@(12),%sp
49d22: 4a80 tstl %d0
49d24: 6676 bnes 49d9c <ramdisk_register+0xa6> <== NEVER TAKEN
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
49d26: 0282 0000 00ff andil #255,%d2
49d2c: 2f02 movel %d2,%sp@-
49d2e: 2f06 movel %d6,%sp@-
49d30: 2f05 movel %d5,%sp@-
49d32: 42a7 clrl %sp@-
49d34: 4eb9 0004 9c48 jsr 49c48 <ramdisk_allocate>
if (rd == NULL) {
49d3a: 4fef 0010 lea %sp@(16),%sp
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
49d3e: 2800 movel %d0,%d4
if (rd == NULL) {
49d40: 660e bnes 49d50 <ramdisk_register+0x5a> <== ALWAYS TAKEN
rtems_io_unregister_driver(major);
49d42: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
49d46: 4eb9 0004 6f4c jsr 46f4c <rtems_io_unregister_driver> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
49d4c: 588f addql #4,%sp <== NOT EXECUTED
49d4e: 604c bras 49d9c <ramdisk_register+0xa6> <== NOT EXECUTED
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
49d50: 2f2e 0014 movel %fp@(20),%sp@-
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
temp.__overlay.minor = _minor;
return temp.device;
49d54: 4283 clrl %d3
49d56: 242e fffc movel %fp@(-4),%d2
49d5a: 2f00 movel %d0,%sp@-
49d5c: 4879 0004 9b5c pea 49b5c <ramdisk_ioctl>
49d62: 2f06 movel %d6,%sp@-
49d64: 2f05 movel %d5,%sp@-
49d66: 2f03 movel %d3,%sp@-
49d68: 2f02 movel %d2,%sp@-
49d6a: 4eb9 0004 26a8 jsr 426a8 <rtems_disk_create_phys>
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
49d70: 4fef 001c lea %sp@(28),%sp
49d74: 4a80 tstl %d0
49d76: 6716 beqs 49d8e <ramdisk_register+0x98> <== ALWAYS TAKEN
ramdisk_free(rd);
49d78: 2f04 movel %d4,%sp@- <== NOT EXECUTED
49d7a: 4eb9 0004 9cbe jsr 49cbe <ramdisk_free> <== NOT EXECUTED
rtems_io_unregister_driver(major);
49d80: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
49d84: 4eb9 0004 6f4c jsr 46f4c <rtems_io_unregister_driver> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
49d8a: 508f addql #8,%sp <== NOT EXECUTED
49d8c: 600e bras 49d9c <ramdisk_register+0xa6> <== NOT EXECUTED
}
*dev_ptr = dev;
49d8e: 206e 0018 moveal %fp@(24),%a0
return RTEMS_SUCCESSFUL;
49d92: 4280 clrl %d0
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
49d94: 2082 movel %d2,%a0@
49d96: 2143 0004 movel %d3,%a0@(4)
return RTEMS_SUCCESSFUL;
49d9a: 6002 bras 49d9e <ramdisk_register+0xa8>
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
49d9c: 700d moveq #13,%d0 <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
49d9e: 4cee 007c ffe8 moveml %fp@(-24),%d2-%d6
49da4: 4e5e unlk %fp <== NOT EXECUTED
00059c90 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
59c90: 4e56 fff4 linkw %fp,#-12
59c94: 202e 0008 movel %fp@(8),%d0
59c98: 222e 000c movel %fp@(12),%d1
59c9c: 206e 0010 moveal %fp@(16),%a0
59ca0: 48d7 040c moveml %d2-%d3/%a2,%sp@
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
59ca4: b0b9 0005 bff2 cmpl 5bff2 <rtems_libio_number_iops>,%d0
59caa: 6436 bccs 59ce2 <read+0x52>
iop = rtems_libio_iop( fd );
59cac: 2400 movel %d0,%d2
59cae: ed88 lsll #6,%d0
59cb0: e78a lsll #3,%d2
59cb2: 2479 0005 d6d8 moveal 5d6d8 <rtems_libio_iops>,%a2
59cb8: 9082 subl %d2,%d0
59cba: d5c0 addal %d0,%a2
rtems_libio_check_is_open( iop );
59cbc: 202a 0014 movel %a2@(20),%d0
59cc0: 0800 0008 btst #8,%d0
59cc4: 671c beqs 59ce2 <read+0x52>
rtems_libio_check_buffer( buffer );
59cc6: 4a81 tstl %d1
59cc8: 660e bnes 59cd8 <read+0x48> <== ALWAYS TAKEN
59cca: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
59cd0: 7216 moveq #22,%d1 <== NOT EXECUTED
59cd2: 2040 moveal %d0,%a0 <== NOT EXECUTED
59cd4: 2081 movel %d1,%a0@ <== NOT EXECUTED
59cd6: 6016 bras 59cee <read+0x5e> <== NOT EXECUTED
rtems_libio_check_count( count );
59cd8: 4a88 tstl %a0
59cda: 6744 beqs 59d20 <read+0x90>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
59cdc: 0800 0001 btst #1,%d0
59ce0: 6610 bnes 59cf2 <read+0x62>
59ce2: 4eb9 0004 c034 jsr 4c034 <__errno>
59ce8: 2040 moveal %d0,%a0
59cea: 7009 moveq #9,%d0
59cec: 2080 movel %d0,%a0@
59cee: 70ff moveq #-1,%d0
59cf0: 6030 bras 59d22 <read+0x92>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
59cf2: 226a 0020 moveal %a2@(32),%a1
59cf6: 2f08 movel %a0,%sp@-
59cf8: 2f01 movel %d1,%sp@-
59cfa: 2f0a movel %a2,%sp@-
59cfc: 2069 0008 moveal %a1@(8),%a0
59d00: 4e90 jsr %a0@
if ( rc > 0 )
59d02: 4fef 000c lea %sp@(12),%sp
59d06: 4a80 tstl %d0
59d08: 6f18 bles 59d22 <read+0x92>
iop->offset += rc;
59d0a: 2600 movel %d0,%d3
59d0c: 5bc2 smi %d2
59d0e: 49c2 extbl %d2
59d10: d7aa 0010 addl %d3,%a2@(16)
59d14: 222a 000c movel %a2@(12),%d1
59d18: d382 addxl %d2,%d1
59d1a: 2541 000c movel %d1,%a2@(12)
59d1e: 6002 bras 59d22 <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 );
59d20: 4280 clrl %d0
if ( rc > 0 )
iop->offset += rc;
return rc;
}
59d22: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
59d28: 4e5e unlk %fp <== NOT EXECUTED
00044ab4 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
44ab4: 4e56 ffdc linkw %fp,#-36
44ab8: 48d7 001c moveml %d2-%d4,%sp@
44abc: 282e 0008 movel %fp@(8),%d4
44ac0: 262e 000c movel %fp@(12),%d3
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
44ac4: 660e bnes 44ad4 <readlink+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
44ac6: 4eb9 0004 d4cc jsr 4d4cc <__errno>
44acc: 720e moveq #14,%d1
44ace: 2040 moveal %d0,%a0
44ad0: 2081 movel %d1,%a0@
44ad2: 607c bras 44b50 <readlink+0x9c>
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
44ad4: 2f04 movel %d4,%sp@-
44ad6: 240e movel %fp,%d2
44ad8: 0682 ffff ffec addil #-20,%d2
44ade: 4eb9 0004 e854 jsr 4e854 <strlen>
44ae4: 4297 clrl %sp@
44ae6: 2f02 movel %d2,%sp@-
44ae8: 42a7 clrl %sp@-
44aea: 2f00 movel %d0,%sp@-
44aec: 2f04 movel %d4,%sp@-
44aee: 4eb9 0004 376c jsr 4376c <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
44af4: 4fef 0014 lea %sp@(20),%sp
44af8: 4a80 tstl %d0
44afa: 6654 bnes 44b50 <readlink+0x9c> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
44afc: 206e fff8 moveal %fp@(-8),%a0
44b00: 2f02 movel %d2,%sp@-
44b02: 2068 0010 moveal %a0@(16),%a0
44b06: 4e90 jsr %a0@
44b08: 588f addql #4,%sp
44b0a: 7204 moveq #4,%d1
44b0c: b280 cmpl %d0,%d1
44b0e: 6718 beqs 44b28 <readlink+0x74>
rtems_filesystem_freenode( &loc );
44b10: 2f02 movel %d2,%sp@-
44b12: 4eb9 0004 3938 jsr 43938 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
44b18: 4eb9 0004 d4cc jsr 4d4cc <__errno>
44b1e: 588f addql #4,%sp
44b20: 2040 moveal %d0,%a0
44b22: 7016 moveq #22,%d0
44b24: 2080 movel %d0,%a0@
44b26: 6028 bras 44b50 <readlink+0x9c>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
44b28: 2f2e 0010 movel %fp@(16),%sp@-
44b2c: 206e fff8 moveal %fp@(-8),%a0
44b30: 2f03 movel %d3,%sp@-
44b32: 2f02 movel %d2,%sp@-
44b34: 2068 003c moveal %a0@(60),%a0
44b38: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
44b3a: 2f02 movel %d2,%sp@-
44b3c: 2d40 ffe8 movel %d0,%fp@(-24)
44b40: 4eb9 0004 3938 jsr 43938 <rtems_filesystem_freenode>
return result;
44b46: 202e ffe8 movel %fp@(-24),%d0
44b4a: 4fef 0010 lea %sp@(16),%sp
44b4e: 6002 bras 44b52 <readlink+0x9e>
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
return -1;
44b50: 70ff moveq #-1,%d0
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
44b52: 4cee 001c ffdc moveml %fp@(-36),%d2-%d4
44b58: 4e5e unlk %fp <== NOT EXECUTED
00044464 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
44464: 4e56 ffe4 linkw %fp,#-28
44468: 202e 0008 movel %fp@(8),%d0
4446c: 48d7 0cdc moveml %d2-%d4/%d6-%d7/%a2-%a3,%sp@
44470: 246e 000c moveal %fp@(12),%a2
44474: 262e 0010 movel %fp@(16),%d3
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
44478: b0b9 0005 c7f2 cmpl 5c7f2 <rtems_libio_number_iops>,%d0
4447e: 6420 bccs 444a0 <readv+0x3c>
iop = rtems_libio_iop( fd );
44480: 2200 movel %d0,%d1
44482: ed88 lsll #6,%d0
44484: e789 lsll #3,%d1
44486: 2679 0005 ded8 moveal 5ded8 <rtems_libio_iops>,%a3
4448c: 9081 subl %d1,%d0
4448e: d7c0 addal %d0,%a3
rtems_libio_check_is_open( iop );
44490: 202b 0014 movel %a3@(20),%d0
44494: 0800 0008 btst #8,%d0
44498: 6706 beqs 444a0 <readv+0x3c>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4449a: 0800 0001 btst #1,%d0
4449e: 6610 bnes 444b0 <readv+0x4c> <== ALWAYS TAKEN
444a0: 4eb9 0004 caa4 jsr 4caa4 <__errno>
444a6: 7209 moveq #9,%d1
444a8: 2040 moveal %d0,%a0
444aa: 2081 movel %d1,%a0@
444ac: 6000 0098 braw 44546 <readv+0xe2>
/*
* Argument validation on IO vector
*/
if ( !iov )
444b0: 4a8a tstl %a2
444b2: 6728 beqs 444dc <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
444b4: 4a83 tstl %d3
444b6: 6f24 bles 444dc <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
444b8: 0c83 0000 0400 cmpil #1024,%d3
444be: 6e1c bgts 444dc <readv+0x78> <== NEVER TAKEN
444c0: 204a moveal %a2,%a0
444c2: 93c9 subal %a1,%a1
444c4: 4281 clrl %d1
444c6: 7001 moveq #1,%d0
444c8: 6002 bras 444cc <readv+0x68>
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
444ca: 2204 movel %d4,%d1
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
444cc: 4a90 tstl %a0@
444ce: 670c beqs 444dc <readv+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
444d0: 2428 0004 movel %a0@(4),%d2
444d4: 2802 movel %d2,%d4
444d6: d881 addl %d1,%d4
if ( total < old )
444d8: b284 cmpl %d4,%d1
444da: 6f0e bles 444ea <readv+0x86>
rtems_set_errno_and_return_minus_one( EINVAL );
444dc: 4eb9 0004 caa4 jsr 4caa4 <__errno>
444e2: 2040 moveal %d0,%a0
444e4: 7016 moveq #22,%d0
444e6: 2080 movel %d0,%a0@
444e8: 605c bras 44546 <readv+0xe2>
if ( iov[v].iov_len )
all_zeros = false;
444ea: 4a82 tstl %d2
444ec: 57c1 seq %d1
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
444ee: 5289 addql #1,%a1
444f0: 5088 addql #8,%a0
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
444f2: c081 andl %d1,%d0
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
444f4: b689 cmpl %a1,%d3
444f6: 66d2 bnes 444ca <readv+0x66>
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
444f8: 4a00 tstb %d0
444fa: 6646 bnes 44542 <readv+0xde>
444fc: 4284 clrl %d4
444fe: 4282 clrl %d2
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
44500: 206b 0020 moveal %a3@(32),%a0
44504: 2f2a 0004 movel %a2@(4),%sp@-
44508: 2f12 movel %a2@,%sp@-
4450a: 2f0b movel %a3,%sp@-
4450c: 2068 0008 moveal %a0@(8),%a0
44510: 4e90 jsr %a0@
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
44512: 4fef 000c lea %sp@(12),%sp
44516: 4a80 tstl %d0
44518: 6d2c blts 44546 <readv+0xe2> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
4451a: 6716 beqs 44532 <readv+0xce> <== NEVER TAKEN
iop->offset += bytes;
total += bytes;
4451c: d480 addl %d0,%d2
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
4451e: 2e00 movel %d0,%d7
44520: 5bc6 smi %d6
44522: 49c6 extbl %d6
44524: dfab 0010 addl %d7,%a3@(16)
44528: 222b 000c movel %a3@(12),%d1
4452c: d386 addxl %d6,%d1
4452e: 2741 000c movel %d1,%a3@(12)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
44532: b0aa 0004 cmpl %a2@(4),%d0
44536: 6610 bnes 44548 <readv+0xe4> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
44538: 5284 addql #1,%d4
4453a: 508a addql #8,%a2
4453c: b684 cmpl %d4,%d3
4453e: 66c0 bnes 44500 <readv+0x9c>
44540: 6006 bras 44548 <readv+0xe4>
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
return 0;
44542: 4282 clrl %d2
44544: 6002 bras 44548 <readv+0xe4>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
44546: 74ff moveq #-1,%d2
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
44548: 2002 movel %d2,%d0
4454a: 4cee 0cdc ffe4 moveml %fp@(-28),%d2-%d4/%d6-%d7/%a2-%a3
44550: 4e5e unlk %fp <== NOT EXECUTED
00059d90 <realloc>:
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
59d90: 7003 moveq #3,%d0
void *realloc(
void *ptr,
size_t size
)
{
59d92: 4e56 fff0 linkw %fp,#-16
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
59d96: 52b9 0005 d700 addql #1,5d700 <rtems_malloc_statistics+0x10>
void *realloc(
void *ptr,
size_t size
)
{
59d9c: 48d7 001c moveml %d2-%d4,%sp@
59da0: 242e 0008 movel %fp@(8),%d2
59da4: 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())) {
59da8: b0b9 0005 d968 cmpl 5d968 <_System_state_Current>,%d0
59dae: 6614 bnes 59dc4 <realloc+0x34> <== NEVER TAKEN
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
59db0: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0
59db6: 6600 00ac bnew 59e64 <realloc+0xd4>
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
59dba: 4ab9 0005 d9b8 tstl 5d9b8 <_Per_CPU_Information+0x8>
59dc0: 6600 00a2 bnew 59e64 <realloc+0xd4>
}
/*
* Continue with realloc().
*/
if ( !ptr )
59dc4: 4a82 tstl %d2
59dc6: 6612 bnes 59dda <realloc+0x4a>
return malloc( size );
59dc8: 2d43 0008 movel %d3,%fp@(8)
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
59dcc: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
59dd2: 4e5e unlk %fp
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
59dd4: 4ef9 0004 2e54 jmp 42e54 <malloc>
if ( !size ) {
59dda: 4a83 tstl %d3
59ddc: 660c bnes 59dea <realloc+0x5a> <== ALWAYS TAKEN
free( ptr );
59dde: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59de0: 4eb9 0004 2b68 jsr 42b68 <free> <== NOT EXECUTED
return (void *) 0;
59de6: 588f addql #4,%sp <== NOT EXECUTED
59de8: 607a bras 59e64 <realloc+0xd4> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
59dea: 486e fffc pea %fp@(-4)
59dee: 2f02 movel %d2,%sp@-
59df0: 2f39 0005 bfaa movel 5bfaa <RTEMS_Malloc_Heap>,%sp@-
59df6: 4eb9 0005 9f10 jsr 59f10 <_Protected_heap_Get_block_size>
59dfc: 4fef 000c lea %sp@(12),%sp
59e00: 4a00 tstb %d0
59e02: 660e bnes 59e12 <realloc+0x82>
errno = EINVAL;
59e04: 4eb9 0004 c034 jsr 4c034 <__errno>
59e0a: 2040 moveal %d0,%a0
59e0c: 7016 moveq #22,%d0
59e0e: 2080 movel %d0,%a0@
59e10: 6052 bras 59e64 <realloc+0xd4>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
59e12: 2f03 movel %d3,%sp@-
59e14: 2f02 movel %d2,%sp@-
59e16: 2f39 0005 bfaa movel 5bfaa <RTEMS_Malloc_Heap>,%sp@-
59e1c: 4eb9 0005 9f4c jsr 59f4c <_Protected_heap_Resize_block>
59e22: 4fef 000c lea %sp@(12),%sp
59e26: 4a00 tstb %d0
59e28: 663c bnes 59e66 <realloc+0xd6>
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
59e2a: 2f03 movel %d3,%sp@-
59e2c: 4eb9 0004 2e54 jsr 42e54 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
59e32: 588f addql #4,%sp
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
59e34: 53b9 0005 d6f4 subql #1,5d6f4 <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 );
59e3a: 2800 movel %d0,%d4
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
59e3c: 6726 beqs 59e64 <realloc+0xd4>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
59e3e: 202e fffc movel %fp@(-4),%d0
59e42: b083 cmpl %d3,%d0
59e44: 6402 bccs 59e48 <realloc+0xb8> <== NEVER TAKEN
59e46: 2600 movel %d0,%d3
59e48: 2f03 movel %d3,%sp@-
59e4a: 2f02 movel %d2,%sp@-
59e4c: 2f04 movel %d4,%sp@-
59e4e: 4eb9 0004 c854 jsr 4c854 <memcpy>
free( ptr );
59e54: 2f02 movel %d2,%sp@-
return new_area;
59e56: 2404 movel %d4,%d2
if ( !new_area ) {
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
59e58: 4eb9 0004 2b68 jsr 42b68 <free>
return new_area;
59e5e: 4fef 0010 lea %sp@(16),%sp
59e62: 6002 bras 59e66 <realloc+0xd6>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
59e64: 4282 clrl %d2
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
59e66: 2002 movel %d2,%d0
59e68: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
59e6e: 4e5e unlk %fp
...
00043a9c <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
43a9c: 4e56 ffbc linkw %fp,#-68
43aa0: 48d7 047c moveml %d2-%d6/%a2,%sp@
43aa4: 2a2e 0008 movel %fp@(8),%d5
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
43aa8: 2f05 movel %d5,%sp@-
43aaa: 4eb9 0004 2d30 jsr 42d30 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
43ab0: 588f addql #4,%sp
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
43ab2: 2c00 movel %d0,%d6
43ab4: 200e movel %fp,%d0
43ab6: 0680 ffff ffd4 addil #-44,%d0
if ( parentpathlen == 0 )
43abc: 4a86 tstl %d6
43abe: 6616 bnes 43ad6 <rmdir+0x3a>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
43ac0: 2f00 movel %d0,%sp@-
43ac2: 486e fffc pea %fp@(-4)
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
43ac6: 4204 clrb %d4
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
43ac8: 2f05 movel %d5,%sp@-
43aca: 4eb9 0004 3bc8 jsr 43bc8 <rtems_filesystem_get_start_loc>
43ad0: 4fef 000c lea %sp@(12),%sp
43ad4: 601e bras 43af4 <rmdir+0x58>
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
43ad6: 42a7 clrl %sp@-
43ad8: 2f00 movel %d0,%sp@-
43ada: 4878 0002 pea 2 <DOUBLE_FLOAT>
43ade: 2f06 movel %d6,%sp@-
43ae0: 2f05 movel %d5,%sp@-
43ae2: 4eb9 0004 2ce4 jsr 42ce4 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
43ae8: 4fef 0014 lea %sp@(20),%sp
43aec: 4a80 tstl %d0
43aee: 6600 00c8 bnew 43bb8 <rmdir+0x11c>
return -1;
free_parentloc = true;
43af2: 7801 moveq #1,%d4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
43af4: 4878 0014 pea 14 <OPER2>
43af8: 260e movel %fp,%d3
43afa: 0683 ffff ffd4 addil #-44,%d3
43b00: 240e movel %fp,%d2
43b02: 0682 ffff ffe8 addil #-24,%d2
name = pathname + parentpathlen;
43b08: da86 addl %d6,%d5
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
43b0a: 45f9 0004 d97c lea 4d97c <strlen>,%a2
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
43b10: 2f03 movel %d3,%sp@-
43b12: 2f02 movel %d2,%sp@-
43b14: 4eb9 0004 ce30 jsr 4ce30 <memcpy>
name = pathname + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
43b1a: 2f05 movel %d5,%sp@-
43b1c: 4e92 jsr %a2@
43b1e: 2e80 movel %d0,%sp@
43b20: 2f05 movel %d5,%sp@-
43b22: 4eb9 0004 2d72 jsr 42d72 <rtems_filesystem_prefix_separators>
43b28: da80 addl %d0,%d5
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
43b2a: 2f05 movel %d5,%sp@-
43b2c: 4e92 jsr %a2@
43b2e: 4297 clrl %sp@
43b30: 2f02 movel %d2,%sp@-
43b32: 42a7 clrl %sp@-
43b34: 2f00 movel %d0,%sp@-
43b36: 2f05 movel %d5,%sp@-
43b38: 4eb9 0004 2c74 jsr 42c74 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
43b3e: 4fef 0028 lea %sp@(40),%sp
43b42: 4a80 tstl %d0
43b44: 6710 beqs 43b56 <rmdir+0xba>
if ( free_parentloc )
43b46: 4a04 tstb %d4
43b48: 676e beqs 43bb8 <rmdir+0x11c>
rtems_filesystem_freenode( &parentloc );
43b4a: 2f03 movel %d3,%sp@-
43b4c: 4eb9 0004 2db0 jsr 42db0 <rtems_filesystem_freenode>
43b52: 588f addql #4,%sp
43b54: 6062 bras 43bb8 <rmdir+0x11c>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
43b56: 206e fff4 moveal %fp@(-12),%a0
43b5a: 2f02 movel %d2,%sp@-
43b5c: 2068 0010 moveal %a0@(16),%a0
43b60: 4e90 jsr %a0@
43b62: 588f addql #4,%sp
43b64: 7201 moveq #1,%d1
43b66: b280 cmpl %d0,%d1
43b68: 6724 beqs 43b8e <rmdir+0xf2>
rtems_filesystem_freenode( &loc );
43b6a: 2f02 movel %d2,%sp@-
43b6c: 45f9 0004 2db0 lea 42db0 <rtems_filesystem_freenode>,%a2
43b72: 4e92 jsr %a2@
if ( free_parentloc )
43b74: 588f addql #4,%sp
43b76: 4a04 tstb %d4
43b78: 6706 beqs 43b80 <rmdir+0xe4> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
43b7a: 2f03 movel %d3,%sp@-
43b7c: 4e92 jsr %a2@
43b7e: 588f addql #4,%sp
rtems_set_errno_and_return_minus_one( ENOTDIR );
43b80: 4eb9 0004 c610 jsr 4c610 <__errno>
43b86: 2040 moveal %d0,%a0
43b88: 7014 moveq #20,%d0
43b8a: 2080 movel %d0,%a0@
43b8c: 602a bras 43bb8 <rmdir+0x11c>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
43b8e: 2f02 movel %d2,%sp@-
43b90: 206e fff0 moveal %fp@(-16),%a0
43b94: 2f03 movel %d3,%sp@-
43b96: 2068 0034 moveal %a0@(52),%a0
rtems_filesystem_freenode( &loc );
43b9a: 45f9 0004 2db0 lea 42db0 <rtems_filesystem_freenode>,%a2
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
43ba0: 4e90 jsr %a0@
43ba2: 2a00 movel %d0,%d5
rtems_filesystem_freenode( &loc );
43ba4: 2f02 movel %d2,%sp@-
43ba6: 4e92 jsr %a2@
if ( free_parentloc )
43ba8: 4fef 000c lea %sp@(12),%sp
43bac: 4a04 tstb %d4
43bae: 670a beqs 43bba <rmdir+0x11e>
rtems_filesystem_freenode( &parentloc );
43bb0: 2f03 movel %d3,%sp@-
43bb2: 4e92 jsr %a2@
43bb4: 588f addql #4,%sp
43bb6: 6002 bras 43bba <rmdir+0x11e>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
43bb8: 7aff moveq #-1,%d5
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
43bba: 2005 movel %d5,%d0
43bbc: 4cee 047c ffbc moveml %fp@(-68),%d2-%d6/%a2
43bc2: 4e5e unlk %fp
...
0004a282 <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
4a282: 4e56 fff4 linkw %fp,#-12
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
4a286: 1039 0006 03a6 moveb 603a6 <bdbuf_cache+0x2e>,%d0
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
4a28c: 48d7 040c moveml %d2-%d3/%a2,%sp@
4a290: 246e 0008 moveal %fp@(8),%a2
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
4a294: 4a00 tstb %d0
4a296: 672a beqs 4a2c2 <rtems_bdbuf_add_to_modified_list_after_access+0x40><== ALWAYS TAKEN
4a298: 2039 0006 03ac movel 603ac <bdbuf_cache+0x34>,%d0 <== NOT EXECUTED
4a29e: 2239 0006 03b0 movel 603b0 <bdbuf_cache+0x38>,%d1 <== NOT EXECUTED
4a2a4: 242a 0012 movel %a2@(18),%d2 <== NOT EXECUTED
4a2a8: 262a 0016 movel %a2@(22),%d3 <== NOT EXECUTED
4a2ac: 9681 subl %d1,%d3 <== NOT EXECUTED
4a2ae: 9580 subxl %d0,%d2 <== NOT EXECUTED
4a2b0: 6610 bnes 4a2c2 <rtems_bdbuf_add_to_modified_list_after_access+0x40><== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
4a2b2: 4eba fce8 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>) <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
4a2b6: 4eba fb5c jsr %pc@(49e14 <rtems_bdbuf_lock_sync>) <== NOT EXECUTED
rtems_bdbuf_unlock_sync ();
4a2ba: 4eba fd06 jsr %pc@(49fc2 <rtems_bdbuf_unlock_sync>) <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4a2be: 4eba fb28 jsr %pc@(49de8 <rtems_bdbuf_lock_cache>) <== NOT EXECUTED
* difficult question. Is a snapshot of a block that is changing better than
* nothing being written? We have tended to think we should hold changes for
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
4a2c2: 202a 0022 movel %a2@(34),%d0
4a2c6: 7603 moveq #3,%d3
4a2c8: b680 cmpl %d0,%d3
4a2ca: 670a beqs 4a2d6 <rtems_bdbuf_add_to_modified_list_after_access+0x54>
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
4a2cc: 202a 0022 movel %a2@(34),%d0
4a2d0: 7205 moveq #5,%d1
4a2d2: b280 cmpl %d0,%d1
4a2d4: 660a bnes 4a2e0 <rtems_bdbuf_add_to_modified_list_after_access+0x5e>
bd->hold_timer = bdbuf_config.swap_block_hold;
4a2d6: 41f9 0005 d8cc lea 5d8cc <rtems_bdbuf_configuration+0x10>,%a0
4a2dc: 2550 002e movel %a0@,%a2@(46)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a2e0: 7007 moveq #7,%d0
4a2e2: 2540 0022 movel %d0,%a2@(34)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4a2e6: 2f0a movel %a2,%sp@-
4a2e8: 4879 0006 03c4 pea 603c4 <bdbuf_cache+0x4c>
4a2ee: 4eb9 0004 718c jsr 4718c <_Chain_Append>
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
4a2f4: 202a 0026 movel %a2@(38),%d0
4a2f8: 508f addql #8,%sp
4a2fa: 6716 beqs 4a312 <rtems_bdbuf_add_to_modified_list_after_access+0x90>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4a2fc: 223c 0006 03dc movel #394204,%d1
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
4a302: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4a308: 2d41 0008 movel %d1,%fp@(8)
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
4a30c: 4e5e unlk %fp
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4a30e: 6000 ff46 braw 4a256 <rtems_bdbuf_wake>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
4a312: 2039 0006 03ec movel 603ec <bdbuf_cache+0x74>,%d0
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
4a318: 670c beqs 4a326 <rtems_bdbuf_add_to_modified_list_after_access+0xa4>
rtems_bdbuf_wake_swapper ();
}
4a31a: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
4a320: 4e5e unlk %fp
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
4a322: 6000 fce8 braw 4a00c <rtems_bdbuf_wake_swapper>
}
4a326: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
4a32c: 4e5e unlk %fp <== NOT EXECUTED
0004a0fa <rtems_bdbuf_anonymous_wait>:
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
4a0fa: 4e56 0000 linkw %fp,#0
4a0fe: 2f0a movel %a2,%sp@-
4a100: 246e 0008 moveal %fp@(8),%a2
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
4a104: 2012 movel %a2@,%d0
4a106: 5280 addql #1,%d0
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
4a108: 2f02 movel %d2,%sp@-
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
4a10a: 2480 movel %d0,%a2@
* blocking or just hits that window, and before this task has blocked on the
* semaphore. If the preempting task flushes the queue this task will not see
* the flush and may block for ever or until another transaction flushes this
* semaphore.
*/
prev_mode = rtems_bdbuf_disable_preemption ();
4a10c: 4eba ff88 jsr %pc@(4a096 <rtems_bdbuf_disable_preemption>)
4a110: 2400 movel %d0,%d2
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
4a112: 4eba fe88 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
4a116: 42a7 clrl %sp@-
4a118: 42a7 clrl %sp@-
4a11a: 2f2a 0004 movel %a2@(4),%sp@-
4a11e: 4eb9 0004 66c8 jsr 466c8 <rtems_semaphore_obtain>
if (sc == RTEMS_TIMEOUT)
4a124: 4fef 000c lea %sp@(12),%sp
4a128: 7206 moveq #6,%d1
4a12a: b280 cmpl %d0,%d1
4a12c: 6608 bnes 4a136 <rtems_bdbuf_anonymous_wait+0x3c><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
4a12e: 2f3c 4200 0012 movel #1107296274,%sp@- <== NOT EXECUTED
4a134: 600c bras 4a142 <rtems_bdbuf_anonymous_wait+0x48><== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
4a136: 720d moveq #13,%d1
4a138: b280 cmpl %d0,%d1
4a13a: 670c beqs 4a148 <rtems_bdbuf_anonymous_wait+0x4e><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
4a13c: 2f3c 4200 0010 movel #1107296272,%sp@- <== NOT EXECUTED
4a142: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4a148: 4eba fc9e jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
rtems_bdbuf_restore_preemption (prev_mode);
4a14c: 2f02 movel %d2,%sp@-
4a14e: 4eba ff7a jsr %pc@(4a0ca <rtems_bdbuf_restore_preemption>)
--waiters->count;
4a152: 2012 movel %a2@,%d0
4a154: 5380 subql #1,%d0
4a156: 588f addql #4,%sp
4a158: 2480 movel %d0,%a2@
}
4a15a: 242e fff8 movel %fp@(-8),%d2
4a15e: 246e fffc moveal %fp@(-4),%a2
4a162: 4e5e unlk %fp <== NOT EXECUTED
0004a096 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
4a096: 4e56 fffc linkw %fp,#-4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
4a09a: 204e moveal %fp,%a0
4a09c: 42a0 clrl %a0@-
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4a09e: 2f08 movel %a0,%sp@-
4a0a0: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
4a0a4: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
4a0a8: 4eb9 0004 d768 jsr 4d768 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
4a0ae: 4fef 000c lea %sp@(12),%sp
4a0b2: 4a80 tstl %d0
4a0b4: 670c beqs 4a0c2 <rtems_bdbuf_disable_preemption+0x2c><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
4a0b6: 2f3c 4200 000f movel #1107296271,%sp@- <== NOT EXECUTED
4a0bc: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
return prev_mode;
}
4a0c2: 202e fffc movel %fp@(-4),%d0
4a0c6: 4e5e unlk %fp <== NOT EXECUTED
0004a8fc <rtems_bdbuf_execute_transfer_request>:
static rtems_status_code
rtems_bdbuf_execute_transfer_request (const rtems_disk_device *dd,
rtems_blkdev_request *req,
bool cache_locked)
{
4a8fc: 4e56 ffd8 linkw %fp,#-40
4a900: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4a904: 142e 0013 moveb %fp@(19),%d2
4a908: 266e 0008 moveal %fp@(8),%a3
4a90c: 246e 000c moveal %fp@(12),%a2
int result = 0;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
4a910: 6704 beqs 4a916 <rtems_bdbuf_execute_transfer_request+0x1a>
rtems_bdbuf_unlock_cache ();
4a912: 4eba f688 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
result = dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
4a916: 2f0a movel %a2,%sp@-
4a918: 2f3c c018 4201 movel #-1072152063,%sp@-
4a91e: 2f2b 0008 movel %a3@(8),%sp@-
4a922: 206b 0028 moveal %a3@(40),%a0
4a926: 4e90 jsr %a0@
if (result == 0)
4a928: 4fef 000c lea %sp@(12),%sp
4a92c: 4a80 tstl %d0
4a92e: 6610 bnes 4a940 <rtems_bdbuf_execute_transfer_request+0x44>
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
4a930: 4878 0002 pea 2 <DOUBLE_FLOAT>
4a934: 4eba f722 jsr %pc@(4a058 <rtems_bdbuf_wait_for_event>)
sc = req->status;
4a938: 262a 000c movel %a2@(12),%d3
4a93c: 588f addql #4,%sp
4a93e: 6002 bras 4a942 <rtems_bdbuf_execute_transfer_request+0x46>
}
else
sc = RTEMS_IO_ERROR;
4a940: 761b moveq #27,%d3
rtems_bdbuf_lock_cache ();
4a942: 4eba f4a4 jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
4a946: 284a moveal %a2,%a4
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4a948: 4284 clrl %d4
4a94a: 2e3c 0004 db60 movel #318304,%d7
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4a950: 4bf9 0004 718c lea 4718c <_Chain_Append>,%a5
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int result = 0;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
4a956: 4205 clrb %d5
bool cache_locked)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int result = 0;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
4a958: 4206 clrb %d6
else
sc = RTEMS_IO_ERROR;
rtems_bdbuf_lock_cache ();
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4a95a: 6066 bras 4a9c2 <rtems_bdbuf_execute_transfer_request+0xc6>
{
rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;
4a95c: 266c 0024 moveal %a4@(36),%a3
bool waiters = bd->waiters;
4a960: 202b 0026 movel %a3@(38),%d0
if (waiters)
4a964: 6704 beqs 4a96a <rtems_bdbuf_execute_transfer_request+0x6e>
wake_transfer_waiters = true;
4a966: 7c01 moveq #1,%d6
4a968: 6002 bras 4a96c <rtems_bdbuf_execute_transfer_request+0x70>
else
wake_buffer_waiters = true;
4a96a: 7a01 moveq #1,%d5
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4a96c: 206b 002a moveal %a3@(42),%a0
4a970: 53a8 000c subql #1,%a0@(12)
else
wake_buffer_waiters = true;
rtems_bdbuf_group_release (bd);
if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
4a974: 4a83 tstl %d3
4a976: 661e bnes 4a996 <rtems_bdbuf_execute_transfer_request+0x9a>
4a978: 202b 0022 movel %a3@(34),%d0
4a97c: 7209 moveq #9,%d1
4a97e: b280 cmpl %d0,%d1
4a980: 6614 bnes 4a996 <rtems_bdbuf_execute_transfer_request+0x9a><== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a982: 7002 moveq #2,%d0
4a984: 2740 0022 movel %d0,%a3@(34)
4a988: 2f0b movel %a3,%sp@-
4a98a: 4879 0006 03b8 pea 603b8 <bdbuf_cache+0x40>
4a990: 4e95 jsr %a5@
4a992: 508f addql #8,%sp
4a994: 6026 bras 4a9bc <rtems_bdbuf_execute_transfer_request+0xc0>
4a996: 7201 moveq #1,%d1
4a998: 2741 0022 movel %d1,%a3@(34)
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4a99c: 202b 0026 movel %a3@(38),%d0
4a9a0: 661a bnes 4a9bc <rtems_bdbuf_execute_transfer_request+0xc0>
{
rtems_bdbuf_remove_from_tree (bd);
4a9a2: 2f0b movel %a3,%sp@-
4a9a4: 4eba fa52 jsr %pc@(4a3f8 <rtems_bdbuf_remove_from_tree>)
4a9a8: 2047 moveal %d7,%a0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a9aa: 42ab 0022 clrl %a3@(34)
4a9ae: 2f0b movel %a3,%sp@-
4a9b0: 4879 0006 03b8 pea 603b8 <bdbuf_cache+0x40>
4a9b6: 4e90 jsr %a0@
4a9b8: 4fef 000c lea %sp@(12),%sp
else
sc = RTEMS_IO_ERROR;
rtems_bdbuf_lock_cache ();
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4a9bc: 5284 addql #1,%d4
4a9be: 49ec 0010 lea %a4@(16),%a4
4a9c2: b8aa 0010 cmpl %a2@(16),%d4
4a9c6: 6594 bcss 4a95c <rtems_bdbuf_execute_transfer_request+0x60>
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
4a9c8: 4a06 tstb %d6
4a9ca: 670c beqs 4a9d8 <rtems_bdbuf_execute_transfer_request+0xdc>
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
4a9cc: 4879 0006 03e4 pea 603e4 <bdbuf_cache+0x6c>
4a9d2: 4eba f882 jsr %pc@(4a256 <rtems_bdbuf_wake>)
4a9d6: 588f addql #4,%sp
if (wake_buffer_waiters)
4a9d8: 4a05 tstb %d5
4a9da: 670c beqs 4a9e8 <rtems_bdbuf_execute_transfer_request+0xec>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4a9dc: 4879 0006 03ec pea 603ec <bdbuf_cache+0x74>
4a9e2: 4eba f872 jsr %pc@(4a256 <rtems_bdbuf_wake>)
4a9e6: 588f addql #4,%sp
if (!cache_locked)
4a9e8: 4a02 tstb %d2
4a9ea: 6604 bnes 4a9f0 <rtems_bdbuf_execute_transfer_request+0xf4>
rtems_bdbuf_unlock_cache ();
4a9ec: 4eba f5ae jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
4a9f0: 4a83 tstl %d3
4a9f2: 6708 beqs 4a9fc <rtems_bdbuf_execute_transfer_request+0x100>
4a9f4: 700d moveq #13,%d0
4a9f6: b083 cmpl %d3,%d0
4a9f8: 6702 beqs 4a9fc <rtems_bdbuf_execute_transfer_request+0x100>
return sc;
else
return RTEMS_IO_ERROR;
4a9fa: 761b moveq #27,%d3
}
4a9fc: 2003 movel %d3,%d0
4a9fe: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5
4aa04: 4e5e unlk %fp <== NOT EXECUTED
00049e40 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
49e40: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
49e44: 202e 0008 movel %fp@(8),%d0 <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
49e48: 4840 swap %d0 <== NOT EXECUTED
49e4a: 4240 clrw %d0 <== NOT EXECUTED
49e4c: 80ae 000c orl %fp@(12),%d0 <== NOT EXECUTED
49e50: 2f00 movel %d0,%sp@- <== NOT EXECUTED
49e52: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
0004b794 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4b794: 4e56 ffe4 linkw %fp,#-28
4b798: 48d7 041c moveml %d2-%d4/%a2,%sp@
4b79c: 242e 0008 movel %fp@(8),%d2
4b7a0: 262e 000c movel %fp@(12),%d3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
4b7a4: 42ae fff4 clrl %fp@(-12)
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
4b7a8: 42ae fff8 clrl %fp@(-8)
size_t bds_per_group = 0;
4b7ac: 42ae fffc clrl %fp@(-4)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4b7b0: 4a39 0006 03fc tstb 603fc <bdbuf_cache+0x84>
4b7b6: 6700 0092 beqw 4b84a <rtems_bdbuf_get+0xb6>
4b7ba: 486e fffc pea %fp@(-4)
4b7be: 486e fff8 pea %fp@(-8)
4b7c2: 486e fff4 pea %fp@(-12)
4b7c6: 2f2e 0010 movel %fp@(16),%sp@-
4b7ca: 2f03 movel %d3,%sp@-
4b7cc: 2f02 movel %d2,%sp@-
4b7ce: 4eba eb60 jsr %pc@(4a330 <rtems_bdbuf_obtain_disk.part.7>)
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
4b7d2: 4fef 0018 lea %sp@(24),%sp
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4b7d6: 2800 movel %d0,%d4
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
4b7d8: 6672 bnes 4b84c <rtems_bdbuf_get+0xb8> <== NEVER TAKEN
return sc;
rtems_bdbuf_lock_cache ();
4b7da: 4eba e60c jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dev);
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
4b7de: 2f2e fffc movel %fp@(-4),%sp@-
4b7e2: 2f2e fff8 movel %fp@(-8),%sp@-
4b7e6: 2f03 movel %d3,%sp@-
4b7e8: 2f02 movel %d2,%sp@-
4b7ea: 4eba fa38 jsr %pc@(4b224 <rtems_bdbuf_get_buffer_for_access>)
switch (bd->state)
4b7ee: 4fef 0010 lea %sp@(16),%sp
4b7f2: 7202 moveq #2,%d1
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dev);
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
4b7f4: 2440 moveal %d0,%a2
switch (bd->state)
4b7f6: 202a 0022 movel %a2@(34),%d0
4b7fa: b280 cmpl %d0,%d1
4b7fc: 6712 beqs 4b810 <rtems_bdbuf_get+0x7c>
4b7fe: 123c 0007 moveb #7,%d1
4b802: b280 cmpl %d0,%d1
4b804: 6716 beqs 4b81c <rtems_bdbuf_get+0x88>
4b806: 123c 0001 moveb #1,%d1
4b80a: b280 cmpl %d0,%d1
4b80c: 6616 bnes 4b824 <rtems_bdbuf_get+0x90> <== NEVER TAKEN
4b80e: 6004 bras 4b814 <rtems_bdbuf_get+0x80>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b810: 7003 moveq #3,%d0
4b812: 600a bras 4b81e <rtems_bdbuf_get+0x8a>
4b814: 7205 moveq #5,%d1
4b816: 2541 0022 movel %d1,%a2@(34)
4b81a: 6018 bras 4b834 <rtems_bdbuf_get+0xa0>
4b81c: 7004 moveq #4,%d0
4b81e: 2540 0022 movel %d0,%a2@(34)
4b822: 6010 bras 4b834 <rtems_bdbuf_get+0xa0>
* so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_2);
4b824: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4b828: 2f3c 4200 001e movel #1107296286,%sp@- <== NOT EXECUTED
4b82e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b830: 4eba e60e jsr %pc@(49e40 <rtems_bdbuf_fatal>) <== NOT EXECUTED
{
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
rtems_bdbuf_unlock_cache ();
4b834: 4eba e766 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
rtems_bdbuf_release_disk (dd);
4b838: 2f2e fff4 movel %fp@(-12),%sp@-
4b83c: 4eba e7aa jsr %pc@(49fe8 <rtems_bdbuf_release_disk>)
*bd_ptr = bd;
4b840: 206e 0014 moveal %fp@(20),%a0
return RTEMS_SUCCESSFUL;
4b844: 588f addql #4,%sp
rtems_bdbuf_unlock_cache ();
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
4b846: 208a movel %a2,%a0@
return RTEMS_SUCCESSFUL;
4b848: 6002 bras 4b84c <rtems_bdbuf_get+0xb8>
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4b84a: 7816 moveq #22,%d4 <== NOT EXECUTED
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
return RTEMS_SUCCESSFUL;
}
4b84c: 2004 movel %d4,%d0
4b84e: 4cee 041c ffe4 moveml %fp@(-28),%d2-%d4/%a2
4b854: 4e5e unlk %fp <== NOT EXECUTED
0004b224 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
4b224: 4e56 ffd4 linkw %fp,#-44
4b228: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4b22c: 242e 0008 movel %fp@(8),%d2
4b230: 262e 000c movel %fp@(12),%d3
4b234: 2a2e 0010 movel %fp@(16),%d5
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
4b238: 2e3c 0004 a1fa movel #303610,%d7
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4b23e: 47fa ef26 lea %pc@(4a166 <rtems_bdbuf_wait>),%a3
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4b242: 2c3c 0004 71c4 movel #291268,%d6
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4b248: 4bf9 0004 718c lea 4718c <_Chain_Append>,%a5
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract (&bd->link);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
4b24e: 45fa edbc lea %pc@(4a00c <rtems_bdbuf_wake_swapper>),%a2
{
if (bd->group->bds_per_group != bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4b252: 49fa f490 lea %pc@(4a6e4 <rtems_bdbuf_remove_from_tree_and_lru_list>),%a4
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
4b256: 282e 0014 movel %fp@(20),%d4
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
4b25a: 2f05 movel %d5,%sp@-
4b25c: 2047 moveal %d7,%a0
4b25e: 2f03 movel %d3,%sp@-
4b260: 2f02 movel %d2,%sp@-
4b262: 2f39 0006 03b4 movel 603b4 <bdbuf_cache+0x3c>,%sp@-
4b268: 4e90 jsr %a0@
4b26a: 4fef 0010 lea %sp@(16),%sp
4b26e: 2040 moveal %d0,%a0
if (bd != NULL)
4b270: 4a80 tstl %d0
4b272: 6700 00c4 beqw 4b338 <rtems_bdbuf_get_buffer_for_access+0x114>
{
if (bd->group->bds_per_group != bds_per_group)
4b276: 2268 002a moveal %a0@(42),%a1
4b27a: b8a9 0008 cmpl %a1@(8),%d4
4b27e: 6700 00ee beqw 4b36e <rtems_bdbuf_get_buffer_for_access+0x14a>
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4b282: 2028 0022 movel %a0@(34),%d0
4b286: 720a moveq #10,%d1
4b288: b280 cmpl %d0,%d1
4b28a: 656e bcss 4b2fa <rtems_bdbuf_get_buffer_for_access+0xd6><== NEVER TAKEN
4b28c: 303b 0a08 movew %pc@(4b296 <rtems_bdbuf_get_buffer_for_access+0x72>,%d0:l:2),%d0
4b290: 48c0 extl %d0
4b292: 4efb 0802 jmp %pc@(4b296 <rtems_bdbuf_get_buffer_for_access+0x72>,%d0:l)
4b296: 0072 .short 0x0072 <== NOT EXECUTED
4b298: 003c .short 0x003c <== NOT EXECUTED
4b29a: 003c .short 0x003c <== NOT EXECUTED
4b29c: 0046 .short 0x0046 <== NOT EXECUTED
4b29e: 0046 .short 0x0046 <== NOT EXECUTED
4b2a0: 0046 .short 0x0046 <== NOT EXECUTED
4b2a2: 0046 .short 0x0046 <== NOT EXECUTED
4b2a4: 0016 .short 0x0016 <== NOT EXECUTED
4b2a6: 004e .short 0x004e <== NOT EXECUTED
4b2a8: 004e .short 0x004e <== NOT EXECUTED
4b2aa: 004e .short 0x004e <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b2ac: 7008 moveq #8,%d0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4b2ae: 2246 moveal %d6,%a1 <== NOT EXECUTED
4b2b0: 2140 0022 movel %d0,%a0@(34) <== NOT EXECUTED
4b2b4: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4b2b6: 2d48 fffc movel %a0,%fp@(-4) <== NOT EXECUTED
4b2ba: 4e91 jsr %a1@ <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4b2bc: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
4b2c0: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4b2c2: 4879 0006 03d0 pea 603d0 <bdbuf_cache+0x58> <== NOT EXECUTED
4b2c8: 4e95 jsr %a5@ <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract (&bd->link);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
4b2ca: 4e92 jsr %a2@ <== NOT EXECUTED
4b2cc: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4b2d0: 6022 bras 4b2f4 <rtems_bdbuf_get_buffer_for_access+0xd0><== NOT EXECUTED
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_request_sync_for_modified_buffer (bd);
break;
case RTEMS_BDBUF_STATE_CACHED:
case RTEMS_BDBUF_STATE_EMPTY:
if (bd->waiters == 0)
4b2d2: 2028 0026 movel %a0@(38),%d0
4b2d6: 6730 beqs 4b308 <rtems_bdbuf_get_buffer_for_access+0xe4><== NEVER TAKEN
4b2d8: 6000 0084 braw 4b35e <rtems_bdbuf_get_buffer_for_access+0x13a>
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4b2dc: 4879 0006 03dc pea 603dc <bdbuf_cache+0x64>
4b2e2: 6006 bras 4b2ea <rtems_bdbuf_get_buffer_for_access+0xc6>
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4b2e4: 4879 0006 03e4 pea 603e4 <bdbuf_cache+0x6c> <== NOT EXECUTED
4b2ea: 2f08 movel %a0,%sp@-
4b2ec: 2d48 fffc movel %a0,%fp@(-4)
4b2f0: 4e93 jsr %a3@
4b2f2: 508f addql #8,%sp
4b2f4: 206e fffc moveal %fp@(-4),%a0
4b2f8: 6088 bras 4b282 <rtems_bdbuf_get_buffer_for_access+0x5e>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_8);
4b2fa: 2028 0022 movel %a0@(34),%d0 <== NOT EXECUTED
4b2fe: 2f3c 4200 0006 movel #1107296262,%sp@- <== NOT EXECUTED
4b304: 6000 00da braw 4b3e0 <rtems_bdbuf_get_buffer_for_access+0x1bc><== NOT EXECUTED
{
if (bd->group->bds_per_group != bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4b308: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4b30a: 2d48 fffc movel %a0,%fp@(-4) <== NOT EXECUTED
4b30e: 4e94 jsr %a4@ <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b310: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
4b314: 42a8 0022 clrl %a0@(34) <== NOT EXECUTED
4b318: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4b31a: 4879 0006 03b8 pea 603b8 <bdbuf_cache+0x40> <== NOT EXECUTED
4b320: 4eb9 0004 db60 jsr 4db60 <_Chain_Insert> <== NOT EXECUTED
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4b326: 4879 0006 03ec pea 603ec <bdbuf_cache+0x74> <== NOT EXECUTED
4b32c: 4eba ef28 jsr %pc@(4a256 <rtems_bdbuf_wake>) <== NOT EXECUTED
4b330: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4b334: 6000 ff24 braw 4b25a <rtems_bdbuf_get_buffer_for_access+0x36><== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
4b338: 2f04 movel %d4,%sp@-
4b33a: 2f05 movel %d5,%sp@-
4b33c: 2f03 movel %d3,%sp@-
4b33e: 2f02 movel %d2,%sp@-
4b340: 4eba fbc6 jsr %pc@(4af08 <rtems_bdbuf_get_buffer_from_lru_list>)
if (bd == NULL)
4b344: 4fef 0010 lea %sp@(16),%sp
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
4b348: 2040 moveal %d0,%a0
if (bd == NULL)
4b34a: 4a80 tstl %d0
4b34c: 6620 bnes 4b36e <rtems_bdbuf_get_buffer_for_access+0x14a>
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4b34e: 203c 0006 03c8 movel #394184,%d0
4b354: b0b9 0006 03c4 cmpl 603c4 <bdbuf_cache+0x4c>,%d0
4b35a: 6702 beqs 4b35e <rtems_bdbuf_get_buffer_for_access+0x13a>
rtems_bdbuf_wake_swapper ();
4b35c: 4e92 jsr %a2@
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
4b35e: 4879 0006 03ec pea 603ec <bdbuf_cache+0x74>
4b364: 4eba ed94 jsr %pc@(4a0fa <rtems_bdbuf_anonymous_wait>)
4b368: 588f addql #4,%sp
4b36a: 6000 feee braw 4b25a <rtems_bdbuf_get_buffer_for_access+0x36>
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4b36e: 45fa edf6 lea %pc@(4a166 <rtems_bdbuf_wait>),%a2
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4b372: 2028 0022 movel %a0@(34),%d0
4b376: 7209 moveq #9,%d1
4b378: 5380 subql #1,%d0
4b37a: b280 cmpl %d0,%d1
4b37c: 6558 bcss 4b3d6 <rtems_bdbuf_get_buffer_for_access+0x1b2><== NEVER TAKEN
4b37e: 303b 0a08 movew %pc@(4b388 <rtems_bdbuf_get_buffer_for_access+0x164>,%d0:l:2),%d0
4b382: 48c0 extl %d0
4b384: 4efb 0802 jmp %pc@(4b388 <rtems_bdbuf_get_buffer_for_access+0x164>,%d0:l)
4b388: 005e .short 0x005e <== NOT EXECUTED
4b38a: 001c .short 0x001c <== NOT EXECUTED
4b38c: 0030 .short 0x0030 <== NOT EXECUTED
4b38e: 0030 .short 0x0030 <== NOT EXECUTED
4b390: 0030 .short 0x0030 <== NOT EXECUTED
4b392: 0030 .short 0x0030 <== NOT EXECUTED
4b394: 0014 .short 0x0014 <== NOT EXECUTED
4b396: 0038 .short 0x0038 <== NOT EXECUTED
4b398: 0038 .short 0x0038 <== NOT EXECUTED
4b39a: 0038 .short 0x0038 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4b39c: 2268 002a moveal %a0@(42),%a1
4b3a0: 53a9 000c subql #1,%a1@(12)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4b3a4: 2f08 movel %a0,%sp@-
4b3a6: 2d48 fffc movel %a0,%fp@(-4)
4b3aa: 4eb9 0004 71c4 jsr 471c4 <_Chain_Extract>
4b3b0: 206e fffc moveal %fp@(-4),%a0
4b3b4: 588f addql #4,%sp
4b3b6: 602e bras 4b3e6 <rtems_bdbuf_get_buffer_for_access+0x1c2>
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4b3b8: 4879 0006 03dc pea 603dc <bdbuf_cache+0x64>
4b3be: 6006 bras 4b3c6 <rtems_bdbuf_get_buffer_for_access+0x1a2>
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4b3c0: 4879 0006 03e4 pea 603e4 <bdbuf_cache+0x6c>
4b3c6: 2f08 movel %a0,%sp@-
4b3c8: 2d48 fffc movel %a0,%fp@(-4)
4b3cc: 4e92 jsr %a2@
4b3ce: 206e fffc moveal %fp@(-4),%a0
4b3d2: 508f addql #8,%sp
4b3d4: 609c bras 4b372 <rtems_bdbuf_get_buffer_for_access+0x14e>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_7);
4b3d6: 2028 0022 movel %a0@(34),%d0 <== NOT EXECUTED
4b3da: 2f3c 4200 0005 movel #1107296261,%sp@- <== NOT EXECUTED
4b3e0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b3e2: 4eba ea5c jsr %pc@(49e40 <rtems_bdbuf_fatal>) <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4b3e6: 2268 002a moveal %a0@(42),%a1
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
4b3ea: 2008 movel %a0,%d0
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4b3ec: 52a9 000c addql #1,%a1@(12)
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
4b3f0: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
4b3f6: 4e5e unlk %fp <== NOT EXECUTED
0004af08 <rtems_bdbuf_get_buffer_from_lru_list>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
4af08: 4e56 ff54 linkw %fp,#-172
4af0c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4af10: 2c2e 0010 movel %fp@(16),%d6
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4af14: 2a3c 0004 a6e4 movel #304868,%d5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4af1a: 2679 0006 03b8 moveal 603b8 <bdbuf_cache+0x40>,%a3
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
4af20: 242e 0008 movel %fp@(8),%d2
4af24: 262e 000c movel %fp@(12),%d3
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
4af28: 6000 02d6 braw 4b200 <rtems_bdbuf_get_buffer_from_lru_list+0x2f8>
bd->group->bds_per_group, bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
4af2c: 202b 0026 movel %a3@(38),%d0
4af30: 6600 02cc bnew 4b1fe <rtems_bdbuf_get_buffer_from_lru_list+0x2f6>
{
if (bd->group->bds_per_group == bds_per_group)
4af34: 246b 002a moveal %a3@(42),%a2
4af38: 2a6a 0008 moveal %a2@(8),%a5
4af3c: bbee 0014 cmpal %fp@(20),%a5
4af40: 660e bnes 4af50 <rtems_bdbuf_get_buffer_from_lru_list+0x48>
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4af42: 2f0b movel %a3,%sp@-
4af44: 2045 moveal %d5,%a0
4af46: 4e90 jsr %a0@
4af48: 588f addql #4,%sp
4af4a: 224b moveal %a3,%a1
4af4c: 6000 00a4 braw 4aff2 <rtems_bdbuf_get_buffer_from_lru_list+0xea>
empty_bd = bd;
}
else if (bd->group->users == 0)
4af50: 4aaa 000c tstl %a2@(12)
4af54: 6600 02a8 bnew 4b1fe <rtems_bdbuf_get_buffer_from_lru_list+0x2f6>
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
4af58: 2239 0006 0396 movel 60396 <bdbuf_cache+0x1e>,%d1
4af5e: 280d movel %a5,%d4
for (b = 0, bd = group->bdbuf;
4af60: 99cc subal %a4,%a4
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
4af62: 4c44 1001 remul %d4,%d1,%d1
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4af66: 783a moveq #58,%d4
4af68: 4c04 1800 mulsl %d4,%d1
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
4af6c: 202a 0010 movel %a2@(16),%d0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4af70: 2a41 moveal %d1,%a5
4af72: 6014 bras 4af88 <rtems_bdbuf_get_buffer_from_lru_list+0x80>
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4af74: 2f00 movel %d0,%sp@-
4af76: 2045 moveal %d5,%a0
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4af78: 528c addql #1,%a4
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4af7a: 2d40 ff7c movel %d0,%fp@(-132)
4af7e: 4e90 jsr %a0@
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4af80: 202e ff7c movel %fp@(-132),%d0
4af84: 588f addql #4,%sp
4af86: d08d addl %a5,%d0
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
4af88: b9ea 0008 cmpal %a2@(8),%a4
4af8c: 65e6 bcss 4af74 <rtems_bdbuf_get_buffer_from_lru_list+0x6c>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
4af8e: 202e 0014 movel %fp@(20),%d0
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4af92: 7e3a moveq #58,%d7
4af94: 387c 0001 moveaw #1,%a4
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
4af98: 2540 0008 movel %d0,%a2@(8)
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
4af9c: 2039 0006 0396 movel 60396 <bdbuf_cache+0x1e>,%d0
4afa2: 282e 0014 movel %fp@(20),%d4
4afa6: 4c44 0000 remul %d4,%d0,%d0
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4afaa: 2a6a 0010 moveal %a2@(16),%a5
4afae: 4c07 0800 mulsl %d7,%d0
4afb2: dbc0 addal %d0,%a5
4afb4: 6020 bras 4afd6 <rtems_bdbuf_get_buffer_from_lru_list+0xce>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4afb6: 42ad 0022 clrl %a5@(34)
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4afba: 528c addql #1,%a4
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4afbc: 2f0d movel %a5,%sp@-
4afbe: 4879 0006 03b8 pea 603b8 <bdbuf_cache+0x40>
4afc4: 2d40 ff7c movel %d0,%fp@(-132)
4afc8: 4eb9 0004 db60 jsr 4db60 <_Chain_Insert>
4afce: 202e ff7c movel %fp@(-132),%d0
4afd2: 508f addql #8,%sp
4afd4: dbc0 addal %d0,%a5
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4afd6: b9ea 0008 cmpal %a2@(8),%a4
4afda: 65da bcss 4afb6 <rtems_bdbuf_get_buffer_from_lru_list+0xae>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
4afdc: 7001 moveq #1,%d0
4afde: b08c cmpl %a4,%d0
4afe0: 640c bccs 4afee <rtems_bdbuf_get_buffer_from_lru_list+0xe6>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4afe2: 4879 0006 03ec pea 603ec <bdbuf_cache+0x74>
4afe8: 4eba f26c jsr %pc@(4a256 <rtems_bdbuf_wake>)
4afec: 588f addql #4,%sp
return group->bdbuf;
4afee: 226a 0010 moveal %a2@(16),%a1
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
4aff2: 4a89 tstl %a1
4aff4: 6700 0208 beqw 4b1fe <rtems_bdbuf_get_buffer_from_lru_list+0x2f6>
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
4aff8: 42a9 0008 clrl %a1@(8)
bd->avl.right = NULL;
4affc: 42a9 000c clrl %a1@(12)
rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
4b000: 2079 0006 03b4 moveal 603b4 <bdbuf_cache+0x3c>,%a0
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
4b006: 2342 0012 movel %d2,%a1@(18)
4b00a: 2343 0016 movel %d3,%a1@(22)
bd->block = block;
4b00e: 2346 001a movel %d6,%a1@(26)
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
4b012: 42a9 0026 clrl %a1@(38)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
4b016: 4a88 tstl %a0
4b018: 665e bnes 4b078 <rtems_bdbuf_get_buffer_from_lru_list+0x170>
{
*root = node;
4b01a: 23c9 0006 03b4 movel %a1,603b4 <bdbuf_cache+0x3c>
node->avl.left = NULL;
node->avl.right = NULL;
node->avl.bal = 0;
4b020: 4201 clrb %d1
bool modified = false;
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
4b022: 42a9 0008 clrl %a1@(8)
node->avl.right = NULL;
node->avl.bal = 0;
4b026: 1341 0011 moveb %d1,%a1@(17)
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
node->avl.right = NULL;
4b02a: 42a9 000c clrl %a1@(12)
4b02e: 6000 01c6 braw 4b1f6 <rtems_bdbuf_get_buffer_from_lru_list+0x2ee>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
4b032: 2004 movel %d4,%d0
4b034: 2205 movel %d5,%d1
4b036: 9283 subl %d3,%d1
4b038: 9182 subxl %d2,%d0
4b03a: 6622 bnes 4b05e <rtems_bdbuf_get_buffer_from_lru_list+0x156><== NEVER TAKEN
4b03c: 2028 001a movel %a0@(26),%d0
4b040: bc80 cmpl %d0,%d6
4b042: 6314 blss 4b058 <rtems_bdbuf_get_buffer_from_lru_list+0x150>
{
p->avl.cache = 1;
q = p->avl.right;
4b044: 2028 000c movel %a0@(12),%d0
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
4b048: 7201 moveq #1,%d1
4b04a: 1141 0010 moveb %d1,%a0@(16)
q = p->avl.right;
if (q == NULL)
4b04e: 4a80 tstl %d0
4b050: 6620 bnes 4b072 <rtems_bdbuf_get_buffer_from_lru_list+0x16a>
{
q = node;
p->avl.right = q = node;
4b052: 2149 000c movel %a1,%a0@(12)
4b056: 603c bras 4b094 <rtems_bdbuf_get_buffer_from_lru_list+0x18c>
break;
}
}
else if ((p->dev != dev) || (p->block != block))
4b058: bc80 cmpl %d0,%d6
4b05a: 6700 01bc beqw 4b218 <rtems_bdbuf_get_buffer_from_lru_list+0x310>
{
p->avl.cache = -1;
q = p->avl.left;
4b05e: 2028 0008 movel %a0@(8),%d0
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
4b062: 50c4 st %d4
4b064: 1144 0010 moveb %d4,%a0@(16)
q = p->avl.left;
if (q == NULL)
4b068: 4a80 tstl %d0
4b06a: 6606 bnes 4b072 <rtems_bdbuf_get_buffer_from_lru_list+0x16a>
{
q = node;
p->avl.left = q;
4b06c: 2149 0008 movel %a1,%a0@(8)
4b070: 6022 bras 4b094 <rtems_bdbuf_get_buffer_from_lru_list+0x18c>
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
4b072: 284a moveal %a2,%a4
4b074: 2040 moveal %d0,%a0
4b076: 6004 bras 4b07c <rtems_bdbuf_get_buffer_from_lru_list+0x174>
rtems_bdbuf_buffer* p = *root;
rtems_bdbuf_buffer* q;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
4b078: 49ee ff80 lea %fp@(-128),%a4
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4b07c: 244c moveal %a4,%a2
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
4b07e: 2828 0012 movel %a0@(18),%d4
4b082: 2a28 0016 movel %a0@(22),%d5
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4b086: 24c8 movel %a0,%a2@+
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
4b088: 2004 movel %d4,%d0
4b08a: 2205 movel %d5,%d1
4b08c: 9283 subl %d3,%d1
4b08e: 9182 subxl %d2,%d0
4b090: 65b2 bcss 4b044 <rtems_bdbuf_get_buffer_from_lru_list+0x13c><== NEVER TAKEN
4b092: 609e bras 4b032 <rtems_bdbuf_get_buffer_from_lru_list+0x12a>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
4b094: 42a9 000c clrl %a1@(12)
q->avl.bal = 0;
4b098: 4201 clrb %d1
}
p = q;
}
q->avl.left = q->avl.right = NULL;
4b09a: 42a9 0008 clrl %a1@(8)
q->avl.bal = 0;
4b09e: 1341 0011 moveb %d1,%a1@(17)
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4b0a2: 220e movel %fp,%d1
4b0a4: 0681 ffff ff80 addil #-128,%d1
4b0aa: 6002 bras 4b0ae <rtems_bdbuf_get_buffer_from_lru_list+0x1a6>
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
4b0ac: 204a moveal %a2,%a0
{
if (p->avl.cache == -1)
4b0ae: 76ff moveq #-1,%d3
4b0b0: 1428 0010 moveb %a0@(16),%d2
4b0b4: 1028 0011 moveb %a0@(17),%d0
4b0b8: 49c2 extbl %d2
4b0ba: b682 cmpl %d2,%d3
4b0bc: 667a bnes 4b138 <rtems_bdbuf_get_buffer_from_lru_list+0x230>
{
switch (p->avl.bal)
4b0be: 4a00 tstb %d0
4b0c0: 6718 beqs 4b0da <rtems_bdbuf_get_buffer_from_lru_list+0x1d2>
4b0c2: 49c0 extbl %d0
4b0c4: 7801 moveq #1,%d4
4b0c6: b880 cmpl %d0,%d4
4b0c8: 6708 beqs 4b0d2 <rtems_bdbuf_get_buffer_from_lru_list+0x1ca>
4b0ca: b680 cmpl %d0,%d3
4b0cc: 6600 00f6 bnew 4b1c4 <rtems_bdbuf_get_buffer_from_lru_list+0x2bc>
4b0d0: 6012 bras 4b0e4 <rtems_bdbuf_get_buffer_from_lru_list+0x1dc>
{
case 1:
p->avl.bal = 0;
4b0d2: 4207 clrb %d7
4b0d4: 1147 0011 moveb %d7,%a0@(17)
4b0d8: 6076 bras 4b150 <rtems_bdbuf_get_buffer_from_lru_list+0x248>
modified = false;
break;
case 0:
p->avl.bal = -1;
4b0da: 50c0 st %d0
4b0dc: 1140 0011 moveb %d0,%a0@(17)
4b0e0: 6000 00e2 braw 4b1c4 <rtems_bdbuf_get_buffer_from_lru_list+0x2bc>
break;
case -1:
p1 = p->avl.left;
4b0e4: 2668 0008 moveal %a0@(8),%a3
if (p1->avl.bal == -1) /* simple LL-turn */
4b0e8: 74ff moveq #-1,%d2
4b0ea: 102b 0011 moveb %a3@(17),%d0
4b0ee: 49c0 extbl %d0
4b0f0: b480 cmpl %d0,%d2
4b0f2: 660c bnes 4b100 <rtems_bdbuf_get_buffer_from_lru_list+0x1f8><== ALWAYS TAKEN
{
p->avl.left = p1->avl.right;
4b0f4: 216b 000c 0008 movel %a3@(12),%a0@(8) <== NOT EXECUTED
p1->avl.right = p;
4b0fa: 2748 000c movel %a0,%a3@(12) <== NOT EXECUTED
4b0fe: 6076 bras 4b176 <rtems_bdbuf_get_buffer_from_lru_list+0x26e><== NOT EXECUTED
p->avl.bal = 0;
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
4b100: 246b 000c moveal %a3@(12),%a2
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4b104: 78ff moveq #-1,%d4
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4b106: 7e01 moveq #1,%d7
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4b108: 102a 0011 moveb %a2@(17),%d0
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4b10c: 276a 0008 000c movel %a2@(8),%a3@(12)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4b112: 49c0 extbl %d0
4b114: b880 cmpl %d0,%d4
4b116: 56c0 sne %d0
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
4b118: 254b 0008 movel %a3,%a2@(8)
p->avl.left = p2->avl.right;
4b11c: 216a 000c 0008 movel %a2@(12),%a0@(8)
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4b122: 5280 addql #1,%d0
4b124: 1140 0011 moveb %d0,%a0@(17)
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
4b128: 2548 000c movel %a0,%a2@(12)
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4b12c: 102a 0011 moveb %a2@(17),%d0
4b130: 49c0 extbl %d0
4b132: be80 cmpl %d0,%d7
4b134: 57c0 seq %d0
4b136: 607e bras 4b1b6 <rtems_bdbuf_get_buffer_from_lru_list+0x2ae>
break;
}
}
else
{
switch (p->avl.bal)
4b138: 4a00 tstb %d0
4b13a: 6718 beqs 4b154 <rtems_bdbuf_get_buffer_from_lru_list+0x24c>
4b13c: 49c0 extbl %d0
4b13e: 7401 moveq #1,%d2
4b140: b480 cmpl %d0,%d2
4b142: 6718 beqs 4b15c <rtems_bdbuf_get_buffer_from_lru_list+0x254>
4b144: 76ff moveq #-1,%d3
4b146: b680 cmpl %d0,%d3
4b148: 667a bnes 4b1c4 <rtems_bdbuf_get_buffer_from_lru_list+0x2bc><== NEVER TAKEN
{
case -1:
p->avl.bal = 0;
4b14a: 4204 clrb %d4
4b14c: 1144 0011 moveb %d4,%a0@(17)
modified = false;
4b150: 4200 clrb %d0
4b152: 6072 bras 4b1c6 <rtems_bdbuf_get_buffer_from_lru_list+0x2be>
break;
case 0:
p->avl.bal = 1;
4b154: 7e01 moveq #1,%d7
4b156: 1147 0011 moveb %d7,%a0@(17)
4b15a: 6068 bras 4b1c4 <rtems_bdbuf_get_buffer_from_lru_list+0x2bc>
break;
case 1:
p1 = p->avl.right;
4b15c: 2668 000c moveal %a0@(12),%a3
if (p1->avl.bal == 1) /* simple RR-turn */
4b160: 7401 moveq #1,%d2
4b162: 102b 0011 moveb %a3@(17),%d0
4b166: 49c0 extbl %d0
4b168: b480 cmpl %d0,%d2
4b16a: 6614 bnes 4b180 <rtems_bdbuf_get_buffer_from_lru_list+0x278>
{
p->avl.right = p1->avl.left;
4b16c: 216b 0008 000c movel %a3@(8),%a0@(12)
p1->avl.left = p;
4b172: 2748 0008 movel %a0,%a3@(8)
p->avl.bal = 0;
4b176: 244b moveal %a3,%a2
4b178: 4203 clrb %d3
4b17a: 1143 0011 moveb %d3,%a0@(17)
4b17e: 603a bras 4b1ba <rtems_bdbuf_get_buffer_from_lru_list+0x2b2>
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
4b180: 246b 0008 moveal %a3@(8),%a2
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4b184: 7801 moveq #1,%d4
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4b186: 7eff moveq #-1,%d7
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4b188: 102a 0011 moveb %a2@(17),%d0
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4b18c: 276a 000c 0008 movel %a2@(12),%a3@(8)
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4b192: 49c0 extbl %d0
4b194: b880 cmpl %d0,%d4
4b196: 57c0 seq %d0
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
4b198: 254b 000c movel %a3,%a2@(12)
p->avl.right = p2->avl.left;
4b19c: 216a 0008 000c movel %a2@(8),%a0@(12)
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4b1a2: 1140 0011 moveb %d0,%a0@(17)
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
4b1a6: 2548 0008 movel %a0,%a2@(8)
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4b1aa: 102a 0011 moveb %a2@(17),%d0
4b1ae: 49c0 extbl %d0
4b1b0: be80 cmpl %d0,%d7
4b1b2: 56c0 sne %d0
4b1b4: 5280 addql #1,%d0
4b1b6: 1740 0011 moveb %d0,%a3@(17)
p = p2;
}
p->avl.bal = 0;
4b1ba: 204a moveal %a2,%a0
4b1bc: 4200 clrb %d0
4b1be: 1540 0011 moveb %d0,%a2@(17)
4b1c2: 6002 bras 4b1c6 <rtems_bdbuf_get_buffer_from_lru_list+0x2be>
break;
}
}
else
{
switch (p->avl.bal)
4b1c4: 7001 moveq #1,%d0
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4b1c6: b28c cmpl %a4,%d1
4b1c8: 641c bccs 4b1e6 <rtems_bdbuf_get_buffer_from_lru_list+0x2de>
{
p = *--buf_prev;
4b1ca: 246c fffc moveal %a4@(-4),%a2
if (p->avl.cache == -1)
4b1ce: 76ff moveq #-1,%d3
4b1d0: 142a 0010 moveb %a2@(16),%d2
4b1d4: 49c2 extbl %d2
4b1d6: b682 cmpl %d2,%d3
4b1d8: 6606 bnes 4b1e0 <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
{
p->avl.left = q;
4b1da: 2548 0008 movel %a0,%a2@(8)
4b1de: 600e bras 4b1ee <rtems_bdbuf_get_buffer_from_lru_list+0x2e6>
}
else
{
p->avl.right = q;
4b1e0: 2548 000c movel %a0,%a2@(12)
4b1e4: 6008 bras 4b1ee <rtems_bdbuf_get_buffer_from_lru_list+0x2e6>
}
}
else
{
*root = p;
4b1e6: 23c8 0006 03b4 movel %a0,603b4 <bdbuf_cache+0x3c>
4b1ec: 6008 bras 4b1f6 <rtems_bdbuf_get_buffer_from_lru_list+0x2ee>
4b1ee: 598c subql #4,%a4
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
4b1f0: 4a00 tstb %d0
4b1f2: 6600 feb8 bnew 4b0ac <rtems_bdbuf_get_buffer_from_lru_list+0x1a4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b1f6: 7801 moveq #1,%d4
4b1f8: 2344 0022 movel %d4,%a1@(34)
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dev, block);
return empty_bd;
4b1fc: 600e bras 4b20c <rtems_bdbuf_get_buffer_from_lru_list+0x304>
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
}
4b1fe: 2653 moveal %a3@,%a3
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
4b200: b7fc 0006 03bc cmpal #394172,%a3
4b206: 6600 fd24 bnew 4af2c <rtems_bdbuf_get_buffer_from_lru_list+0x24>
}
node = rtems_chain_next (node);
}
return NULL;
4b20a: 93c9 subal %a1,%a1
}
4b20c: 2009 movel %a1,%d0
4b20e: 4cee 3cfc ff54 moveml %fp@(-172),%d2-%d7/%a2-%a5
4b214: 4e5e unlk %fp
4b216: 4e75 rts
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_RECYCLE);
4b218: 2f3c 4200 001b movel #1107296283,%sp@- <== NOT EXECUTED
4b21e: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
0004b3fa <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
4b3fa: 4e56 ffe4 linkw %fp,#-28
4b3fe: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
4b402: 4ab9 0006 0dd0 tstl 60dd0 <_Per_CPU_Information+0x8>
4b408: 6600 037a bnew 4b784 <rtems_bdbuf_init+0x38a>
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
4b40c: 2439 0005 d8dc movel 5d8dc <rtems_bdbuf_configuration+0x20>,%d2
4b412: 2839 0005 d8e0 movel 5d8e0 <rtems_bdbuf_configuration+0x24>,%d4
4b418: 4c42 4000 remul %d2,%d0,%d4
4b41c: 4c42 4004 remul %d2,%d4,%d4
4b420: 4a80 tstl %d0
4b422: 6600 0364 bnew 4b788 <rtems_bdbuf_init+0x38e>
/*
* We use a special variable to manage the initialisation incase we have
* completing threads doing this. You may get errors if the another thread
* makes a call and we have not finished initialisation.
*/
prev_mode = rtems_bdbuf_disable_preemption ();
4b426: 4eba ec6e jsr %pc@(4a096 <rtems_bdbuf_disable_preemption>)
4b42a: 2600 movel %d0,%d3
if (bdbuf_cache.initialised)
4b42c: 4a39 0006 03fc tstb 603fc <bdbuf_cache+0x84>
4b432: 670e beqs 4b442 <rtems_bdbuf_init+0x48> <== ALWAYS TAKEN
{
rtems_bdbuf_restore_preemption (prev_mode);
4b434: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b436: 4eba ec92 jsr %pc@(4a0ca <rtems_bdbuf_restore_preemption>)<== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
4b43a: 588f addql #4,%sp <== NOT EXECUTED
4b43c: 700c moveq #12,%d0 <== NOT EXECUTED
4b43e: 6000 034a braw 4b78a <rtems_bdbuf_init+0x390> <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
4b442: 4878 0086 pea 86 <DBL_MANT_DIG+0x51>
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4b446: 45f9 0004 648c lea 4648c <rtems_semaphore_create>,%a2
{
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
4b44c: 42a7 clrl %sp@-
4b44e: 4879 0006 0378 pea 60378 <bdbuf_cache>
4b454: 4eb9 0004 fecc jsr 4fecc <memset>
bdbuf_cache.initialised = true;
4b45a: 7001 moveq #1,%d0
rtems_bdbuf_restore_preemption (prev_mode);
4b45c: 2f03 movel %d3,%sp@-
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
bdbuf_cache.initialised = true;
4b45e: 13c0 0006 03fc moveb %d0,603fc <bdbuf_cache+0x84>
rtems_bdbuf_restore_preemption (prev_mode);
4b464: 4eba ec64 jsr %pc@(4a0ca <rtems_bdbuf_restore_preemption>)
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4b468: 4879 0006 039e pea 6039e <bdbuf_cache+0x26>
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
4b46e: 70ff moveq #-1,%d0
4b470: 72ff moveq #-1,%d1
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4b472: 42a7 clrl %sp@-
4b474: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
4b478: 4878 0001 pea 1 <ADD>
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
4b47c: 23c0 0006 03ac movel %d0,603ac <bdbuf_cache+0x34>
4b482: 23c1 0006 03b0 movel %d1,603b0 <bdbuf_cache+0x38>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b488: 223c 0006 0382 movel #394114,%d1
head->previous = NULL;
tail->previous = head;
4b48e: 203c 0006 037e movel #394110,%d0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b494: 23c1 0006 037e movel %d1,6037e <bdbuf_cache+0x6>
4b49a: 223c 0006 03bc movel #394172,%d1
head->previous = NULL;
tail->previous = head;
4b4a0: 23c0 0006 0386 movel %d0,60386 <bdbuf_cache+0xe>
4b4a6: 203c 0006 03b8 movel #394168,%d0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b4ac: 23c1 0006 03b8 movel %d1,603b8 <bdbuf_cache+0x40>
4b4b2: 223c 0006 03c8 movel #394184,%d1
head->previous = NULL;
tail->previous = head;
4b4b8: 23c0 0006 03c0 movel %d0,603c0 <bdbuf_cache+0x48>
4b4be: 203c 0006 03c4 movel #394180,%d0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b4c4: 23c1 0006 03c4 movel %d1,603c4 <bdbuf_cache+0x4c>
4b4ca: 223c 0006 03d4 movel #394196,%d1
head->previous = NULL;
tail->previous = head;
4b4d0: 23c0 0006 03cc movel %d0,603cc <bdbuf_cache+0x54>
4b4d6: 203c 0006 03d0 movel #394192,%d0
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4b4dc: 2f3c 4244 436c movel #1111769964,%sp@-
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4b4e2: 42b9 0006 0382 clrl 60382 <bdbuf_cache+0xa>
4b4e8: 42b9 0006 03bc clrl 603bc <bdbuf_cache+0x44>
4b4ee: 42b9 0006 03c8 clrl 603c8 <bdbuf_cache+0x50>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4b4f4: 23c1 0006 03d0 movel %d1,603d0 <bdbuf_cache+0x58>
head->previous = NULL;
4b4fa: 42b9 0006 03d4 clrl 603d4 <bdbuf_cache+0x5c>
tail->previous = head;
4b500: 23c0 0006 03d8 movel %d0,603d8 <bdbuf_cache+0x60>
4b506: 4e92 jsr %a2@
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
4b508: 4fef 0024 lea %sp@(36),%sp
4b50c: 4a80 tstl %d0
4b50e: 6600 01f8 bnew 4b708 <rtems_bdbuf_init+0x30e>
goto error;
rtems_bdbuf_lock_cache ();
4b512: 4eba e8d4 jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
4b516: 4879 0006 03a2 pea 603a2 <bdbuf_cache+0x2a>
4b51c: 42a7 clrl %sp@-
4b51e: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
4b522: 4878 0001 pea 1 <ADD>
4b526: 2f3c 4244 4373 movel #1111769971,%sp@-
4b52c: 4e92 jsr %a2@
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
4b52e: 4fef 0014 lea %sp@(20),%sp
4b532: 4a80 tstl %d0
4b534: 6600 01d2 bnew 4b708 <rtems_bdbuf_init+0x30e>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
4b538: 4879 0006 03e0 pea 603e0 <bdbuf_cache+0x68>
4b53e: 42a7 clrl %sp@-
4b540: 4878 0024 pea 24 <OPER2+0x10>
4b544: 42a7 clrl %sp@-
4b546: 2f3c 4244 4361 movel #1111769953,%sp@-
4b54c: 4e92 jsr %a2@
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4b54e: 4fef 0014 lea %sp@(20),%sp
4b552: 4a80 tstl %d0
4b554: 6600 01b2 bnew 4b708 <rtems_bdbuf_init+0x30e>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
4b558: 4879 0006 03e8 pea 603e8 <bdbuf_cache+0x70>
4b55e: 42a7 clrl %sp@-
4b560: 4878 0024 pea 24 <OPER2+0x10>
4b564: 42a7 clrl %sp@-
4b566: 2f3c 4244 4374 movel #1111769972,%sp@-
4b56c: 4e92 jsr %a2@
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4b56e: 4fef 0014 lea %sp@(20),%sp
4b572: 4a80 tstl %d0
4b574: 6600 0192 bnew 4b708 <rtems_bdbuf_init+0x30e>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
4b578: 4879 0006 03f0 pea 603f0 <bdbuf_cache+0x78>
4b57e: 42a7 clrl %sp@-
4b580: 4878 0024 pea 24 <OPER2+0x10>
4b584: 42a7 clrl %sp@-
4b586: 2f3c 4244 4362 movel #1111769954,%sp@-
4b58c: 4e92 jsr %a2@
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4b58e: 4fef 0014 lea %sp@(20),%sp
4b592: 4a80 tstl %d0
4b594: 6600 0172 bnew 4b708 <rtems_bdbuf_init+0x30e>
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4b598: 2639 0005 d8d8 movel 5d8d8 <rtems_bdbuf_configuration+0x1c>,%d3
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4b59e: 45f9 0004 3294 lea 43294 <calloc>,%a2
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4b5a4: 4c42 3003 remul %d2,%d3,%d3
bdbuf_cache.max_bds_per_group =
4b5a8: 23c4 0006 0396 movel %d4,60396 <bdbuf_cache+0x1e>
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4b5ae: 2203 movel %d3,%d1
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4b5b0: 2f03 movel %d3,%sp@-
4b5b2: 4878 003a pea 3a <DBL_MANT_DIG+0x5>
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4b5b6: 4c44 1001 remul %d4,%d1,%d1
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
4b5ba: 23c3 0006 0392 movel %d3,60392 <bdbuf_cache+0x1a>
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4b5c0: 2801 movel %d1,%d4
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
4b5c2: 23c1 0006 03f4 movel %d1,603f4 <bdbuf_cache+0x7c>
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4b5c8: 4e92 jsr %a2@
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
4b5ca: 508f addql #8,%sp
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4b5cc: 23c0 0006 038a movel %d0,6038a <bdbuf_cache+0x12>
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
4b5d2: 6700 0134 beqw 4b708 <rtems_bdbuf_init+0x30e>
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
4b5d6: 2f04 movel %d4,%sp@-
4b5d8: 4878 0014 pea 14 <OPER2>
4b5dc: 4e92 jsr %a2@
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
4b5de: 508f addql #8,%sp
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
4b5e0: 23c0 0006 03f8 movel %d0,603f8 <bdbuf_cache+0x80>
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
4b5e6: 6700 0120 beqw 4b708 <rtems_bdbuf_init+0x30e>
* aligned. It is possible to free the memory allocated by rtems_memalign()
* with free(). Return 0 if allocated.
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
4b5ea: 4c02 3800 mulsl %d2,%d3
4b5ee: 2f03 movel %d3,%sp@-
4b5f0: 4878 0020 pea 20 <OPER2+0xc>
4b5f4: 4879 0006 038e pea 6038e <bdbuf_cache+0x16>
4b5fa: 4eb9 0004 d49c jsr 4d49c <rtems_memalign>
4b600: 4fef 000c lea %sp@(12),%sp
4b604: 4a80 tstl %d0
4b606: 6600 0100 bnew 4b708 <rtems_bdbuf_init+0x30e>
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4b60a: 2a39 0006 03f8 movel 603f8 <bdbuf_cache+0x80>,%d5
4b610: 4283 clrl %d3
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4b612: 47f9 0004 718c lea 4718c <_Chain_Append>,%a3
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4b618: 2479 0006 038a moveal 6038a <bdbuf_cache+0x12>,%a2
4b61e: 2839 0006 038e movel 6038e <bdbuf_cache+0x16>,%d4
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4b624: 6040 bras 4b666 <rtems_bdbuf_init+0x26c>
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
bd->group = group;
4b626: 2545 002a movel %d5,%a2@(42)
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4b62a: 2c03 movel %d3,%d6
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
4b62c: 70ff moveq #-1,%d0
4b62e: 72ff moveq #-1,%d1
bd->group = group;
bd->buffer = buffer;
4b630: 2544 001e movel %d4,%a2@(30)
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
4b634: 2540 0012 movel %d0,%a2@(18)
4b638: 2541 0016 movel %d1,%a2@(22)
4b63c: 2f0a movel %a2,%sp@-
4b63e: 4879 0006 03b8 pea 603b8 <bdbuf_cache+0x40>
4b644: 4e93 jsr %a3@
bd->group = group;
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4b646: 2039 0006 0396 movel 60396 <bdbuf_cache+0x1e>,%d0
4b64c: 508f addql #8,%sp
4b64e: 4c40 6001 remul %d0,%d1,%d6
(bdbuf_cache.max_bds_per_group - 1))
4b652: 5380 subql #1,%d0
bd->group = group;
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4b654: b081 cmpl %d1,%d0
4b656: 6606 bnes 4b65e <rtems_bdbuf_init+0x264>
(bdbuf_cache.max_bds_per_group - 1))
group++;
4b658: 0685 0000 0014 addil #20,%d5
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
4b65e: 5283 addql #1,%d3
4b660: 45ea 003a lea %a2@(58),%a2
4b664: d882 addl %d2,%d4
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4b666: b6b9 0006 0392 cmpl 60392 <bdbuf_cache+0x1a>,%d3
4b66c: 65b8 bcss 4b626 <rtems_bdbuf_init+0x22c>
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4b66e: 2439 0006 0396 movel 60396 <bdbuf_cache+0x1e>,%d2
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
4b674: 763a moveq #58,%d3
4b676: 4c02 3800 mulsl %d2,%d3
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
4b67a: 4280 clrl %d0
group = bdbuf_cache.groups,
4b67c: 2079 0006 03f8 moveal 603f8 <bdbuf_cache+0x80>,%a0
bd = bdbuf_cache.bds;
4b682: 2239 0006 038a movel 6038a <bdbuf_cache+0x12>,%d1
b < bdbuf_cache.group_count;
4b688: 2279 0006 03f4 moveal 603f4 <bdbuf_cache+0x7c>,%a1
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
4b68e: 6010 bras 4b6a0 <rtems_bdbuf_init+0x2a6>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
4b690: 2141 0010 movel %d1,%a0@(16)
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
4b694: 5280 addql #1,%d0
group++,
bd += bdbuf_cache.max_bds_per_group)
4b696: d283 addl %d3,%d1
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4b698: 2142 0008 movel %d2,%a0@(8)
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
4b69c: 41e8 0014 lea %a0@(20),%a0
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
4b6a0: b3c0 cmpal %d0,%a1
4b6a2: 66ec bnes 4b690 <rtems_bdbuf_init+0x296>
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
bdbuf_config.swapout_priority ?
4b6a4: 2039 0005 d8c4 movel 5d8c4 <rtems_bdbuf_configuration+0x8>,%d0
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
4b6aa: 7201 moveq #1,%d1
4b6ac: 13c1 0006 037c moveb %d1,6037c <bdbuf_cache+0x4>
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
4b6b2: 4a80 tstl %d0
4b6b4: 6604 bnes 4b6ba <rtems_bdbuf_init+0x2c0> <== ALWAYS TAKEN
4b6b6: 103c 000f moveb #15,%d0 <== NOT EXECUTED
4b6ba: 4879 0006 0378 pea 60378 <bdbuf_cache>
4b6c0: 42a7 clrl %sp@-
4b6c2: 4878 0400 pea 400 <D_BIAS+0x2>
4b6c6: 4878 2000 pea 2000 <D_MAX_EXP+0x1801>
4b6ca: 2f00 movel %d0,%sp@-
4b6cc: 2f3c 4253 5750 movel #1112758096,%sp@-
4b6d2: 4eb9 0004 6880 jsr 46880 <rtems_task_create>
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
4b6d8: 4fef 0018 lea %sp@(24),%sp
4b6dc: 4a80 tstl %d0
4b6de: 6628 bnes 4b708 <rtems_bdbuf_init+0x30e> <== NEVER TAKEN
goto error;
sc = rtems_task_start (bdbuf_cache.swapout,
4b6e0: 4879 0006 0378 pea 60378 <bdbuf_cache>
4b6e6: 487a f470 pea %pc@(4ab58 <rtems_bdbuf_swapout_task>)
4b6ea: 2f39 0006 0378 movel 60378 <bdbuf_cache>,%sp@-
4b6f0: 4eb9 0004 6ab4 jsr 46ab4 <rtems_task_start>
rtems_bdbuf_swapout_task,
(rtems_task_argument) &bdbuf_cache);
if (sc != RTEMS_SUCCESSFUL)
4b6f6: 4fef 000c lea %sp@(12),%sp
4b6fa: 4a80 tstl %d0
4b6fc: 660a bnes 4b708 <rtems_bdbuf_init+0x30e> <== NEVER TAKEN
goto error;
rtems_bdbuf_unlock_cache ();
4b6fe: 4eba e89c jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
return RTEMS_SUCCESSFUL;
4b702: 4280 clrl %d0
4b704: 6000 0084 braw 4b78a <rtems_bdbuf_init+0x390>
error:
if (bdbuf_cache.swapout != 0)
4b708: 2039 0006 0378 movel 60378 <bdbuf_cache>,%d0 <== NOT EXECUTED
4b70e: 670a beqs 4b71a <rtems_bdbuf_init+0x320> <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
4b710: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4b712: 4eb9 0004 69a4 jsr 469a4 <rtems_task_delete> <== NOT EXECUTED
4b718: 588f addql #4,%sp <== NOT EXECUTED
free (bdbuf_cache.buffers);
4b71a: 2f39 0006 038e movel 6038e <bdbuf_cache+0x16>,%sp@- <== NOT EXECUTED
4b720: 45f9 0004 3630 lea 43630 <free>,%a2 <== NOT EXECUTED
4b726: 4e92 jsr %a2@ <== NOT EXECUTED
free (bdbuf_cache.groups);
4b728: 2f39 0006 03f8 movel 603f8 <bdbuf_cache+0x80>,%sp@- <== NOT EXECUTED
4b72e: 4e92 jsr %a2@ <== NOT EXECUTED
free (bdbuf_cache.bds);
4b730: 2f39 0006 038a movel 6038a <bdbuf_cache+0x12>,%sp@- <== NOT EXECUTED
4b736: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
4b738: 2f39 0006 03f0 movel 603f0 <bdbuf_cache+0x78>,%sp@- <== NOT EXECUTED
4b73e: 45f9 0004 662c lea 4662c <rtems_semaphore_delete>,%a2 <== NOT EXECUTED
4b744: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
4b746: 2f39 0006 03e0 movel 603e0 <bdbuf_cache+0x68>,%sp@- <== NOT EXECUTED
4b74c: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
4b74e: 2f39 0006 03e8 movel 603e8 <bdbuf_cache+0x70>,%sp@- <== NOT EXECUTED
4b754: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
4b756: 2f39 0006 03a2 movel 603a2 <bdbuf_cache+0x2a>,%sp@- <== NOT EXECUTED
4b75c: 4e92 jsr %a2@ <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
4b75e: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4b762: 4ab9 0006 039e tstl 6039e <bdbuf_cache+0x26> <== NOT EXECUTED
4b768: 670e beqs 4b778 <rtems_bdbuf_init+0x37e> <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
4b76a: 4eba e830 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>) <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
4b76e: 2f39 0006 039e movel 6039e <bdbuf_cache+0x26>,%sp@- <== NOT EXECUTED
4b774: 4e92 jsr %a2@ <== NOT EXECUTED
4b776: 588f addql #4,%sp <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
4b778: 4200 clrb %d0 <== NOT EXECUTED
4b77a: 13c0 0006 03fc moveb %d0,603fc <bdbuf_cache+0x84> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
4b780: 700d moveq #13,%d0 <== NOT EXECUTED
4b782: 6006 bras 4b78a <rtems_bdbuf_init+0x390> <== NOT EXECUTED
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
return RTEMS_CALLED_FROM_ISR;
4b784: 7012 moveq #18,%d0 <== NOT EXECUTED
4b786: 6002 bras 4b78a <rtems_bdbuf_init+0x390> <== NOT EXECUTED
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
return RTEMS_INVALID_NUMBER;
4b788: 700a moveq #10,%d0 <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
return RTEMS_UNSATISFIED;
}
4b78a: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
4b790: 4e5e unlk %fp <== NOT EXECUTED
00049de8 <rtems_bdbuf_lock_cache>:
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
49de8: 4e56 0000 linkw %fp,#0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
49dec: 42a7 clrl %sp@-
49dee: 42a7 clrl %sp@-
49df0: 2f39 0006 039e movel 6039e <bdbuf_cache+0x26>,%sp@-
49df6: 4eb9 0004 66c8 jsr 466c8 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
49dfc: 4fef 000c lea %sp@(12),%sp
49e00: 4a80 tstl %d0
49e02: 670c beqs 49e10 <rtems_bdbuf_lock_cache+0x28> <== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
49e04: 2f3c 4200 000d movel #1107296269,%sp@- <== NOT EXECUTED
49e0a: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_lock_cache (void)
{
rtems_bdbuf_lock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_LOCK);
}
49e10: 4e5e unlk %fp <== NOT EXECUTED
00049e14 <rtems_bdbuf_lock_sync>:
/**
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
49e14: 4e56 0000 linkw %fp,#0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
49e18: 42a7 clrl %sp@-
49e1a: 42a7 clrl %sp@-
49e1c: 2f39 0006 03a2 movel 603a2 <bdbuf_cache+0x2a>,%sp@-
49e22: 4eb9 0004 66c8 jsr 466c8 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
49e28: 4fef 000c lea %sp@(12),%sp
49e2c: 4a80 tstl %d0
49e2e: 670c beqs 49e3c <rtems_bdbuf_lock_sync+0x28> <== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
49e30: 2f3c 4200 000b movel #1107296267,%sp@- <== NOT EXECUTED
49e36: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_lock_sync (void)
{
rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BLKDEV_FATAL_BDBUF_SYNC_LOCK);
}
49e3c: 4e5e unlk %fp <== NOT EXECUTED
0004a330 <rtems_bdbuf_obtain_disk.part.7>:
return bd;
}
static rtems_status_code
rtems_bdbuf_obtain_disk (dev_t dev,
4a330: 4e56 ffe4 linkw %fp,#-28
4a334: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
4a338: 2f2e 000c movel %fp@(12),%sp@-
4a33c: 2f2e 0008 movel %fp@(8),%sp@-
return bd;
}
static rtems_status_code
rtems_bdbuf_obtain_disk (dev_t dev,
4a340: 286e 0018 moveal %fp@(24),%a4
4a344: 266e 001c moveal %fp@(28),%a3
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
4a348: 4eb9 0004 2912 jsr 42912 <rtems_disk_obtain>
if (dd == NULL)
4a34e: 508f addql #8,%sp
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
4a350: 2440 moveal %d0,%a2
if (dd == NULL)
4a352: 4a80 tstl %d0
4a354: 6700 0092 beqw 4a3e8 <rtems_bdbuf_obtain_disk.part.7+0xb8>
return RTEMS_INVALID_ID;
*dd_ptr = dd;
4a358: 206e 0014 moveal %fp@(20),%a0
4a35c: 2080 movel %d0,%a0@
if (media_block_ptr != NULL)
4a35e: 4a8c tstl %a4
4a360: 673e beqs 4a3a0 <rtems_bdbuf_obtain_disk.part.7+0x70>
rtems_bdbuf_media_block (rtems_blkdev_bnum block,
size_t block_size,
size_t media_block_size)
{
return (rtems_blkdev_bnum)
((((uint64_t) block) * block_size) / media_block_size);
4a362: 262a 0020 movel %a2@(32),%d3
4a366: 4282 clrl %d2
4a368: 4284 clrl %d4
4a36a: 2f03 movel %d3,%sp@-
4a36c: 2f02 movel %d2,%sp@-
4a36e: 2f2e 0010 movel %fp@(16),%sp@-
4a372: 42a7 clrl %sp@-
4a374: 4eb9 0005 bb20 jsr 5bb20 <__muldi3>
4a37a: 2a2a 0024 movel %a2@(36),%d5
4a37e: 4fef 0010 lea %sp@(16),%sp
4a382: 2f05 movel %d5,%sp@-
4a384: 2f04 movel %d4,%sp@-
4a386: 2f01 movel %d1,%sp@-
4a388: 2f00 movel %d0,%sp@-
4a38a: 4eb9 0005 c400 jsr 5c400 <__udivdi3>
4a390: 4fef 0010 lea %sp@(16),%sp
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
dd->media_block_size);
if (mb >= dd->size)
4a394: b2aa 001c cmpl %a2@(28),%d1
4a398: 643c bccs 4a3d6 <rtems_bdbuf_obtain_disk.part.7+0xa6><== NEVER TAKEN
{
rtems_disk_release(dd);
return RTEMS_INVALID_NUMBER;
}
*media_block_ptr = mb + dd->start;
4a39a: d2aa 0018 addl %a2@(24),%d1
4a39e: 2881 movel %d1,%a4@
}
if (bds_per_group_ptr != NULL)
4a3a0: 4a8b tstl %a3
4a3a2: 6748 beqs 4a3ec <rtems_bdbuf_obtain_disk.part.7+0xbc>
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
4a3a4: 202a 0020 movel %a2@(32),%d0
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
4a3a8: b0b9 0005 d8e0 cmpl 5d8e0 <rtems_bdbuf_configuration+0x24>,%d0
4a3ae: 6226 bhis 4a3d6 <rtems_bdbuf_obtain_disk.part.7+0xa6><== NEVER TAKEN
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
4a3b0: 5380 subql #1,%d0
4a3b2: 41f9 0005 d8dc lea 5d8dc <rtems_bdbuf_configuration+0x20>,%a0
4a3b8: 4c50 0000 remul %a0@,%d0,%d0
4a3bc: 2200 movel %d0,%d1
4a3be: 5281 addql #1,%d1
for (bds_per_size = 1;
4a3c0: 7001 moveq #1,%d0
4a3c2: 6002 bras 4a3c6 <rtems_bdbuf_obtain_disk.part.7+0x96>
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
4a3c4: d080 addl %d0,%d0
if (size > bdbuf_config.buffer_max)
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
for (bds_per_size = 1;
4a3c6: b280 cmpl %d0,%d1
4a3c8: 62fa bhis 4a3c4 <rtems_bdbuf_obtain_disk.part.7+0x94>
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
;
return bdbuf_cache.max_bds_per_group / bds_per_size;
4a3ca: 2439 0006 0396 movel 60396 <bdbuf_cache+0x1e>,%d2
4a3d0: 4c40 2002 remul %d0,%d2,%d2
if (bds_per_group_ptr != NULL)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
if (bds_per_group == 0)
4a3d4: 660e bnes 4a3e4 <rtems_bdbuf_obtain_disk.part.7+0xb4><== ALWAYS TAKEN
{
rtems_disk_release (dd);
4a3d6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4a3d8: 4eb9 0004 297a jsr 4297a <rtems_disk_release> <== NOT EXECUTED
4a3de: 588f addql #4,%sp <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
4a3e0: 700a moveq #10,%d0 <== NOT EXECUTED
4a3e2: 600a bras 4a3ee <rtems_bdbuf_obtain_disk.part.7+0xbe><== NOT EXECUTED
}
*bds_per_group_ptr = bds_per_group;
4a3e4: 2682 movel %d2,%a3@
4a3e6: 6004 bras 4a3ec <rtems_bdbuf_obtain_disk.part.7+0xbc>
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
if (dd == NULL)
return RTEMS_INVALID_ID;
4a3e8: 7004 moveq #4,%d0 <== NOT EXECUTED
4a3ea: 6002 bras 4a3ee <rtems_bdbuf_obtain_disk.part.7+0xbe><== NOT EXECUTED
}
*bds_per_group_ptr = bds_per_group;
}
return RTEMS_SUCCESSFUL;
4a3ec: 4280 clrl %d0
}
4a3ee: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4a3f4: 4e5e unlk %fp <== NOT EXECUTED
0004a780 <rtems_bdbuf_purge>:
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
4a780: 4e56 ff50 linkw %fp,#-176
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4a784: 200e movel %fp,%d0
4a786: 5180 subql #8,%d0
4a788: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4a78c: 280e movel %fp,%d4
4a78e: 0684 ffff fff4 addil #-12,%d4
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
rtems_bdbuf_purge_compare compare,
dev_t dev)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
4a794: 47ee ff74 lea %fp@(-140),%a3
4a798: 2a3c 0004 71c4 movel #291268,%d5
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4a79e: 4bf9 0004 718c lea 4718c <_Chain_Append>,%a5
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
4a7a4: 49fa fab0 lea %pc@(4a256 <rtems_bdbuf_wake>),%a4
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
4a7a8: 2c2e 0008 movel %fp@(8),%d6
4a7ac: 2d40 fff4 movel %d0,%fp@(-12)
4a7b0: 242e 000c movel %fp@(12),%d2
4a7b4: 262e 0010 movel %fp@(16),%d3
head->previous = NULL;
4a7b8: 42ae fff8 clrl %fp@(-8)
tail->previous = head;
4a7bc: 2d44 fffc movel %d4,%fp@(-4)
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
4a7c0: 4eba f626 jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
rtems_bdbuf_purge_compare compare,
dev_t dev)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
4a7c4: 2479 0006 03b4 moveal 603b4 <bdbuf_cache+0x3c>,%a2
*prev = NULL;
4a7ca: 42ae ff74 clrl %fp@(-140)
4a7ce: 6000 00b0 braw 4a880 <rtems_bdbuf_purge+0x100>
while (cur != NULL)
{
if ((*compare) (cur->dev, dev))
4a7d2: 2f03 movel %d3,%sp@-
4a7d4: 2046 moveal %d6,%a0
4a7d6: 2f02 movel %d2,%sp@-
4a7d8: 2f2a 0016 movel %a2@(22),%sp@-
4a7dc: 2f2a 0012 movel %a2@(18),%sp@-
4a7e0: 4e90 jsr %a0@
4a7e2: 4fef 0010 lea %sp@(16),%sp
4a7e6: 4a00 tstb %d0
4a7e8: 676a beqs 4a854 <rtems_bdbuf_purge+0xd4> <== NEVER TAKEN
{
switch (cur->state)
4a7ea: 202a 0022 movel %a2@(34),%d0
4a7ee: 720a moveq #10,%d1
4a7f0: b280 cmpl %d0,%d1
4a7f2: 6554 bcss 4a848 <rtems_bdbuf_purge+0xc8> <== NEVER TAKEN
4a7f4: 303b 0a08 movew %pc@(4a7fe <rtems_bdbuf_purge+0x7e>,%d0:l:2),%d0
4a7f8: 48c0 extl %d0
4a7fa: 4efb 0802 jmp %pc@(4a7fe <rtems_bdbuf_purge+0x7e>,%d0:l)
4a7fe: 0056 .short 0x0056 <== NOT EXECUTED
4a800: 0056 .short 0x0056 <== NOT EXECUTED
4a802: 0028 .short 0x0028 <== NOT EXECUTED
4a804: 0042 .short 0x0042 <== NOT EXECUTED
4a806: 0042 .short 0x0042 <== NOT EXECUTED
4a808: 0042 .short 0x0042 <== NOT EXECUTED
4a80a: 0056 .short 0x0056 <== NOT EXECUTED
4a80c: 0020 .short 0x0020 <== NOT EXECUTED
4a80e: 0016 .short 0x0016 <== NOT EXECUTED
4a810: 003a .short 0x003a <== NOT EXECUTED
4a812: 0056 .short 0x0056 <== NOT EXECUTED
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
4a814: 4879 0006 03e4 pea 603e4 <bdbuf_cache+0x6c>
4a81a: 4e94 jsr %a4@
4a81c: 588f addql #4,%sp
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4a81e: 206a 002a moveal %a2@(42),%a0
4a822: 53a8 000c subql #1,%a0@(12)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4a826: 2f0a movel %a2,%sp@-
4a828: 2045 moveal %d5,%a0
4a82a: 4e90 jsr %a0@
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4a82c: 2f0a movel %a2,%sp@-
4a82e: 2f04 movel %d4,%sp@-
4a830: 4e95 jsr %a5@
4a832: 4fef 000c lea %sp@(12),%sp
4a836: 601c bras 4a854 <rtems_bdbuf_purge+0xd4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a838: 700a moveq #10,%d0
4a83a: 2540 0022 movel %d0,%a2@(34)
4a83e: 6014 bras 4a854 <rtems_bdbuf_purge+0xd4>
4a840: 7206 moveq #6,%d1
4a842: 2541 0022 movel %d1,%a2@(34)
4a846: 600c bras 4a854 <rtems_bdbuf_purge+0xd4>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_set_state (cur, RTEMS_BDBUF_STATE_ACCESS_PURGED);
break;
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
4a848: 2f3c 4200 0001 movel #1107296257,%sp@- <== NOT EXECUTED
4a84e: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
4a854: 206a 0008 moveal %a2@(8),%a0
4a858: 4a88 tstl %a0
4a85a: 6608 bnes 4a864 <rtems_bdbuf_purge+0xe4> <== NEVER TAKEN
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
4a85c: 206a 000c moveal %a2@(12),%a0
4a860: 4a88 tstl %a0
4a862: 670c beqs 4a870 <rtems_bdbuf_purge+0xf0> <== ALWAYS TAKEN
{
/* Right */
++prev;
*prev = cur;
4a864: 274a 0004 movel %a2,%a3@(4) <== NOT EXECUTED
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
4a868: 588b addql #4,%a3 <== NOT EXECUTED
4a86a: 6012 bras 4a87e <rtems_bdbuf_purge+0xfe> <== NOT EXECUTED
{
while (*prev != NULL && cur == (*prev)->avl.right)
{
/* Up */
cur = *prev;
--prev;
4a86c: 598b subql #4,%a3 <== NOT EXECUTED
4a86e: 2448 moveal %a0,%a2 <== NOT EXECUTED
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
4a870: 2053 moveal %a3@,%a0
4a872: 4a88 tstl %a0
4a874: 6708 beqs 4a87e <rtems_bdbuf_purge+0xfe> <== ALWAYS TAKEN
4a876: b5e8 000c cmpal %a0@(12),%a2 <== NOT EXECUTED
4a87a: 67f0 beqs 4a86c <rtems_bdbuf_purge+0xec> <== NOT EXECUTED
4a87c: 6078 bras 4a8f6 <rtems_bdbuf_purge+0x176> <== NOT EXECUTED
}
if (cur->avl.left != NULL)
{
/* Left */
++prev;
4a87e: 2448 moveal %a0,%a2
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
4a880: 4a8a tstl %a2
4a882: 6600 ff4e bnew 4a7d2 <rtems_bdbuf_purge+0x52>
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_gather_for_purge (&purge_list, compare, dev);
rtems_bdbuf_purge_list (&purge_list);
4a886: 260e movel %fp,%d3
4a888: 0683 ffff fff4 addil #-12,%d3
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4a88e: 49f9 0004 71ec lea 471ec <_Chain_Get>,%a4
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
{
rtems_bdbuf_remove_from_tree (bd);
4a894: 47fa fb62 lea %pc@(4a3f8 <rtems_bdbuf_remove_from_tree>),%a3
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4a898: 45f9 0004 db60 lea 4db60 <_Chain_Insert>,%a2
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
4a89e: 4202 clrb %d2
4a8a0: 602a bras 4a8cc <rtems_bdbuf_purge+0x14c>
while ((node = rtems_chain_get (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
4a8a2: 202d 0026 movel %a5@(38),%d0
4a8a6: 6602 bnes 4a8aa <rtems_bdbuf_purge+0x12a>
wake_buffer_waiters = true;
4a8a8: 7401 moveq #1,%d2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a8aa: 7001 moveq #1,%d0
4a8ac: 2b40 0022 movel %d0,%a5@(34)
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4a8b0: 202d 0026 movel %a5@(38),%d0
4a8b4: 6616 bnes 4a8cc <rtems_bdbuf_purge+0x14c>
{
rtems_bdbuf_remove_from_tree (bd);
4a8b6: 2f0d movel %a5,%sp@-
4a8b8: 4e93 jsr %a3@
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4a8ba: 42ad 0022 clrl %a5@(34)
4a8be: 2f0d movel %a5,%sp@-
4a8c0: 4879 0006 03b8 pea 603b8 <bdbuf_cache+0x40>
4a8c6: 4e92 jsr %a2@
4a8c8: 4fef 000c lea %sp@(12),%sp
4a8cc: 2f03 movel %d3,%sp@-
4a8ce: 4e94 jsr %a4@
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
rtems_chain_node *node = NULL;
while ((node = rtems_chain_get (purge_list)) != NULL)
4a8d0: 588f addql #4,%sp
4a8d2: 2a40 moveal %d0,%a5
4a8d4: 4a80 tstl %d0
4a8d6: 66ca bnes 4a8a2 <rtems_bdbuf_purge+0x122>
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
4a8d8: 4a02 tstb %d2
4a8da: 670c beqs 4a8e8 <rtems_bdbuf_purge+0x168>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4a8dc: 4879 0006 03ec pea 603ec <bdbuf_cache+0x74>
4a8e2: 4eba f972 jsr %pc@(4a256 <rtems_bdbuf_wake>)
4a8e6: 588f addql #4,%sp
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_gather_for_purge (&purge_list, compare, dev);
rtems_bdbuf_purge_list (&purge_list);
rtems_bdbuf_unlock_cache ();
4a8e8: 4eba f6b2 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
}
4a8ec: 4cee 3c7c ff50 moveml %fp@(-176),%d2-%d6/%a2-%a5
4a8f2: 4e5e unlk %fp
4a8f4: 4e75 rts
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
4a8f6: 2068 000c moveal %a0@(12),%a0 <== NOT EXECUTED
4a8fa: 6082 bras 4a87e <rtems_bdbuf_purge+0xfe> <== NOT EXECUTED
00049db2 <rtems_bdbuf_purge_compare_dev>:
rtems_bdbuf_unlock_cache ();
}
static bool
rtems_bdbuf_purge_compare_dev (dev_t a, dev_t b)
{
49db2: 4e56 0000 linkw %fp,#0
49db6: 2f02 movel %d2,%sp@-
return a == b;
49db8: 222e 0010 movel %fp@(16),%d1
49dbc: 242e 0014 movel %fp@(20),%d2
49dc0: b2ae 0008 cmpl %fp@(8),%d1
49dc4: 6604 bnes 49dca <rtems_bdbuf_purge_compare_dev+0x18><== NEVER TAKEN
49dc6: b4ae 000c cmpl %fp@(12),%d2
49dca: 57c0 seq %d0
}
49dcc: 241f movel %sp@+,%d2
49dce: 4480 negl %d0
49dd0: 4e5e unlk %fp <== NOT EXECUTED
00049dd4 <rtems_bdbuf_purge_compare_major>:
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_dev, dev);
}
static bool
rtems_bdbuf_purge_compare_major (dev_t a, dev_t b)
{
49dd4: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b);
49dd8: 202e 0010 movel %fp@(16),%d0 <== NOT EXECUTED
49ddc: b0ae 0008 cmpl %fp@(8),%d0 <== NOT EXECUTED
49de0: 57c0 seq %d0 <== NOT EXECUTED
}
49de2: 4e5e unlk %fp <== NOT EXECUTED
49de4: 4480 negl %d0 <== NOT EXECUTED
0004bd5a <rtems_bdbuf_purge_major>:
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
temp.__overlay.minor = _minor;
4bd5a: 4281 clrl %d1 <== NOT EXECUTED
return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b);
}
void
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
4bd5c: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
4bd60: 202e 0008 movel %fp@(8),%d0 <== NOT EXECUTED
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
4bd64: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4bd66: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bd68: 487a e06a pea %pc@(49dd4 <rtems_bdbuf_purge_compare_major>)<== NOT EXECUTED
4bd6c: 4eba ea12 jsr %pc@(4a780 <rtems_bdbuf_purge>) <== NOT EXECUTED
4bd70: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
4bd74: 4e5e unlk %fp <== NOT EXECUTED
0004b858 <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4b858: 4e56 ffc4 linkw %fp,#-60
4b85c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
4b860: 42ae fff4 clrl %fp@(-12)
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
4b864: 42ae fff8 clrl %fp@(-8)
size_t bds_per_group = 0;
4b868: 42ae fffc clrl %fp@(-4)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4b86c: 4a39 0006 03fc tstb 603fc <bdbuf_cache+0x84>
4b872: 6700 01ea beqw 4ba5e <rtems_bdbuf_read+0x206>
4b876: 486e fffc pea %fp@(-4)
4b87a: 486e fff8 pea %fp@(-8)
4b87e: 486e fff4 pea %fp@(-12)
4b882: 2f2e 0010 movel %fp@(16),%sp@-
4b886: 2f2e 000c movel %fp@(12),%sp@-
4b88a: 2f2e 0008 movel %fp@(8),%sp@-
4b88e: 4eba eaa0 jsr %pc@(4a330 <rtems_bdbuf_obtain_disk.part.7>)
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
4b892: 4fef 0018 lea %sp@(24),%sp
4b896: 4a80 tstl %d0
4b898: 6600 01c6 bnew 4ba60 <rtems_bdbuf_read+0x208>
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
4b89c: 2839 0005 d8bc movel 5d8bc <rtems_bdbuf_configuration>,%d4
4b8a2: 5284 addql #1,%d4
4b8a4: 2004 movel %d4,%d0
4b8a6: 72fe moveq #-2,%d1
4b8a8: e988 lsll #4,%d0
4b8aa: 0680 0000 001c addil #28,%d0
4b8b0: 9fc0 subal %d0,%sp
4b8b2: 45ef 0001 lea %sp@(1),%a2
4b8b6: 200a movel %a2,%d0
4b8b8: c081 andl %d1,%d0
4b8ba: 2440 moveal %d0,%a2
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
4b8bc: 4eba e52a jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
4b8c0: 206e fff4 moveal %fp@(-12),%a0
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
4b8c4: 2a28 0020 movel %a0@(32),%d5
4b8c8: 2e05 movel %d5,%d7
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
4b8ca: 2628 001c movel %a0@(28),%d3
4b8ce: d6a8 0018 addl %a0@(24),%d3
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
4b8d2: 4c68 7007 0024 remul %a0@(36),%d7,%d7
dev_t dev = dd->dev;
4b8d8: 2010 movel %a0@,%d0
4b8da: 2228 0004 movel %a0@(4),%d1
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
4b8de: 242e fff8 movel %fp@(-8),%d2
dev_t dev = dd->dev;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
4b8e2: 9682 subl %d2,%d3
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
4b8e4: 2c2e fffc movel %fp@(-4),%d6
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
dev_t dev = dd->dev;
4b8e8: 2d40 ffec movel %d0,%fp@(-20)
4b8ec: 2d41 fff0 movel %d1,%fp@(-16)
4b8f0: b883 cmpl %d3,%d4
4b8f2: 6402 bccs 4b8f6 <rtems_bdbuf_read+0x9e>
4b8f4: 2604 movel %d4,%d3
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
4b8f6: 4292 clrl %a2@
req->req_done = rtems_bdbuf_transfer_done;
4b8f8: 223c 0004 a036 movel #303158,%d1
req->done_arg = req;
4b8fe: 254a 0008 movel %a2,%a2@(8)
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
4b902: 2541 0004 movel %d1,%a2@(4)
req->done_arg = req;
req->io_task = rtems_task_self ();
4b906: 4eb9 0004 d894 jsr 4d894 <rtems_task_self>
4b90c: 2540 0014 movel %d0,%a2@(20)
req->status = RTEMS_RESOURCE_IN_USE;
4b910: 700c moveq #12,%d0
req->bufnum = 0;
4b912: 42aa 0010 clrl %a2@(16)
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
4b916: 2540 000c movel %d0,%a2@(12)
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
4b91a: 2f06 movel %d6,%sp@-
4b91c: 2f02 movel %d2,%sp@-
4b91e: 2f2e fff0 movel %fp@(-16),%sp@-
4b922: 2f2e ffec movel %fp@(-20),%sp@-
4b926: 4eba f8fc jsr %pc@(4b224 <rtems_bdbuf_get_buffer_for_access>)
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
4b92a: 4fef 0010 lea %sp@(16),%sp
4b92e: 7202 moveq #2,%d1
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
4b930: 2640 moveal %d0,%a3
*bd_ptr = bd;
req->bufs [0].user = bd;
4b932: 2540 0024 movel %d0,%a2@(36)
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
4b936: 256b 001e 0020 movel %a3@(30),%a2@(32)
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
4b93c: 202b 0022 movel %a3@(34),%d0
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
4b940: 2542 0018 movel %d2,%a2@(24)
req->bufs [0].length = block_size;
4b944: 2545 001c movel %d5,%a2@(28)
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
4b948: b280 cmpl %d0,%d1
4b94a: 6700 0096 beqw 4b9e2 <rtems_bdbuf_read+0x18a>
4b94e: 123c 0007 moveb #7,%d1
4b952: b280 cmpl %d0,%d1
4b954: 6700 008c beqw 4b9e2 <rtems_bdbuf_read+0x18a>
4b958: 123c 0001 moveb #1,%d1
4b95c: b280 cmpl %d0,%d1
4b95e: 6610 bnes 4b970 <rtems_bdbuf_read+0x118> <== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b960: 7009 moveq #9,%d0
4b962: 284a moveal %a2,%a4
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
dev_t dev = dd->dev;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
4b964: 7801 moveq #1,%d4
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
4b966: 4bfa e892 lea %pc@(4a1fa <rtems_bdbuf_avl_search.isra.1>),%a5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b96a: 2740 0022 movel %d0,%a3@(34)
4b96e: 606a bras 4b9da <rtems_bdbuf_read+0x182>
return;
case RTEMS_BDBUF_STATE_EMPTY:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
4b970: 202b 0022 movel %a3@(34),%d0 <== NOT EXECUTED
4b974: 2f3c 4200 001d movel #1107296285,%sp@- <== NOT EXECUTED
4b97a: 6000 00c2 braw 4ba3e <rtems_bdbuf_read+0x1e6> <== NOT EXECUTED
break;
}
while (transfer_index < transfer_count)
{
media_block += media_block_count;
4b97e: d487 addl %d7,%d2
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
4b980: 2f02 movel %d2,%sp@-
4b982: 2f2e fff0 movel %fp@(-16),%sp@-
4b986: 2f2e ffec movel %fp@(-20),%sp@-
4b98a: 2f39 0006 03b4 movel 603b4 <bdbuf_cache+0x3c>,%sp@-
4b990: 4e95 jsr %a5@
4b992: 4fef 0010 lea %sp@(16),%sp
if (bd == NULL)
4b996: 4a80 tstl %d0
4b998: 6644 bnes 4b9de <rtems_bdbuf_read+0x186> <== NEVER TAKEN
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
4b99a: 2f06 movel %d6,%sp@-
4b99c: 49ec 0010 lea %a4@(16),%a4
4b9a0: 2f02 movel %d2,%sp@-
4b9a2: 2f2e fff0 movel %fp@(-16),%sp@-
4b9a6: 2f2e ffec movel %fp@(-20),%sp@-
4b9aa: 4eba f55c jsr %pc@(4af08 <rtems_bdbuf_get_buffer_from_lru_list>)
if (bd != NULL)
4b9ae: 4fef 0010 lea %sp@(16),%sp
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
if (bd == NULL)
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
4b9b2: 2040 moveal %d0,%a0
if (bd != NULL)
4b9b4: 4a80 tstl %d0
4b9b6: 6726 beqs 4b9de <rtems_bdbuf_read+0x186> <== ALWAYS TAKEN
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4b9b8: 2268 002a moveal %a0@(42),%a1 <== NOT EXECUTED
4b9bc: 52a9 000c addql #1,%a1@(12) <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b9c0: 7209 moveq #9,%d1 <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
4b9c2: 5284 addql #1,%d4 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4b9c4: 2141 0022 movel %d1,%a0@(34) <== NOT EXECUTED
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
4b9c8: 2940 0024 movel %d0,%a4@(36) <== NOT EXECUTED
req->bufs [transfer_index].block = media_block;
4b9cc: 2942 0018 movel %d2,%a4@(24) <== NOT EXECUTED
req->bufs [transfer_index].length = block_size;
4b9d0: 2945 001c movel %d5,%a4@(28) <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
4b9d4: 2968 001e 0020 movel %a0@(30),%a4@(32) <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
4b9da: b684 cmpl %d4,%d3
4b9dc: 62a0 bhis 4b97e <rtems_bdbuf_read+0x126>
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
}
req->bufnum = transfer_index;
4b9de: 2544 0010 movel %d4,%a2@(16)
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
4b9e2: 4aaa 0010 tstl %a2@(16)
4b9e6: 6728 beqs 4ba10 <rtems_bdbuf_read+0x1b8>
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
4b9e8: 4878 0001 pea 1 <ADD>
4b9ec: 2f0a movel %a2,%sp@-
4b9ee: 2f2e fff4 movel %fp@(-12),%sp@-
4b9f2: 4eba ef08 jsr %pc@(4a8fc <rtems_bdbuf_execute_transfer_request>)
if (sc == RTEMS_SUCCESSFUL)
4b9f6: 4fef 000c lea %sp@(12),%sp
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
4b9fa: 2400 movel %d0,%d2
if (sc == RTEMS_SUCCESSFUL)
4b9fc: 666c bnes 4ba6a <rtems_bdbuf_read+0x212>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4b9fe: 2f0b movel %a3,%sp@-
4ba00: 4eb9 0004 71c4 jsr 471c4 <_Chain_Extract>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4ba06: 206b 002a moveal %a3@(42),%a0
4ba0a: 588f addql #4,%sp
4ba0c: 52a8 000c addql #1,%a0@(12)
}
}
if (sc == RTEMS_SUCCESSFUL)
{
switch (bd->state)
4ba10: 202b 0022 movel %a3@(34),%d0
4ba14: 7202 moveq #2,%d1
4ba16: b280 cmpl %d0,%d1
4ba18: 670a beqs 4ba24 <rtems_bdbuf_read+0x1cc>
4ba1a: 123c 0007 moveb #7,%d1
4ba1e: b280 cmpl %d0,%d1
4ba20: 6612 bnes 4ba34 <rtems_bdbuf_read+0x1dc> <== NEVER TAKEN
4ba22: 6008 bras 4ba2c <rtems_bdbuf_read+0x1d4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4ba24: 7003 moveq #3,%d0
4ba26: 2740 0022 movel %d0,%a3@(34)
4ba2a: 6018 bras 4ba44 <rtems_bdbuf_read+0x1ec>
4ba2c: 7204 moveq #4,%d1
4ba2e: 2741 0022 movel %d1,%a3@(34)
4ba32: 6010 bras 4ba44 <rtems_bdbuf_read+0x1ec>
break;
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_4);
4ba34: 202b 0022 movel %a3@(34),%d0 <== NOT EXECUTED
4ba38: 2f3c 4200 0002 movel #1107296258,%sp@- <== NOT EXECUTED
4ba3e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ba40: 4eba e3fe jsr %pc@(49e40 <rtems_bdbuf_fatal>) <== NOT EXECUTED
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
4ba44: 206e 0014 moveal %fp@(20),%a0
4ba48: 4282 clrl %d2
4ba4a: 208b movel %a3,%a0@
}
else
*bd_ptr = NULL;
rtems_bdbuf_unlock_cache ();
4ba4c: 4eba e54e jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
rtems_bdbuf_release_disk (dd);
4ba50: 2f2e fff4 movel %fp@(-12),%sp@-
4ba54: 4eba e592 jsr %pc@(49fe8 <rtems_bdbuf_release_disk>)
return sc;
4ba58: 588f addql #4,%sp
4ba5a: 2002 movel %d2,%d0
4ba5c: 6002 bras 4ba60 <rtems_bdbuf_read+0x208>
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4ba5e: 7016 moveq #22,%d0 <== NOT EXECUTED
rtems_bdbuf_unlock_cache ();
rtems_bdbuf_release_disk (dd);
return sc;
}
4ba60: 4cee 3cfc ffc4 moveml %fp@(-60),%d2-%d7/%a2-%a5
4ba66: 4e5e unlk %fp
4ba68: 4e75 rts
}
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
4ba6a: 206e 0014 moveal %fp@(20),%a0
4ba6e: 4290 clrl %a0@
4ba70: 60da bras 4ba4c <rtems_bdbuf_read+0x1f4>
0004ba72 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
4ba72: 4e56 0000 linkw %fp,#0
4ba76: 2f0a movel %a2,%sp@-
4ba78: 246e 0008 moveal %fp@(8),%a2
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
4ba7c: 4a39 0006 03fc tstb 603fc <bdbuf_cache+0x84>
4ba82: 6726 beqs 4baaa <rtems_bdbuf_release+0x38> <== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
4ba84: 4a8a tstl %a2
4ba86: 6726 beqs 4baae <rtems_bdbuf_release+0x3c> <== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
4ba88: 4eba e35e jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4ba8c: 202a 0022 movel %a2@(34),%d0
4ba90: 7204 moveq #4,%d1
4ba92: b280 cmpl %d0,%d1
4ba94: 6766 beqs 4bafc <rtems_bdbuf_release+0x8a>
4ba96: 650a bcss 4baa2 <rtems_bdbuf_release+0x30>
4ba98: 123c 0003 moveb #3,%d1
4ba9c: b280 cmpl %d0,%d1
4ba9e: 6664 bnes 4bb04 <rtems_bdbuf_release+0x92> <== NEVER TAKEN
4baa0: 6010 bras 4bab2 <rtems_bdbuf_release+0x40>
4baa2: 7206 moveq #6,%d1
4baa4: b280 cmpl %d0,%d1
4baa6: 655c bcss 4bb04 <rtems_bdbuf_release+0x92> <== NEVER TAKEN
4baa8: 6042 bras 4baec <rtems_bdbuf_release+0x7a>
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4baaa: 7016 moveq #22,%d0 <== NOT EXECUTED
4baac: 6066 bras 4bb14 <rtems_bdbuf_release+0xa2> <== NOT EXECUTED
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
4baae: 7009 moveq #9,%d0 <== NOT EXECUTED
4bab0: 6062 bras 4bb14 <rtems_bdbuf_release+0xa2> <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4bab2: 206a 002a moveal %a2@(42),%a0
4bab6: 53a8 000c subql #1,%a0@(12)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4baba: 7002 moveq #2,%d0
4babc: 2540 0022 movel %d0,%a2@(34)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4bac0: 2f0a movel %a2,%sp@-
4bac2: 4879 0006 03b8 pea 603b8 <bdbuf_cache+0x40>
4bac8: 4eb9 0004 718c jsr 4718c <_Chain_Append>
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
4bace: 202a 0026 movel %a2@(38),%d0
4bad2: 508f addql #8,%sp
4bad4: 41fa e780 lea %pc@(4a256 <rtems_bdbuf_wake>),%a0
4bad8: 6708 beqs 4bae2 <rtems_bdbuf_release+0x70>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4bada: 4879 0006 03dc pea 603dc <bdbuf_cache+0x64>
4bae0: 6006 bras 4bae8 <rtems_bdbuf_release+0x76>
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4bae2: 4879 0006 03ec pea 603ec <bdbuf_cache+0x74>
4bae8: 4e90 jsr %a0@
4baea: 6006 bras 4baf2 <rtems_bdbuf_release+0x80>
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4baec: 2f0a movel %a2,%sp@-
4baee: 4eba ec34 jsr %pc@(4a724 <rtems_bdbuf_discard_buffer_after_access>)
break;
4baf2: 588f addql #4,%sp
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4baf4: 4eba e4a6 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
return RTEMS_SUCCESSFUL;
4baf8: 4280 clrl %d0
4bafa: 6018 bras 4bb14 <rtems_bdbuf_release+0xa2>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
4bafc: 2f0a movel %a2,%sp@-
4bafe: 4eba e782 jsr %pc@(4a282 <rtems_bdbuf_add_to_modified_list_after_access>)
4bb02: 60ee bras 4baf2 <rtems_bdbuf_release+0x80>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
4bb04: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4bb08: 2f3c 4200 001c movel #1107296284,%sp@- <== NOT EXECUTED
4bb0e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bb10: 4eba e32e jsr %pc@(49e40 <rtems_bdbuf_fatal>) <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
4bb14: 246e fffc moveal %fp@(-4),%a2
4bb18: 4e5e unlk %fp <== NOT EXECUTED
00049fe8 <rtems_bdbuf_release_disk>:
return RTEMS_SUCCESSFUL;
}
static void
rtems_bdbuf_release_disk (rtems_disk_device *dd)
{
49fe8: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_disk_release (dd);
49fec: 2f2e 0008 movel %fp@(8),%sp@-
49ff0: 4eb9 0004 297a jsr 4297a <rtems_disk_release>
if (sc != RTEMS_SUCCESSFUL)
49ff6: 588f addql #4,%sp
49ff8: 4a80 tstl %d0
49ffa: 670c beqs 4a008 <rtems_bdbuf_release_disk+0x20> <== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_DISK_REL);
49ffc: 2f3c 4200 001f movel #1107296287,%sp@- <== NOT EXECUTED
4a002: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
4a008: 4e5e unlk %fp <== NOT EXECUTED
0004bb1c <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
4bb1c: 4e56 0000 linkw %fp,#0
4bb20: 2f0a movel %a2,%sp@-
4bb22: 246e 0008 moveal %fp@(8),%a2
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
4bb26: 4a39 0006 03fc tstb 603fc <bdbuf_cache+0x84>
4bb2c: 6724 beqs 4bb52 <rtems_bdbuf_release_modified+0x36><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
4bb2e: 4a8a tstl %a2
4bb30: 6724 beqs 4bb56 <rtems_bdbuf_release_modified+0x3a><== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
4bb32: 4eba e2b4 jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4bb36: 202a 0022 movel %a2@(34),%d0
4bb3a: 7203 moveq #3,%d1
4bb3c: b280 cmpl %d0,%d1
4bb3e: 6232 bhis 4bb72 <rtems_bdbuf_release_modified+0x56><== NEVER TAKEN
4bb40: 123c 0005 moveb #5,%d1
4bb44: b280 cmpl %d0,%d1
4bb46: 6412 bccs 4bb5a <rtems_bdbuf_release_modified+0x3e>
4bb48: 123c 0006 moveb #6,%d1
4bb4c: b280 cmpl %d0,%d1
4bb4e: 6622 bnes 4bb72 <rtems_bdbuf_release_modified+0x56><== NEVER TAKEN
4bb50: 6010 bras 4bb62 <rtems_bdbuf_release_modified+0x46>
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4bb52: 7016 moveq #22,%d0 <== NOT EXECUTED
4bb54: 602c bras 4bb82 <rtems_bdbuf_release_modified+0x66><== NOT EXECUTED
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
4bb56: 7009 moveq #9,%d0 <== NOT EXECUTED
4bb58: 6028 bras 4bb82 <rtems_bdbuf_release_modified+0x66><== NOT EXECUTED
switch (bd->state)
{
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
4bb5a: 2f0a movel %a2,%sp@-
4bb5c: 4eba e724 jsr %pc@(4a282 <rtems_bdbuf_add_to_modified_list_after_access>)
4bb60: 6006 bras 4bb68 <rtems_bdbuf_release_modified+0x4c>
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4bb62: 2f0a movel %a2,%sp@-
4bb64: 4eba ebbe jsr %pc@(4a724 <rtems_bdbuf_discard_buffer_after_access>)
break;
4bb68: 588f addql #4,%sp
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4bb6a: 4eba e430 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
return RTEMS_SUCCESSFUL;
4bb6e: 4280 clrl %d0
4bb70: 6010 bras 4bb82 <rtems_bdbuf_release_modified+0x66>
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
4bb72: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4bb76: 2f3c 4200 0004 movel #1107296260,%sp@- <== NOT EXECUTED
4bb7c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bb7e: 4eba e2c0 jsr %pc@(49e40 <rtems_bdbuf_fatal>) <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
4bb82: 246e fffc moveal %fp@(-4),%a2
4bb86: 4e5e unlk %fp <== NOT EXECUTED
0004a3f8 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
4a3f8: 4e56 ff58 linkw %fp,#-168
4a3fc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4a400: 266e 0008 moveal %fp@(8),%a3
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
4a404: 280e movel %fp,%d4
4a406: 0684 ffff ff80 addil #-128,%d4
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
4a40c: 2a2b 001a movel %a3@(26),%d5
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
4a410: 242b 0012 movel %a3@(18),%d2
4a414: 262b 0016 movel %a3@(22),%d3
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
4a418: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
4a41c: 2479 0006 03b4 moveal 603b4 <bdbuf_cache+0x3c>,%a2
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
4a422: 42a7 clrl %sp@-
4a424: 2f04 movel %d4,%sp@-
4a426: 4eb9 0004 fecc jsr 4fecc <memset>
4a42c: 4fef 000c lea %sp@(12),%sp
rtems_bdbuf_buffer* r;
rtems_bdbuf_buffer* s;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
4a430: 2244 moveal %d4,%a1
4a432: 6040 bras 4a474 <rtems_bdbuf_remove_from_tree+0x7c>
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4a434: 22ca movel %a2,%a1@+
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
4a436: 202a 0012 movel %a2@(18),%d0
4a43a: 222a 0016 movel %a2@(22),%d1
4a43e: 2c00 movel %d0,%d6
4a440: 2e01 movel %d1,%d7
4a442: 9e83 subl %d3,%d7
4a444: 9d82 subxl %d2,%d6
4a446: 6512 bcss 4a45a <rtems_bdbuf_remove_from_tree+0x62><== NEVER TAKEN
4a448: 2c00 movel %d0,%d6
4a44a: 2e01 movel %d1,%d7
4a44c: 9e83 subl %d3,%d7
4a44e: 9d82 subxl %d2,%d6
4a450: 6618 bnes 4a46a <rtems_bdbuf_remove_from_tree+0x72><== NEVER TAKEN
4a452: 202a 001a movel %a2@(26),%d0
4a456: ba80 cmpl %d0,%d5
4a458: 630c blss 4a466 <rtems_bdbuf_remove_from_tree+0x6e>
{
p->avl.cache = 1;
4a45a: 7e01 moveq #1,%d7
4a45c: 1547 0010 moveb %d7,%a2@(16)
p = p->avl.right;
4a460: 246a 000c moveal %a2@(12),%a2
4a464: 600e bras 4a474 <rtems_bdbuf_remove_from_tree+0x7c>
}
else if ((p->dev != dev) || (p->block != block))
4a466: ba80 cmpl %d0,%d5
4a468: 6714 beqs 4a47e <rtems_bdbuf_remove_from_tree+0x86>
{
p->avl.cache = -1;
4a46a: 50c0 st %d0
4a46c: 1540 0010 moveb %d0,%a2@(16)
p = p->avl.left;
4a470: 246a 0008 moveal %a2@(8),%a2
4a474: 2809 movel %a1,%d4
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
4a476: 4a8a tstl %a2
4a478: 66ba bnes 4a434 <rtems_bdbuf_remove_from_tree+0x3c><== ALWAYS TAKEN
4a47a: 6000 024e braw 4a6ca <rtems_bdbuf_remove_from_tree+0x2d2><== NOT EXECUTED
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
4a47e: 200e movel %fp,%d0
4a480: 0680 ffff ff80 addil #-128,%d0
4a486: b084 cmpl %d4,%d0
4a488: 6406 bccs 4a490 <rtems_bdbuf_remove_from_tree+0x98>
{
p = *(buf_prev - 1);
4a48a: 2429 fff8 movel %a1@(-8),%d2
4a48e: 6002 bras 4a492 <rtems_bdbuf_remove_from_tree+0x9a>
}
else
{
p = NULL;
4a490: 4282 clrl %d2
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
4a492: 206a 000c moveal %a2@(12),%a0
4a496: 4a88 tstl %a0
4a498: 6610 bnes 4a4aa <rtems_bdbuf_remove_from_tree+0xb2>
{
r = q->avl.left;
4a49a: 206a 0008 moveal %a2@(8),%a0
if (r != NULL)
4a49e: 4a88 tstl %a0
4a4a0: 676c beqs 4a50e <rtems_bdbuf_remove_from_tree+0x116>
{
r->avl.bal = 0;
4a4a2: 4201 clrb %d1
4a4a4: 1141 0011 moveb %d1,%a0@(17)
4a4a8: 6064 bras 4a50e <rtems_bdbuf_remove_from_tree+0x116>
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
4a4aa: 4aa8 0008 tstl %a0@(8)
4a4ae: 6708 beqs 4a4b8 <rtems_bdbuf_remove_from_tree+0xc0>
4a4b0: 2648 moveal %a0,%a3
4a4b2: 2008 movel %a0,%d0
4a4b4: 2809 movel %a1,%d4
4a4b6: 602a bras 4a4e2 <rtems_bdbuf_remove_from_tree+0xea>
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
4a4b8: 2348 fffc movel %a0,%a1@(-4)
4a4bc: 2809 movel %a1,%d4
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
4a4be: 216a 0008 0008 movel %a2@(8),%a0@(8)
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
4a4c4: 7601 moveq #1,%d3
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
4a4c6: 116a 0011 0011 moveb %a2@(17),%a0@(17)
r->avl.cache = 1;
4a4cc: 1143 0010 moveb %d3,%a0@(16)
4a4d0: 603c bras 4a50e <rtems_bdbuf_remove_from_tree+0x116>
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
4a4d2: 2844 moveal %d4,%a4
4a4d4: 5884 addql #4,%d4
s = r->avl.left;
r->avl.cache = -1;
4a4d6: 50c0 st %d0
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
4a4d8: 28cb movel %a3,%a4@+
s = r->avl.left;
r->avl.cache = -1;
4a4da: 1740 0010 moveb %d0,%a3@(16)
4a4de: 200b movel %a3,%d0
4a4e0: 2641 moveal %d1,%a3
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
4a4e2: 222b 0008 movel %a3@(8),%d1
4a4e6: 66ea bnes 4a4d2 <rtems_bdbuf_remove_from_tree+0xda>
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
4a4e8: 2840 moveal %d0,%a4
4a4ea: 4beb 000c lea %a3@(12),%a5
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
4a4ee: 276a 0008 0008 movel %a2@(8),%a3@(8)
r->avl.left = s->avl.right;
4a4f4: 2955 0008 movel %a5@,%a4@(8)
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
4a4f8: 7001 moveq #1,%d0
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
4a4fa: 176a 0011 0011 moveb %a2@(17),%a3@(17)
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
4a500: 2748 000c movel %a0,%a3@(12)
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
*t = q = s;
4a504: 204b moveal %a3,%a0
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
4a506: 1740 0010 moveb %d0,%a3@(16)
*t = q = s;
4a50a: 234b fffc movel %a3,%a1@(-4)
}
}
if (p != NULL)
4a50e: 4a82 tstl %d2
4a510: 672a beqs 4a53c <rtems_bdbuf_remove_from_tree+0x144>
{
if (p->avl.cache == -1)
4a512: 2242 moveal %d2,%a1
4a514: 72ff moveq #-1,%d1
4a516: 1029 0010 moveb %a1@(16),%d0
4a51a: 49c0 extbl %d0
4a51c: b280 cmpl %d0,%d1
4a51e: 6614 bnes 4a534 <rtems_bdbuf_remove_from_tree+0x13c>
{
p->avl.left = q;
4a520: 2348 0008 movel %a0,%a1@(8)
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
4a524: 200e movel %fp,%d0
4a526: 0680 ffff ff80 addil #-128,%d0
4a52c: b084 cmpl %d4,%d0
4a52e: 6514 bcss 4a544 <rtems_bdbuf_remove_from_tree+0x14c>
4a530: 6000 01a8 braw 4a6da <rtems_bdbuf_remove_from_tree+0x2e2>
{
p->avl.left = q;
}
else
{
p->avl.right = q;
4a534: 2242 moveal %d2,%a1
4a536: 2348 000c movel %a0,%a1@(12)
4a53a: 60e8 bras 4a524 <rtems_bdbuf_remove_from_tree+0x12c>
}
}
else
{
*root = q;
4a53c: 23c8 0006 03b4 movel %a0,603b4 <bdbuf_cache+0x3c>
4a542: 60e0 bras 4a524 <rtems_bdbuf_remove_from_tree+0x12c>
4a544: 2844 moveal %d4,%a4
default:
break;
}
}
if (buf_prev > buf_stack)
4a546: 2400 movel %d0,%d2
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
4a548: 206c fffc moveal %a4@(-4),%a0
else
{
break;
}
if (p->avl.cache == -1)
4a54c: 76ff moveq #-1,%d3
4a54e: 1228 0010 moveb %a0@(16),%d1
4a552: 1028 0011 moveb %a0@(17),%d0
4a556: 49c1 extbl %d1
4a558: b681 cmpl %d1,%d3
4a55a: 6600 009e bnew 4a5fa <rtems_bdbuf_remove_from_tree+0x202>
{
/* rebalance left branch */
switch (p->avl.bal)
4a55e: 4a00 tstb %d0
4a560: 6718 beqs 4a57a <rtems_bdbuf_remove_from_tree+0x182>
4a562: 49c0 extbl %d0
4a564: 7c01 moveq #1,%d6
4a566: bc80 cmpl %d0,%d6
4a568: 6718 beqs 4a582 <rtems_bdbuf_remove_from_tree+0x18a>
4a56a: b680 cmpl %d0,%d3
4a56c: 6600 0124 bnew 4a692 <rtems_bdbuf_remove_from_tree+0x29a>
{
case -1:
p->avl.bal = 0;
4a570: 4207 clrb %d7
4a572: 1147 0011 moveb %d7,%a0@(17)
4a576: 6000 011a braw 4a692 <rtems_bdbuf_remove_from_tree+0x29a>
break;
case 0:
p->avl.bal = 1;
4a57a: 7001 moveq #1,%d0
4a57c: 1140 0011 moveb %d0,%a0@(17)
4a580: 6020 bras 4a5a2 <rtems_bdbuf_remove_from_tree+0x1aa>
modified = false;
break;
case +1:
p1 = p->avl.right;
4a582: 2268 000c moveal %a0@(12),%a1
if (p1->avl.bal >= 0) /* simple RR-turn */
4a586: 1229 0011 moveb %a1@(17),%d1
4a58a: 6d2a blts 4a5b6 <rtems_bdbuf_remove_from_tree+0x1be>
{
p->avl.right = p1->avl.left;
4a58c: 2169 0008 000c movel %a1@(8),%a0@(12)
p1->avl.left = p;
4a592: 2348 0008 movel %a0,%a1@(8)
if (p1->avl.bal == 0)
4a596: 4a01 tstb %d1
4a598: 660e bnes 4a5a8 <rtems_bdbuf_remove_from_tree+0x1b0>
{
p1->avl.bal = -1;
4a59a: 50c1 st %d1
4a59c: 1341 0011 moveb %d1,%a1@(17)
4a5a0: 2049 moveal %a1,%a0
modified = false;
4a5a2: 4200 clrb %d0
4a5a4: 6000 00ee braw 4a694 <rtems_bdbuf_remove_from_tree+0x29c>
}
else
{
p->avl.bal = 0;
4a5a8: 4203 clrb %d3
4a5aa: 1143 0011 moveb %d3,%a0@(17)
p1->avl.bal = 0;
4a5ae: 1343 0011 moveb %d3,%a1@(17)
4a5b2: 6000 0098 braw 4a64c <rtems_bdbuf_remove_from_tree+0x254>
}
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
4a5b6: 2469 0008 moveal %a1@(8),%a2
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4a5ba: 7c01 moveq #1,%d6
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4a5bc: 7eff moveq #-1,%d7
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4a5be: 102a 0011 moveb %a2@(17),%d0
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4a5c2: 236a 000c 0008 movel %a2@(12),%a1@(8)
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4a5c8: 49c0 extbl %d0
4a5ca: bc80 cmpl %d0,%d6
4a5cc: 57c0 seq %d0
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
4a5ce: 2549 000c movel %a1,%a2@(12)
p->avl.right = p2->avl.left;
4a5d2: 216a 0008 000c movel %a2@(8),%a0@(12)
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4a5d8: 1140 0011 moveb %d0,%a0@(17)
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
4a5dc: 2548 0008 movel %a0,%a2@(8)
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4a5e0: 102a 0011 moveb %a2@(17),%d0
4a5e4: 49c0 extbl %d0
4a5e6: be80 cmpl %d0,%d7
4a5e8: 56c0 sne %d0
4a5ea: 5280 addql #1,%d0
4a5ec: 1340 0011 moveb %d0,%a1@(17)
p = p2;
p2->avl.bal = 0;
4a5f0: 4200 clrb %d0
4a5f2: 1540 0011 moveb %d0,%a2@(17)
4a5f6: 6000 0098 braw 4a690 <rtems_bdbuf_remove_from_tree+0x298>
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4a5fa: 4a00 tstb %d0
4a5fc: 671a beqs 4a618 <rtems_bdbuf_remove_from_tree+0x220>
4a5fe: 49c0 extbl %d0
4a600: 7201 moveq #1,%d1
4a602: b280 cmpl %d0,%d1
4a604: 670a beqs 4a610 <rtems_bdbuf_remove_from_tree+0x218>
4a606: 76ff moveq #-1,%d3
4a608: b680 cmpl %d0,%d3
4a60a: 6600 0086 bnew 4a692 <rtems_bdbuf_remove_from_tree+0x29a>
4a60e: 6010 bras 4a620 <rtems_bdbuf_remove_from_tree+0x228>
{
case +1:
p->avl.bal = 0;
4a610: 4206 clrb %d6
4a612: 1146 0011 moveb %d6,%a0@(17)
4a616: 607a bras 4a692 <rtems_bdbuf_remove_from_tree+0x29a>
break;
case 0:
p->avl.bal = -1;
4a618: 50c7 st %d7
4a61a: 1147 0011 moveb %d7,%a0@(17)
4a61e: 6082 bras 4a5a2 <rtems_bdbuf_remove_from_tree+0x1aa>
modified = false;
break;
case -1:
p1 = p->avl.left;
4a620: 2268 0008 moveal %a0@(8),%a1
if (p1->avl.bal <= 0) /* simple LL-turn */
4a624: 1229 0011 moveb %a1@(17),%d1
4a628: 6e26 bgts 4a650 <rtems_bdbuf_remove_from_tree+0x258>
{
p->avl.left = p1->avl.right;
4a62a: 2169 000c 0008 movel %a1@(12),%a0@(8)
p1->avl.right = p;
4a630: 2348 000c movel %a0,%a1@(12)
if (p1->avl.bal == 0)
4a634: 4a01 tstb %d1
4a636: 660a bnes 4a642 <rtems_bdbuf_remove_from_tree+0x24a>
{
p1->avl.bal = 1;
4a638: 7001 moveq #1,%d0
4a63a: 1340 0011 moveb %d0,%a1@(17)
4a63e: 6000 ff60 braw 4a5a0 <rtems_bdbuf_remove_from_tree+0x1a8>
modified = false;
}
else
{
p->avl.bal = 0;
4a642: 4201 clrb %d1
4a644: 1141 0011 moveb %d1,%a0@(17)
p1->avl.bal = 0;
4a648: 1341 0011 moveb %d1,%a1@(17)
4a64c: 2049 moveal %a1,%a0
4a64e: 6042 bras 4a692 <rtems_bdbuf_remove_from_tree+0x29a>
}
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
4a650: 2469 000c moveal %a1@(12),%a2
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4a654: 76ff moveq #-1,%d3
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4a656: 7c01 moveq #1,%d6
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4a658: 102a 0011 moveb %a2@(17),%d0
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4a65c: 236a 0008 000c movel %a2@(8),%a1@(12)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4a662: 49c0 extbl %d0
4a664: b680 cmpl %d0,%d3
4a666: 56c0 sne %d0
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
4a668: 2549 0008 movel %a1,%a2@(8)
p->avl.left = p2->avl.right;
4a66c: 216a 000c 0008 movel %a2@(12),%a0@(8)
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4a672: 5280 addql #1,%d0
4a674: 1140 0011 moveb %d0,%a0@(17)
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
4a678: 2548 000c movel %a0,%a2@(12)
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4a67c: 102a 0011 moveb %a2@(17),%d0
p = p2;
p2->avl.bal = 0;
4a680: 4207 clrb %d7
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4a682: 49c0 extbl %d0
4a684: bc80 cmpl %d0,%d6
4a686: 57c0 seq %d0
4a688: 1340 0011 moveb %d0,%a1@(17)
p = p2;
p2->avl.bal = 0;
4a68c: 1547 0011 moveb %d7,%a2@(17)
4a690: 204a moveal %a2,%a0
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4a692: 7001 moveq #1,%d0
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
4a694: 220c movel %a4,%d1
4a696: 5981 subql #4,%d1
default:
break;
}
}
if (buf_prev > buf_stack)
4a698: b481 cmpl %d1,%d2
4a69a: 641c bccs 4a6b8 <rtems_bdbuf_remove_from_tree+0x2c0>
{
q = *(buf_prev - 1);
4a69c: 226c fff8 moveal %a4@(-8),%a1
if (q->avl.cache == -1)
4a6a0: 76ff moveq #-1,%d3
4a6a2: 1229 0010 moveb %a1@(16),%d1
4a6a6: 49c1 extbl %d1
4a6a8: b681 cmpl %d1,%d3
4a6aa: 6606 bnes 4a6b2 <rtems_bdbuf_remove_from_tree+0x2ba>
{
q->avl.left = p;
4a6ac: 2348 0008 movel %a0,%a1@(8)
4a6b0: 600e bras 4a6c0 <rtems_bdbuf_remove_from_tree+0x2c8>
}
else
{
q->avl.right = p;
4a6b2: 2348 000c movel %a0,%a1@(12)
4a6b6: 6008 bras 4a6c0 <rtems_bdbuf_remove_from_tree+0x2c8>
}
}
else
{
*root = p;
4a6b8: 23c8 0006 03b4 movel %a0,603b4 <bdbuf_cache+0x3c>
4a6be: 601a bras 4a6da <rtems_bdbuf_remove_from_tree+0x2e2>
4a6c0: 598c subql #4,%a4
*root = q;
}
modified = true;
while (modified)
4a6c2: 4a00 tstb %d0
4a6c4: 6600 fe82 bnew 4a548 <rtems_bdbuf_remove_from_tree+0x150>
4a6c8: 6010 bras 4a6da <rtems_bdbuf_remove_from_tree+0x2e2>
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
4a6ca: 202b 0022 movel %a3@(34),%d0 <== NOT EXECUTED
4a6ce: 2f3c 4200 0009 movel #1107296265,%sp@- <== NOT EXECUTED
4a6d4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4a6d6: 4eba f768 jsr %pc@(49e40 <rtems_bdbuf_fatal>) <== NOT EXECUTED
}
4a6da: 4cee 3cfc ff58 moveml %fp@(-168),%d2-%d7/%a2-%a5
4a6e0: 4e5e unlk %fp <== NOT EXECUTED
0004a6e4 <rtems_bdbuf_remove_from_tree_and_lru_list>:
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
4a6e4: 4e56 0000 linkw %fp,#0
4a6e8: 2f0a movel %a2,%sp@-
4a6ea: 246e 0008 moveal %fp@(8),%a2
switch (bd->state)
4a6ee: 202a 0022 movel %a2@(34),%d0
4a6f2: 6720 beqs 4a714 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
4a6f4: 7202 moveq #2,%d1
4a6f6: b280 cmpl %d0,%d1
4a6f8: 660a bnes 4a704 <rtems_bdbuf_remove_from_tree_and_lru_list+0x20><== NEVER TAKEN
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
4a6fa: 2f0a movel %a2,%sp@-
4a6fc: 4eba fcfa jsr %pc@(4a3f8 <rtems_bdbuf_remove_from_tree>)
break;
4a700: 588f addql #4,%sp
4a702: 6010 bras 4a714 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
4a704: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4a708: 2f3c 4200 0008 movel #1107296264,%sp@- <== NOT EXECUTED
4a70e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4a710: 4eba f72e jsr %pc@(49e40 <rtems_bdbuf_fatal>) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4a714: 2d4a 0008 movel %a2,%fp@(8)
}
rtems_chain_extract (&bd->link);
}
4a718: 246e fffc moveal %fp@(-4),%a2
4a71c: 4e5e unlk %fp
4a71e: 4ef9 0004 71c4 jmp 471c4 <_Chain_Extract>
0004a0ca <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4a0ca: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
4a0ce: 486e 0008 pea %fp@(8)
4a0d2: 2f3c 0000 ffff movel #65535,%sp@-
4a0d8: 2f2e 0008 movel %fp@(8),%sp@-
4a0dc: 4eb9 0004 d768 jsr 4d768 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
4a0e2: 4fef 000c lea %sp@(12),%sp
4a0e6: 4a80 tstl %d0
4a0e8: 670c beqs 4a0f6 <rtems_bdbuf_restore_preemption+0x2c><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
4a0ea: 2f3c 4200 0011 movel #1107296273,%sp@- <== NOT EXECUTED
4a0f0: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
4a0f6: 4e5e unlk %fp <== NOT EXECUTED
00049e58 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
49e58: 4e56 ffcc linkw %fp,#-52
49e5c: 202e 000c movel %fp@(12),%d0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
49e60: 2040 moveal %d0,%a0
49e62: 122e 0017 moveb %fp@(23),%d1
49e66: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
49e6a: 266e 0008 moveal %fp@(8),%a3
49e6e: 286e 0010 moveal %fp@(16),%a4
49e72: 2a2e 001c movel %fp@(28),%d5
49e76: 1d41 fff7 moveb %d1,%fp@(-9)
49e7a: 2458 moveal %a0@+,%a2
49e7c: 1e2e 001b moveb %fp@(27),%d7
if (!rtems_chain_is_empty (chain))
49e80: b1ca cmpal %a2,%a0
49e82: 6700 010e beqw 49f92 <rtems_bdbuf_swapout_modified_processing+0x13a>
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dev == BDBUF_INVALID_DEV))
49e86: 4a01 tstb %d1
49e88: 6718 beqs 49ea2 <rtems_bdbuf_swapout_modified_processing+0x4a>
* @param update_timers If true update the timers.
* @param timer_delta It update_timers is true update the timers by this
* amount.
*/
static void
rtems_bdbuf_swapout_modified_processing (dev_t* dev,
49e8a: 2213 movel %a3@,%d1
49e8c: 74ff moveq #-1,%d2
49e8e: c2ab 0004 andl %a3@(4),%d1
49e92: b481 cmpl %d1,%d2
49e94: 57c3 seq %d3
49e96: 2803 movel %d3,%d4
49e98: 4484 negl %d4
49e9a: 1d44 fffb moveb %d4,%fp@(-5)
49e9e: 6000 00ca braw 49f6a <rtems_bdbuf_swapout_modified_processing+0x112>
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dev == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
49ea2: 4201 clrb %d1
49ea4: 1d41 fffb moveb %d1,%fp@(-5)
49ea8: 6000 00c0 braw 49f6a <rtems_bdbuf_swapout_modified_processing+0x112>
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
49eac: 4a2e fffb tstb %fp@(-5)
49eb0: 6622 bnes 49ed4 <rtems_bdbuf_swapout_modified_processing+0x7c>
49eb2: 4a2e fff7 tstb %fp@(-9)
49eb6: 6714 beqs 49ecc <rtems_bdbuf_swapout_modified_processing+0x74>
49eb8: 2413 movel %a3@,%d2
49eba: 262b 0004 movel %a3@(4),%d3
49ebe: 202a 0012 movel %a2@(18),%d0
49ec2: 222a 0016 movel %a2@(22),%d1
49ec6: 9681 subl %d1,%d3
49ec8: 9580 subxl %d0,%d2
49eca: 6708 beqs 49ed4 <rtems_bdbuf_swapout_modified_processing+0x7c>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
49ecc: 2039 0006 03ec movel 603ec <bdbuf_cache+0x74>,%d0
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dev == bd->dev))
|| rtems_bdbuf_has_buffer_waiters ())
49ed2: 6704 beqs 49ed8 <rtems_bdbuf_swapout_modified_processing+0x80>
bd->hold_timer = 0;
49ed4: 42aa 002e clrl %a2@(46)
if (bd->hold_timer)
49ed8: 202a 002e movel %a2@(46),%d0
49edc: 6726 beqs 49f04 <rtems_bdbuf_swapout_modified_processing+0xac>
{
if (update_timers)
49ede: 4a07 tstb %d7
49ee0: 6718 beqs 49efa <rtems_bdbuf_swapout_modified_processing+0xa2>
{
if (bd->hold_timer > timer_delta)
49ee2: 202a 002e movel %a2@(46),%d0
49ee6: ba80 cmpl %d0,%d5
49ee8: 640c bccs 49ef6 <rtems_bdbuf_swapout_modified_processing+0x9e>
bd->hold_timer -= timer_delta;
49eea: 202a 002e movel %a2@(46),%d0
49eee: 9085 subl %d5,%d0
49ef0: 2540 002e movel %d0,%a2@(46)
49ef4: 6004 bras 49efa <rtems_bdbuf_swapout_modified_processing+0xa2>
else
bd->hold_timer = 0;
49ef6: 42aa 002e clrl %a2@(46)
}
if (bd->hold_timer)
49efa: 202a 002e movel %a2@(46),%d0
49efe: 6704 beqs 49f04 <rtems_bdbuf_swapout_modified_processing+0xac>
{
node = node->next;
49f00: 2452 moveal %a2@,%a2
continue;
49f02: 6078 bras 49f7c <rtems_bdbuf_swapout_modified_processing+0x124>
/*
* This assumes we can set dev_t to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dev == BDBUF_INVALID_DEV)
49f04: 2213 movel %a3@,%d1
49f06: 242b 0004 movel %a3@(4),%d2
49f0a: 76ff moveq #-1,%d3
49f0c: 78ff moveq #-1,%d4
49f0e: 9484 subl %d4,%d2
49f10: 9383 subxl %d3,%d1
49f12: 660e bnes 49f22 <rtems_bdbuf_swapout_modified_processing+0xca>
*dev = bd->dev;
49f14: 202a 0012 movel %a2@(18),%d0
49f18: 222a 0016 movel %a2@(22),%d1
49f1c: 2680 movel %d0,%a3@
49f1e: 2741 0004 movel %d1,%a3@(4)
49f22: 2412 movel %a2@,%d2
if (bd->dev == *dev)
49f24: 262a 0012 movel %a2@(18),%d3
49f28: 282a 0016 movel %a2@(22),%d4
49f2c: 2013 movel %a3@,%d0
49f2e: 222b 0004 movel %a3@(4),%d1
49f32: 9881 subl %d1,%d4
49f34: 9780 subxl %d0,%d3
49f36: 6656 bnes 49f8e <rtems_bdbuf_swapout_modified_processing+0x136><== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
49f38: 7209 moveq #9,%d1
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
49f3a: 2046 moveal %d6,%a0
49f3c: 2541 0022 movel %d1,%a2@(34)
49f40: 2f0a movel %a2,%sp@-
49f42: 4e90 jsr %a0@
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract (node);
tnode = tnode->previous;
49f44: 206c 0008 moveal %a4@(8),%a0
while (node && !rtems_chain_is_head (transfer, tnode))
49f48: 588f addql #4,%sp
49f4a: 6014 bras 49f60 <rtems_bdbuf_swapout_modified_processing+0x108>
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
49f4c: 2028 001a movel %a0@(26),%d0
49f50: b0aa 001a cmpl %a2@(26),%d0
49f54: 6406 bccs 49f5c <rtems_bdbuf_swapout_modified_processing+0x104>
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
49f56: 2f0a movel %a2,%sp@-
49f58: 2f08 movel %a0,%sp@-
49f5a: 602e bras 49f8a <rtems_bdbuf_swapout_modified_processing+0x132>
{
rtems_chain_insert (tnode, node);
node = NULL;
}
else
tnode = tnode->previous;
49f5c: 2068 0004 moveal %a0@(4),%a0
rtems_chain_extract (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
49f60: 4a8a tstl %a2
49f62: 672a beqs 49f8e <rtems_bdbuf_swapout_modified_processing+0x136><== NEVER TAKEN
49f64: b9c8 cmpal %a0,%a4
49f66: 66e4 bnes 49f4c <rtems_bdbuf_swapout_modified_processing+0xf4>
49f68: 601c bras 49f86 <rtems_bdbuf_swapout_modified_processing+0x12e>
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
49f6a: 5880 addql #4,%d0
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
49f6c: 2c3c 0004 71c4 movel #291268,%d6
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
49f72: 4bf9 0004 db60 lea 4db60 <_Chain_Insert>,%a5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
49f78: 2d40 fffc movel %d0,%fp@(-4)
if (sync_active && (*dev == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
49f7c: b5ee fffc cmpal %fp@(-4),%a2
49f80: 6600 ff2a bnew 49eac <rtems_bdbuf_swapout_modified_processing+0x54>
49f84: 600c bras 49f92 <rtems_bdbuf_swapout_modified_processing+0x13a>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
49f86: 2f0a movel %a2,%sp@-
49f88: 2f0c movel %a4,%sp@-
49f8a: 4e95 jsr %a5@
49f8c: 508f addql #8,%sp
}
if (node)
rtems_chain_prepend (transfer, node);
node = next_node;
49f8e: 2442 moveal %d2,%a2
49f90: 60ea bras 49f7c <rtems_bdbuf_swapout_modified_processing+0x124>
{
node = node->next;
}
}
}
}
49f92: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5
49f98: 4e5e unlk %fp <== NOT EXECUTED
0004ab58 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
4ab58: 4e56 ffac linkw %fp,#-84
4ab5c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
4ab60: 2639 0005 d8c8 movel 5d8c8 <rtems_bdbuf_configuration+0xc>,%d3
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4ab66: 45fa f63e lea %pc@(4a1a6 <rtems_bdbuf_swapout_writereq_alloc>),%a2
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4ab6a: 243c 0000 03e8 movel #1000,%d2
4ab70: 4c03 2800 mulsl %d3,%d2
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4ab74: 4284 clrl %d4
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4ab76: 2e3c 0004 391c movel #276764,%d7
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4ab7c: 2c3c 0004 718c movel #291212,%d6
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4ab82: 2a4a moveal %a2,%a5
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ab84: 49f9 0004 6880 lea 46880 <rtems_task_create>,%a4
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
sc = rtems_task_start (worker->id,
4ab8a: 47f9 0004 6ab4 lea 46ab4 <rtems_task_start>,%a3
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4ab90: 4e92 jsr %a2@
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4ab92: 41ee ffe2 lea %fp@(-30),%a0
4ab96: 2d40 fff4 movel %d0,%fp@(-12)
rtems_chain_initialize_empty (&transfer.bds);
transfer.dev = BDBUF_INVALID_DEV;
4ab9a: 70ff moveq #-1,%d0
4ab9c: 72ff moveq #-1,%d1
4ab9e: 2d48 ffde movel %a0,%fp@(-34)
head->previous = NULL;
tail->previous = head;
4aba2: 41ee ffde lea %fp@(-34),%a0
4aba6: 2d40 ffea movel %d0,%fp@(-22)
4abaa: 2d41 ffee movel %d1,%fp@(-18)
4abae: 2d48 ffe6 movel %a0,%fp@(-26)
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4abb2: 41f9 0005 f238 lea 5f238 <Configuration+0xc>,%a0
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&transfer.bds);
transfer.dev = BDBUF_INVALID_DEV;
transfer.syncing = false;
4abb8: 4201 clrb %d1
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4abba: 42ae ffe2 clrl %fp@(-30)
4abbe: 1d41 fff2 moveb %d1,%fp@(-14)
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4abc2: 4c50 2002 remul %a0@,%d2,%d2
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
4abc6: 4eba f220 jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
(bdbuf_config.swapout_priority ?
4abca: 2a39 0005 d8c4 movel 5d8c4 <rtems_bdbuf_configuration+0x8>,%d5
4abd0: 6000 00b2 braw 4ac84 <rtems_bdbuf_swapout_task+0x12c>
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4abd4: 4878 002c pea 2c <OPER2+0x18> <== NOT EXECUTED
4abd8: 2047 moveal %d7,%a0 <== NOT EXECUTED
4abda: 4e90 jsr %a0@ <== NOT EXECUTED
if (!worker)
4abdc: 588f addql #4,%sp <== NOT EXECUTED
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4abde: 2440 moveal %d0,%a2 <== NOT EXECUTED
if (!worker)
4abe0: 4a80 tstl %d0 <== NOT EXECUTED
4abe2: 6608 bnes 4abec <rtems_bdbuf_swapout_task+0x94> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
4abe4: 2f3c 4200 0015 movel #1107296277,%sp@- <== NOT EXECUTED
4abea: 6074 bras 4ac60 <rtems_bdbuf_swapout_task+0x108> <== NOT EXECUTED
4abec: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4abee: 4879 0006 037e pea 6037e <bdbuf_cache+0x6> <== NOT EXECUTED
4abf4: 2046 moveal %d6,%a0 <== NOT EXECUTED
4abf6: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
4abf8: 7001 moveq #1,%d0 <== NOT EXECUTED
4abfa: 1540 000c moveb %d0,%a2@(12) <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4abfe: 4e95 jsr %a5@ <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ac00: 508f addql #8,%sp <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4ac02: 41ea 0012 lea %a2@(18),%a0 <== NOT EXECUTED
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4ac06: 2540 0024 movel %d0,%a2@(36) <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
4ac0a: 70ff moveq #-1,%d0 <== NOT EXECUTED
4ac0c: 72ff moveq #-1,%d1 <== NOT EXECUTED
4ac0e: 2548 000e movel %a0,%a2@(14) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4ac12: 41ea 000e lea %a2@(14),%a0 <== NOT EXECUTED
4ac16: 2540 001a movel %d0,%a2@(26) <== NOT EXECUTED
4ac1a: 2541 001e movel %d1,%a2@(30) <== NOT EXECUTED
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ac1e: 220a movel %a2,%d1 <== NOT EXECUTED
4ac20: 5081 addql #8,%d1 <== NOT EXECUTED
(bdbuf_config.swapout_priority ?
4ac22: 2005 movel %d5,%d0 <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4ac24: 42aa 0012 clrl %a2@(18) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4ac28: 2548 0016 movel %a0,%a2@(22) <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ac2c: 4a85 tstl %d5 <== NOT EXECUTED
4ac2e: 6602 bnes 4ac32 <rtems_bdbuf_swapout_task+0xda> <== NOT EXECUTED
4ac30: 700f moveq #15,%d0 <== NOT EXECUTED
4ac32: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4ac34: 42a7 clrl %sp@- <== NOT EXECUTED
4ac36: 4878 0400 pea 400 <D_BIAS+0x2> <== NOT EXECUTED
4ac3a: 4878 2000 pea 2000 <D_MAX_EXP+0x1801> <== NOT EXECUTED
4ac3e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
4ac40: 2004 movel %d4,%d0 <== NOT EXECUTED
4ac42: 0680 0000 0061 addil #97,%d0 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
4ac48: 0080 4244 6f00 oril #1111781120,%d0 <== NOT EXECUTED
4ac4e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ac50: 4e94 jsr %a4@ <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT),
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
4ac52: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4ac56: 4a80 tstl %d0 <== NOT EXECUTED
4ac58: 670c beqs 4ac66 <rtems_bdbuf_swapout_task+0x10e> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
4ac5a: 2f3c 4200 0016 movel #1107296278,%sp@- <== NOT EXECUTED
4ac60: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
sc = rtems_task_start (worker->id,
4ac66: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ac68: 487a 0208 pea %pc@(4ae72 <rtems_bdbuf_swapout_worker_task>)<== NOT EXECUTED
4ac6c: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4ac70: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
4ac72: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4ac76: 4a80 tstl %d0 <== NOT EXECUTED
4ac78: 6708 beqs 4ac82 <rtems_bdbuf_swapout_task+0x12a> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
4ac7a: 2f3c 4200 0017 movel #1107296279,%sp@- <== NOT EXECUTED
4ac80: 60de bras 4ac60 <rtems_bdbuf_swapout_task+0x108> <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4ac82: 5284 addql #1,%d4 <== NOT EXECUTED
4ac84: b8b9 0005 d8d0 cmpl 5d8d0 <rtems_bdbuf_configuration+0x14>,%d4
4ac8a: 6500 ff48 bcsw 4abd4 <rtems_bdbuf_swapout_task+0x7c>
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
4ac8e: 45fa f30c lea %pc@(49f9c <rtems_bdbuf_unlock_cache>),%a2
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
4ac92: 49fa f154 lea %pc@(49de8 <rtems_bdbuf_lock_cache>),%a4
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4ac96: 4bf9 0004 71ec lea 471ec <_Chain_Get>,%a5
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
4ac9c: 47fa f1ba lea %pc@(49e58 <rtems_bdbuf_swapout_modified_processing>),%a3
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
4aca0: 4e92 jsr %a2@
4aca2: 6000 0176 braw 4ae1a <rtems_bdbuf_swapout_task+0x2c2>
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4aca6: 4206 clrb %d6
4aca8: 6002 bras 4acac <rtems_bdbuf_swapout_task+0x154>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4acaa: 7c01 moveq #1,%d6
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
4acac: 4e94 jsr %a4@
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
4acae: 1039 0006 03a6 moveb 603a6 <bdbuf_cache+0x2e>,%d0
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4acb4: 0286 0000 00ff andil #255,%d6
* here. We do not know the worker is the last in a sequence of sync writes
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
4acba: 4a00 tstb %d0
4acbc: 6618 bnes 4acd6 <rtems_bdbuf_swapout_task+0x17e>
4acbe: 4879 0006 037e pea 6037e <bdbuf_cache+0x6>
4acc4: 4e95 jsr %a5@
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
if (worker)
4acc6: 588f addql #4,%sp
4acc8: 4a80 tstl %d0
4acca: 670c beqs 4acd8 <rtems_bdbuf_swapout_task+0x180> <== ALWAYS TAKEN
transfer = &worker->transfer;
4accc: 2e00 movel %d0,%d7 <== NOT EXECUTED
4acce: 0687 0000 000e addil #14,%d7 <== NOT EXECUTED
4acd4: 600a bras 4ace0 <rtems_bdbuf_swapout_task+0x188> <== NOT EXECUTED
* until after we have it running so we do not know to tell it to release the
* lock. The simplest solution is to get the main swap out task perform all
* sync operations.
*/
if (bdbuf_cache.sync_active)
worker = NULL;
4acd6: 4280 clrl %d0
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4acd8: 2e0e movel %fp,%d7
4acda: 0687 ffff ffde addil #-34,%d7
Chain_Node *tail = _Chain_Tail( the_chain );
4ace0: 2207 movel %d7,%d1
4ace2: 2047 moveal %d7,%a0
4ace4: 5881 addql #4,%d1
4ace6: 2081 movel %d1,%a0@
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
4ace8: 1239 0006 03a6 moveb 603a6 <bdbuf_cache+0x2e>,%d1
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
4acee: 78ff moveq #-1,%d4
4acf0: 7aff moveq #-1,%d5
head->next = tail;
head->previous = NULL;
4acf2: 42a8 0004 clrl %a0@(4)
transfer->syncing = bdbuf_cache.sync_active;
4acf6: 1141 0014 moveb %d1,%a0@(20)
/*
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
4acfa: 1239 0006 03a6 moveb 603a6 <bdbuf_cache+0x2e>,%d1
tail->previous = head;
4ad00: 2147 0008 movel %d7,%a0@(8)
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
4ad04: 2144 000c movel %d4,%a0@(12)
4ad08: 2145 0010 movel %d5,%a0@(16)
/*
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
4ad0c: 4a01 tstb %d1
4ad0e: 6714 beqs 4ad24 <rtems_bdbuf_swapout_task+0x1cc>
transfer->dev = bdbuf_cache.sync_device;
4ad10: 2839 0006 03ac movel 603ac <bdbuf_cache+0x34>,%d4
4ad16: 2a39 0006 03b0 movel 603b0 <bdbuf_cache+0x38>,%d5
4ad1c: 2144 000c movel %d4,%a0@(12)
4ad20: 2145 0010 movel %d5,%a0@(16)
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
4ad24: 2f03 movel %d3,%sp@-
4ad26: 2207 movel %d7,%d1
4ad28: 0681 0000 000c addil #12,%d1
4ad2e: 42a7 clrl %sp@-
4ad30: 4878 0001 pea 1 <ADD>
4ad34: 2f07 movel %d7,%sp@-
4ad36: 4879 0006 03d0 pea 603d0 <bdbuf_cache+0x58>
4ad3c: 2d40 ffd8 movel %d0,%fp@(-40)
4ad40: 2f01 movel %d1,%sp@-
4ad42: 2d41 ffd4 movel %d1,%fp@(-44)
4ad46: 4e93 jsr %a3@
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
4ad48: 222e ffd4 movel %fp@(-44),%d1
4ad4c: 2f03 movel %d3,%sp@-
&bdbuf_cache.modified,
&transfer->bds,
bdbuf_cache.sync_active,
4ad4e: 1839 0006 03a6 moveb 603a6 <bdbuf_cache+0x2e>,%d4
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
4ad54: 2f06 movel %d6,%sp@-
4ad56: 4286 clrl %d6
4ad58: 1c04 moveb %d4,%d6
4ad5a: 2f06 movel %d6,%sp@-
4ad5c: 2f07 movel %d7,%sp@-
4ad5e: 4879 0006 03c4 pea 603c4 <bdbuf_cache+0x4c>
4ad64: 2f01 movel %d1,%sp@-
4ad66: 4e93 jsr %a3@
/*
* We have all the buffers that have been modified for this device so the
* cache can be unlocked because the state of each buffer has been set to
* TRANSFER.
*/
rtems_bdbuf_unlock_cache ();
4ad68: 4fef 0030 lea %sp@(48),%sp
4ad6c: 4e92 jsr %a2@
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4ad6e: 202e ffd8 movel %fp@(-40),%d0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4ad72: 2207 movel %d7,%d1
4ad74: 5881 addql #4,%d1
4ad76: 2047 moveal %d7,%a0
4ad78: b290 cmpl %a0@,%d1
4ad7a: 672e beqs 4adaa <rtems_bdbuf_swapout_task+0x252>
{
if (worker)
4ad7c: 4a80 tstl %d0
4ad7e: 6720 beqs 4ada0 <rtems_bdbuf_swapout_task+0x248> <== ALWAYS TAKEN
{
rtems_status_code sc = rtems_event_send (worker->id,
4ad80: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4ad84: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ad86: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
4ad8a: 4eb9 0004 626c jsr 4626c <rtems_event_send> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4ad90: 508f addql #8,%sp <== NOT EXECUTED
4ad92: 4a80 tstl %d0 <== NOT EXECUTED
4ad94: 6718 beqs 4adae <rtems_bdbuf_swapout_task+0x256> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
4ad96: 2f3c 4200 0014 movel #1107296276,%sp@- <== NOT EXECUTED
4ad9c: 6000 fec2 braw 4ac60 <rtems_bdbuf_swapout_task+0x108> <== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
4ada0: 2f07 movel %d7,%sp@-
4ada2: 4eba fc64 jsr %pc@(4aa08 <rtems_bdbuf_swapout_write>)
4ada6: 588f addql #4,%sp
4ada8: 6004 bras 4adae <rtems_bdbuf_swapout_task+0x256>
rtems_bdbuf_swapout_processing (unsigned long timer_delta,
bool update_timers,
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
4adaa: 4200 clrb %d0
4adac: 6002 bras 4adb0 <rtems_bdbuf_swapout_task+0x258>
else
{
rtems_bdbuf_swapout_write (transfer);
}
transfered_buffers = true;
4adae: 7001 moveq #1,%d0
}
if (bdbuf_cache.sync_active && !transfered_buffers)
4adb0: 1239 0006 03a6 moveb 603a6 <bdbuf_cache+0x2e>,%d1
4adb6: 6732 beqs 4adea <rtems_bdbuf_swapout_task+0x292>
4adb8: 4a00 tstb %d0
4adba: 6600 feea bnew 4aca6 <rtems_bdbuf_swapout_task+0x14e>
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
4adbe: 4e94 jsr %a4@
sync_requester = bdbuf_cache.sync_requester;
4adc0: 2a39 0006 03a8 movel 603a8 <bdbuf_cache+0x30>,%d5
bdbuf_cache.sync_active = false;
4adc6: 4200 clrb %d0
4adc8: 13c0 0006 03a6 moveb %d0,603a6 <bdbuf_cache+0x2e>
bdbuf_cache.sync_requester = 0;
4adce: 42b9 0006 03a8 clrl 603a8 <bdbuf_cache+0x30>
rtems_bdbuf_unlock_cache ();
4add4: 4e92 jsr %a2@
if (sync_requester)
4add6: 4a85 tstl %d5
4add8: 6716 beqs 4adf0 <rtems_bdbuf_swapout_task+0x298> <== NEVER TAKEN
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
4adda: 4878 0002 pea 2 <DOUBLE_FLOAT>
4adde: 2f05 movel %d5,%sp@-
4ade0: 4eb9 0004 626c jsr 4626c <rtems_event_send>
4ade6: 508f addql #8,%sp
4ade8: 6006 bras 4adf0 <rtems_bdbuf_swapout_task+0x298>
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4adea: 4a00 tstb %d0
4adec: 6600 feb8 bnew 4aca6 <rtems_bdbuf_swapout_task+0x14e>
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
4adf0: 486e fffc pea %fp@(-4)
4adf4: 2f02 movel %d2,%sp@-
4adf6: 42a7 clrl %sp@-
4adf8: 4878 0004 pea 4 <CONTEXT_ARG>
4adfc: 4eb9 0004 6104 jsr 46104 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
4ae02: 4fef 0010 lea %sp@(16),%sp
4ae06: 4a80 tstl %d0
4ae08: 6710 beqs 4ae1a <rtems_bdbuf_swapout_task+0x2c2>
4ae0a: 7206 moveq #6,%d1
4ae0c: b280 cmpl %d0,%d1
4ae0e: 670a beqs 4ae1a <rtems_bdbuf_swapout_task+0x2c2> <== ALWAYS TAKEN
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
4ae10: 2f3c 4200 0018 movel #1107296280,%sp@- <== NOT EXECUTED
4ae16: 6000 fe48 braw 4ac60 <rtems_bdbuf_swapout_task+0x108> <== NOT EXECUTED
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4ae1a: 1039 0006 037c moveb 6037c <bdbuf_cache+0x4>,%d0
4ae20: 6600 fe88 bnew 4acaa <rtems_bdbuf_swapout_task+0x152>
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
4ae24: 4eba efc2 jsr %pc@(49de8 <rtems_bdbuf_lock_cache>) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4ae28: 2479 0006 037e moveal 6037e <bdbuf_cache+0x6>,%a2 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4ae2e: 47f9 0004 626c lea 4626c <rtems_event_send>,%a3 <== NOT EXECUTED
4ae34: 6014 bras 4ae4a <rtems_bdbuf_swapout_task+0x2f2> <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
4ae36: 4204 clrb %d4 <== NOT EXECUTED
4ae38: 1544 000c moveb %d4,%a2@(12) <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4ae3c: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4ae40: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4ae44: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
}
4ae46: 2452 moveal %a2@,%a2 <== NOT EXECUTED
4ae48: 508f addql #8,%sp <== NOT EXECUTED
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
4ae4a: b5fc 0006 0382 cmpal #394114,%a2 <== NOT EXECUTED
4ae50: 66e4 bnes 4ae36 <rtems_bdbuf_swapout_task+0x2de> <== NOT EXECUTED
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
4ae52: 4eba f148 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>) <== NOT EXECUTED
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
4ae56: 2f2e fff4 movel %fp@(-12),%sp@- <== NOT EXECUTED
4ae5a: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4ae60: 42a7 clrl %sp@- <== NOT EXECUTED
4ae62: 4eb9 0004 69a4 jsr 469a4 <rtems_task_delete> <== NOT EXECUTED
}
4ae68: 4cee 3cfc ffac moveml %fp@(-84),%d2-%d7/%a2-%a5 <== NOT EXECUTED
4ae6e: 4e5e unlk %fp <== NOT EXECUTED
0004ae72 <rtems_bdbuf_swapout_worker_task>:
* @param arg A pointer to the worker thread's private data.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
4ae72: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
4ae76: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@ <== NOT EXECUTED
4ae7a: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
4ae7e: 283c 0004 a058 movel #303192,%d4 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
4ae84: 47ea 000e lea %a2@(14),%a3 <== NOT EXECUTED
4ae88: 263c 0004 aa08 movel #305672,%d3 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4ae8e: 243c 0004 9de8 movel #302568,%d2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4ae94: 4bf9 0004 718c lea 4718c <_Chain_Append>,%a5 <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
4ae9a: 49fa f100 lea %pc@(49f9c <rtems_bdbuf_unlock_cache>),%a4<== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4ae9e: 603e bras 4aede <rtems_bdbuf_swapout_worker_task+0x6c><== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
4aea0: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4aea4: 2044 moveal %d4,%a0 <== NOT EXECUTED
4aea6: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
4aea8: 2043 moveal %d3,%a0 <== NOT EXECUTED
4aeaa: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4aeac: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4aeae: 2042 moveal %d2,%a0 <== NOT EXECUTED
4aeb0: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
4aeb2: 70ff moveq #-1,%d0 <== NOT EXECUTED
4aeb4: 72ff moveq #-1,%d1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4aeb6: 41ea 0012 lea %a2@(18),%a0 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
4aeba: 42aa 0012 clrl %a2@(18) <== NOT EXECUTED
4aebe: 2540 001a movel %d0,%a2@(26) <== NOT EXECUTED
4aec2: 2541 001e movel %d1,%a2@(30) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4aec6: 2548 000e movel %a0,%a2@(14) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4aeca: 254b 0016 movel %a3,%a2@(22) <== NOT EXECUTED
4aece: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4aed0: 4879 0006 037e pea 6037e <bdbuf_cache+0x6> <== NOT EXECUTED
4aed6: 4e95 jsr %a5@ <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
4aed8: 4e94 jsr %a4@ <== NOT EXECUTED
4aeda: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4aede: 102a 000c moveb %a2@(12),%d0 <== NOT EXECUTED
4aee2: 66bc bnes 4aea0 <rtems_bdbuf_swapout_worker_task+0x2e><== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
4aee4: 2f2a 0024 movel %a2@(36),%sp@- <== NOT EXECUTED
4aee8: 47f9 0004 3630 lea 43630 <free>,%a3 <== NOT EXECUTED
4aeee: 4e93 jsr %a3@ <== NOT EXECUTED
free (worker);
4aef0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4aef2: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4aef4: 508f addql #8,%sp <== NOT EXECUTED
4aef6: 42ae 0008 clrl %fp@(8) <== NOT EXECUTED
}
4aefa: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5 <== NOT EXECUTED
4af00: 4e5e unlk %fp <== NOT EXECUTED
}
free (worker->transfer.write_req);
free (worker);
rtems_task_delete (RTEMS_SELF);
4af02: 4ef9 0004 69a4 jmp 469a4 <rtems_task_delete> <== NOT EXECUTED
0004aa08 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
4aa08: 4e56 ffdc linkw %fp,#-36
4aa0c: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
4aa10: 246e 0008 moveal %fp@(8),%a2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4aa14: 260a movel %a2,%d3
4aa16: 5883 addql #4,%d3
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4aa18: b692 cmpl %a2@,%d3
4aa1a: 6700 0132 beqw 4ab4e <rtems_bdbuf_swapout_write+0x146>
/*
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
4aa1e: 2f2a 0010 movel %a2@(16),%sp@-
4aa22: 2f2a 000c movel %a2@(12),%sp@-
4aa26: 4eb9 0004 2912 jsr 42912 <rtems_disk_obtain>
if (dd == NULL)
4aa2c: 508f addql #8,%sp
/*
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
4aa2e: 2640 moveal %d0,%a3
if (dd == NULL)
4aa30: 4a80 tstl %d0
4aa32: 6606 bnes 4aa3a <rtems_bdbuf_swapout_write+0x32>
dd = &null_disk;
4aa34: 47f9 0005 f480 lea 5f480 <null_disk.6942>,%a3
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
4aa3a: 2a2b 0020 movel %a3@(32),%d5
4aa3e: 41f9 0005 d8dc lea 5d8dc <rtems_bdbuf_configuration+0x20>,%a0
{
/*
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
4aa44: 4282 clrl %d2
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4aa46: 283c 0004 71ec movel #291308,%d4
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4aa4c: 4bf9 0004 db60 lea 4db60 <_Chain_Insert>,%a5
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
if (dd == NULL)
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
4aa52: 4c50 5005 remul %a0@,%d5,%d5
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4aa56: 206a 0016 moveal %a2@(22),%a0
4aa5a: 700c moveq #12,%d0
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
4aa5c: 2c3c 0004 a8fc movel #305404,%d6
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4aa62: 2140 000c movel %d0,%a0@(12)
transfer->write_req->bufnum = 0;
4aa66: 42a8 0010 clrl %a0@(16)
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
4aa6a: 6000 0094 braw 4ab00 <rtems_bdbuf_swapout_write+0xf8>
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
4aa6e: 226b 0008 moveal %a3@(8),%a1
4aa72: 7201 moveq #1,%d1
4aa74: c2a9 000c andl %a1@(12),%d1
4aa78: 202a 0016 movel %a2@(22),%d0
4aa7c: 4a81 tstl %d1
4aa7e: 671e beqs 4aa9e <rtems_bdbuf_swapout_write+0x96> <== ALWAYS TAKEN
4aa80: 2240 moveal %d0,%a1 <== NOT EXECUTED
4aa82: 4aa9 0010 tstl %a1@(16) <== NOT EXECUTED
4aa86: 6716 beqs 4aa9e <rtems_bdbuf_swapout_write+0x96> <== NOT EXECUTED
transfer->write_req->bufnum &&
(bd->block != (last_block + bufs_per_bd)))
4aa88: 2202 movel %d2,%d1 <== NOT EXECUTED
4aa8a: d285 addl %d5,%d1 <== NOT EXECUTED
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
transfer->write_req->bufnum &&
4aa8c: b2a8 001a cmpl %a0@(26),%d1 <== NOT EXECUTED
4aa90: 670c beqs 4aa9e <rtems_bdbuf_swapout_write+0x96> <== NOT EXECUTED
4aa92: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4aa94: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4aa96: 4e95 jsr %a5@ <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
{
rtems_chain_prepend (&transfer->bds, &bd->link);
write = true;
4aa98: 508f addql #8,%sp <== NOT EXECUTED
4aa9a: 7001 moveq #1,%d0 <== NOT EXECUTED
4aa9c: 602c bras 4aaca <rtems_bdbuf_swapout_write+0xc2> <== NOT EXECUTED
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4aa9e: 2840 moveal %d0,%a4
4aaa0: 222c 0010 movel %a4@(16),%d1
4aaa4: 2401 movel %d1,%d2
transfer->write_req->bufnum++;
4aaa6: 5281 addql #1,%d1
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4aaa8: e98a lsll #4,%d2
transfer->write_req->bufnum++;
4aaaa: 2941 0010 movel %d1,%a4@(16)
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4aaae: 43f4 2818 lea %a4@(00000018,%d2:l),%a1
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4aab2: 2428 001a movel %a0@(26),%d2
buf->length = dd->block_size;
4aab6: 236b 0020 0004 movel %a3@(32),%a1@(4)
buf->buffer = bd->buffer;
4aabc: 2368 001e 0008 movel %a0@(30),%a1@(8)
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
4aac2: 4200 clrb %d0
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
4aac4: 2348 000c movel %a0,%a1@(12)
buf->block = bd->block;
4aac8: 2282 movel %d2,%a1@
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
4aaca: b692 cmpl %a2@,%d3
4aacc: 6714 beqs 4aae2 <rtems_bdbuf_swapout_write+0xda>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
4aace: 206a 0016 moveal %a2@(22),%a0
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
4aad2: 2239 0005 d8c0 movel 5d8c0 <rtems_bdbuf_configuration+0x4>,%d1
4aad8: b2a8 0010 cmpl %a0@(16),%d1
4aadc: 6304 blss 4aae2 <rtems_bdbuf_swapout_write+0xda>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
4aade: 4a00 tstb %d0
4aae0: 671e beqs 4ab00 <rtems_bdbuf_swapout_write+0xf8> <== ALWAYS TAKEN
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
4aae2: 42a7 clrl %sp@-
4aae4: 2f2a 0016 movel %a2@(22),%sp@-
4aae8: 2046 moveal %d6,%a0
4aaea: 2f0b movel %a3,%sp@-
4aaec: 4e90 jsr %a0@
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4aaee: 206a 0016 moveal %a2@(22),%a0
4aaf2: 700c moveq #12,%d0
transfer->write_req->bufnum = 0;
4aaf4: 4fef 000c lea %sp@(12),%sp
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4aaf8: 2140 000c movel %d0,%a0@(12)
transfer->write_req->bufnum = 0;
4aafc: 42a8 0010 clrl %a0@(16)
4ab00: 2f0a movel %a2,%sp@-
4ab02: 2044 moveal %d4,%a0
4ab04: 4e90 jsr %a0@
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
4ab06: 588f addql #4,%sp
4ab08: 2040 moveal %d0,%a0
4ab0a: 4a80 tstl %d0
4ab0c: 6600 ff60 bnew 4aa6e <rtems_bdbuf_swapout_write+0x66>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
}
}
if (dd != &null_disk)
4ab10: b7fc 0005 f480 cmpal #390272,%a3
4ab16: 6736 beqs 4ab4e <rtems_bdbuf_swapout_write+0x146><== NEVER TAKEN
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
4ab18: 4a2a 0014 tstb %a2@(20)
4ab1c: 671e beqs 4ab3c <rtems_bdbuf_swapout_write+0x134>
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
4ab1e: 206b 0008 moveal %a3@(8),%a0
4ab22: 7002 moveq #2,%d0
4ab24: c0a8 000c andl %a0@(12),%d0
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
4ab28: 6712 beqs 4ab3c <rtems_bdbuf_swapout_write+0x134><== ALWAYS TAKEN
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
4ab2a: 42a7 clrl %sp@- <== NOT EXECUTED
4ab2c: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
4ab30: 2f08 movel %a0,%sp@- <== NOT EXECUTED
4ab32: 206b 0028 moveal %a3@(40),%a0 <== NOT EXECUTED
4ab36: 4e90 jsr %a0@ <== NOT EXECUTED
4ab38: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
/* How should the error be handled ? */
}
rtems_disk_release (dd);
4ab3c: 2d4b 0008 movel %a3,%fp@(8)
}
}
}
4ab40: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
4ab46: 4e5e unlk %fp
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
/* How should the error be handled ? */
}
rtems_disk_release (dd);
4ab48: 4ef9 0004 297a jmp 4297a <rtems_disk_release>
}
}
}
4ab4e: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5 <== NOT EXECUTED
4ab54: 4e5e unlk %fp <== NOT EXECUTED
0004a1a6 <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
4a1a6: 4e56 0000 linkw %fp,#0
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
4a1aa: 2039 0005 d8c0 movel 5d8c0 <rtems_bdbuf_configuration+0x4>,%d0
4a1b0: e988 lsll #4,%d0
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
4a1b2: 2f0a movel %a2,%sp@-
* @note chrisj The rtems_blkdev_request and the array at the end is a hack.
* I am disappointment at finding code like this in RTEMS. The request should
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
4a1b4: 2040 moveal %d0,%a0
4a1b6: 4868 0018 pea %a0@(24)
4a1ba: 4eb9 0004 391c jsr 4391c <malloc>
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
4a1c0: 588f addql #4,%sp
* @note chrisj The rtems_blkdev_request and the array at the end is a hack.
* I am disappointment at finding code like this in RTEMS. The request should
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
4a1c2: 2440 moveal %d0,%a2
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
4a1c4: 4a80 tstl %d0
4a1c6: 660c bnes 4a1d4 <rtems_bdbuf_swapout_writereq_alloc+0x2e><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
4a1c8: 2f3c 4200 0015 movel #1107296277,%sp@- <== NOT EXECUTED
4a1ce: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
4a1d4: 7001 moveq #1,%d0
4a1d6: 2480 movel %d0,%a2@
write_req->req_done = rtems_bdbuf_transfer_done;
4a1d8: 203c 0004 a036 movel #303158,%d0
write_req->done_arg = write_req;
4a1de: 254a 0008 movel %a2,%a2@(8)
if (!write_req)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
write_req->req_done = rtems_bdbuf_transfer_done;
4a1e2: 2540 0004 movel %d0,%a2@(4)
write_req->done_arg = write_req;
write_req->io_task = rtems_task_self ();
4a1e6: 4eb9 0004 d894 jsr 4d894 <rtems_task_self>
4a1ec: 2540 0014 movel %d0,%a2@(20)
return write_req;
}
4a1f0: 200a movel %a2,%d0
4a1f2: 246e fffc moveal %fp@(-4),%a2
4a1f6: 4e5e unlk %fp <== NOT EXECUTED
0004bb8a <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
4bb8a: 4e56 0000 linkw %fp,#0
4bb8e: 2f0b movel %a3,%sp@-
4bb90: 2f0a movel %a2,%sp@-
4bb92: 246e 0008 moveal %fp@(8),%a2
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
4bb96: 4a39 0006 03fc tstb 603fc <bdbuf_cache+0x84>
4bb9c: 672a beqs 4bbc8 <rtems_bdbuf_sync+0x3e> <== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
4bb9e: 4a8a tstl %a2
4bba0: 672c beqs 4bbce <rtems_bdbuf_sync+0x44> <== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
4bba2: 4eba e244 jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
4bba6: 202a 0022 movel %a2@(34),%d0
4bbaa: 7203 moveq #3,%d1
4bbac: b280 cmpl %d0,%d1
4bbae: 6200 00e0 bhiw 4bc90 <rtems_bdbuf_sync+0x106>
4bbb2: 123c 0005 moveb #5,%d1
4bbb6: b280 cmpl %d0,%d1
4bbb8: 641a bccs 4bbd4 <rtems_bdbuf_sync+0x4a>
4bbba: 123c 0006 moveb #6,%d1
4bbbe: b280 cmpl %d0,%d1
4bbc0: 6600 00ce bnew 4bc90 <rtems_bdbuf_sync+0x106>
4bbc4: 6000 00c0 braw 4bc86 <rtems_bdbuf_sync+0xfc>
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4bbc8: 7016 moveq #22,%d0 <== NOT EXECUTED
4bbca: 6000 00da braw 4bca6 <rtems_bdbuf_sync+0x11c> <== NOT EXECUTED
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
4bbce: 7009 moveq #9,%d0 <== NOT EXECUTED
4bbd0: 6000 00d4 braw 4bca6 <rtems_bdbuf_sync+0x11c> <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4bbd4: 7008 moveq #8,%d0
4bbd6: 2540 0022 movel %d0,%a2@(34)
4bbda: 2f0a movel %a2,%sp@-
4bbdc: 4879 0006 03d0 pea 603d0 <bdbuf_cache+0x58>
4bbe2: 4eb9 0004 718c jsr 4718c <_Chain_Append>
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
4bbe8: 202a 0026 movel %a2@(38),%d0
4bbec: 508f addql #8,%sp
4bbee: 670c beqs 4bbfc <rtems_bdbuf_sync+0x72>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4bbf0: 4879 0006 03dc pea 603dc <bdbuf_cache+0x64>
4bbf6: 4eba e65e jsr %pc@(4a256 <rtems_bdbuf_wake>)
4bbfa: 588f addql #4,%sp
rtems_bdbuf_wake_swapper ();
4bbfc: 4eba e40e jsr %pc@(4a00c <rtems_bdbuf_wake_swapper>)
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4bc00: 47fa e564 lea %pc@(4a166 <rtems_bdbuf_wait>),%a3
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4bc04: 202a 0022 movel %a2@(34),%d0
4bc08: 7201 moveq #1,%d1
4bc0a: b280 cmpl %d0,%d1
4bc0c: 621e bhis 4bc2c <rtems_bdbuf_sync+0xa2> <== NEVER TAKEN
4bc0e: 123c 0007 moveb #7,%d1
4bc12: b280 cmpl %d0,%d1
4bc14: 6422 bccs 4bc38 <rtems_bdbuf_sync+0xae>
4bc16: 123c 000a moveb #10,%d1
4bc1a: b280 cmpl %d0,%d1
4bc1c: 650e bcss 4bc2c <rtems_bdbuf_sync+0xa2> <== NEVER TAKEN
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4bc1e: 4879 0006 03e4 pea 603e4 <bdbuf_cache+0x6c>
4bc24: 2f0a movel %a2,%sp@-
4bc26: 4e93 jsr %a3@
4bc28: 508f addql #8,%sp
4bc2a: 60d8 bras 4bc04 <rtems_bdbuf_sync+0x7a>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_9);
4bc2c: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4bc30: 2f3c 4200 0007 movel #1107296263,%sp@- <== NOT EXECUTED
4bc36: 6062 bras 4bc9a <rtems_bdbuf_sync+0x110> <== NOT EXECUTED
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
4bc38: 202a 0026 movel %a2@(38),%d0
4bc3c: 6662 bnes 4bca0 <rtems_bdbuf_sync+0x116>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
4bc3e: 202a 0022 movel %a2@(34),%d0
4bc42: 7202 moveq #2,%d1
4bc44: b280 cmpl %d0,%d1
4bc46: 670c beqs 4bc54 <rtems_bdbuf_sync+0xca>
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
4bc48: 202a 0022 movel %a2@(34),%d0
4bc4c: 123c 0001 moveb #1,%d1
4bc50: b280 cmpl %d0,%d1
4bc52: 664c bnes 4bca0 <rtems_bdbuf_sync+0x116> <== NEVER TAKEN
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
4bc54: 202a 0022 movel %a2@(34),%d0
4bc58: 7201 moveq #1,%d1
4bc5a: b280 cmpl %d0,%d1
4bc5c: 661c bnes 4bc7a <rtems_bdbuf_sync+0xf0>
{
rtems_bdbuf_remove_from_tree (bd);
4bc5e: 2f0a movel %a2,%sp@-
4bc60: 4eba e796 jsr %pc@(4a3f8 <rtems_bdbuf_remove_from_tree>)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4bc64: 42aa 0022 clrl %a2@(34)
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
4bc68: 2f0a movel %a2,%sp@-
4bc6a: 4879 0006 03b8 pea 603b8 <bdbuf_cache+0x40>
4bc70: 4eb9 0004 db60 jsr 4db60 <_Chain_Insert>
4bc76: 4fef 000c lea %sp@(12),%sp
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4bc7a: 4879 0006 03ec pea 603ec <bdbuf_cache+0x74>
4bc80: 4eba e5d4 jsr %pc@(4a256 <rtems_bdbuf_wake>)
4bc84: 6006 bras 4bc8c <rtems_bdbuf_sync+0x102>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_sync_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
4bc86: 2f0a movel %a2,%sp@-
4bc88: 4eba ea9a jsr %pc@(4a724 <rtems_bdbuf_discard_buffer_after_access>)
break;
4bc8c: 588f addql #4,%sp
4bc8e: 6010 bras 4bca0 <rtems_bdbuf_sync+0x116>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
4bc90: 202a 0022 movel %a2@(34),%d0 <== NOT EXECUTED
4bc94: 2f3c 4200 0003 movel #1107296259,%sp@- <== NOT EXECUTED
4bc9a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bc9c: 4eba e1a2 jsr %pc@(49e40 <rtems_bdbuf_fatal>) <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4bca0: 4eba e2fa jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
return RTEMS_SUCCESSFUL;
4bca4: 4280 clrl %d0
}
4bca6: 246e fff8 moveal %fp@(-8),%a2
4bcaa: 266e fffc moveal %fp@(-4),%a3
4bcae: 4e5e unlk %fp <== NOT EXECUTED
0004bcb2 <rtems_bdbuf_syncdev>:
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
4bcb2: 4e56 fff0 linkw %fp,#-16
4bcb6: 48d7 001c moveml %d2-%d4,%sp@
4bcba: 242e 0008 movel %fp@(8),%d2
4bcbe: 262e 000c movel %fp@(12),%d3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
4bcc2: 42ae fffc clrl %fp@(-4)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4bcc6: 4a39 0006 03fc tstb 603fc <bdbuf_cache+0x84>
4bccc: 6762 beqs 4bd30 <rtems_bdbuf_syncdev+0x7e> <== NEVER TAKEN
4bcce: 42a7 clrl %sp@-
4bcd0: 42a7 clrl %sp@-
4bcd2: 486e fffc pea %fp@(-4)
4bcd6: 42a7 clrl %sp@-
4bcd8: 2f03 movel %d3,%sp@-
4bcda: 2f02 movel %d2,%sp@-
4bcdc: 4eba e652 jsr %pc@(4a330 <rtems_bdbuf_obtain_disk.part.7>)
if (rtems_bdbuf_tracer)
printf ("bdbuf:syncdev: %08x\n", (unsigned) dev);
sc = rtems_bdbuf_obtain_disk (dev, 0, &dd, NULL, NULL);
if (sc != RTEMS_SUCCESSFUL)
4bce0: 4fef 0018 lea %sp@(24),%sp
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
4bce4: 2800 movel %d0,%d4
if (rtems_bdbuf_tracer)
printf ("bdbuf:syncdev: %08x\n", (unsigned) dev);
sc = rtems_bdbuf_obtain_disk (dev, 0, &dd, NULL, NULL);
if (sc != RTEMS_SUCCESSFUL)
4bce6: 664a bnes 4bd32 <rtems_bdbuf_syncdev+0x80> <== NEVER TAKEN
* Take the sync lock before locking the cache. Once we have the sync lock we
* can lock the cache. If another thread has the sync lock it will cause this
* thread to block until it owns the sync lock then it can own the cache. The
* sync lock can only be obtained with the cache unlocked.
*/
rtems_bdbuf_lock_sync ();
4bce8: 4eba e12a jsr %pc@(49e14 <rtems_bdbuf_lock_sync>)
rtems_bdbuf_lock_cache ();
4bcec: 4eba e0fa jsr %pc@(49de8 <rtems_bdbuf_lock_cache>)
* out task know the id of the requester to wake when done.
*
* The swap out task will negate the sync active flag when no more buffers
* for the device are held on the "modified for sync" queues.
*/
bdbuf_cache.sync_active = true;
4bcf0: 7001 moveq #1,%d0
4bcf2: 13c0 0006 03a6 moveb %d0,603a6 <bdbuf_cache+0x2e>
bdbuf_cache.sync_requester = rtems_task_self ();
4bcf8: 4eb9 0004 d894 jsr 4d894 <rtems_task_self>
4bcfe: 23c0 0006 03a8 movel %d0,603a8 <bdbuf_cache+0x30>
bdbuf_cache.sync_device = dev;
4bd04: 23c2 0006 03ac movel %d2,603ac <bdbuf_cache+0x34>
4bd0a: 23c3 0006 03b0 movel %d3,603b0 <bdbuf_cache+0x38>
rtems_bdbuf_wake_swapper ();
4bd10: 4eba e2fa jsr %pc@(4a00c <rtems_bdbuf_wake_swapper>)
rtems_bdbuf_unlock_cache ();
4bd14: 4eba e286 jsr %pc@(49f9c <rtems_bdbuf_unlock_cache>)
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
4bd18: 4878 0002 pea 2 <DOUBLE_FLOAT>
4bd1c: 4eba e33a jsr %pc@(4a058 <rtems_bdbuf_wait_for_event>)
rtems_bdbuf_unlock_sync ();
4bd20: 4eba e2a0 jsr %pc@(49fc2 <rtems_bdbuf_unlock_sync>)
rtems_bdbuf_release_disk (dd);
4bd24: 2f2e fffc movel %fp@(-4),%sp@-
4bd28: 4eba e2be jsr %pc@(49fe8 <rtems_bdbuf_release_disk>)
return RTEMS_SUCCESSFUL;
4bd2c: 508f addql #8,%sp
4bd2e: 6002 bras 4bd32 <rtems_bdbuf_syncdev+0x80>
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
4bd30: 7816 moveq #22,%d4 <== NOT EXECUTED
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
rtems_bdbuf_unlock_sync ();
rtems_bdbuf_release_disk (dd);
return RTEMS_SUCCESSFUL;
}
4bd32: 2004 movel %d4,%d0
4bd34: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
4bd3a: 4e5e unlk %fp <== NOT EXECUTED
00049f9c <rtems_bdbuf_unlock_cache>:
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
49f9c: 4e56 0000 linkw %fp,#0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
49fa0: 2f39 0006 039e movel 6039e <bdbuf_cache+0x26>,%sp@-
49fa6: 4eb9 0004 67d4 jsr 467d4 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
49fac: 588f addql #4,%sp
49fae: 4a80 tstl %d0
49fb0: 670c beqs 49fbe <rtems_bdbuf_unlock_cache+0x22> <== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
49fb2: 2f3c 4200 000e movel #1107296270,%sp@- <== NOT EXECUTED
49fb8: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_unlock_cache (void)
{
rtems_bdbuf_unlock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_UNLOCK);
}
49fbe: 4e5e unlk %fp <== NOT EXECUTED
00049fc2 <rtems_bdbuf_unlock_sync>:
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
49fc2: 4e56 0000 linkw %fp,#0
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
49fc6: 2f39 0006 03a2 movel 603a2 <bdbuf_cache+0x2a>,%sp@-
49fcc: 4eb9 0004 67d4 jsr 467d4 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
49fd2: 588f addql #4,%sp
49fd4: 4a80 tstl %d0
49fd6: 670c beqs 49fe4 <rtems_bdbuf_unlock_sync+0x22> <== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
49fd8: 2f3c 4200 000c movel #1107296268,%sp@- <== NOT EXECUTED
49fde: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
static void
rtems_bdbuf_unlock_sync (void)
{
rtems_bdbuf_unlock (bdbuf_cache.sync_lock,
RTEMS_BLKDEV_FATAL_BDBUF_SYNC_UNLOCK);
}
49fe4: 4e5e unlk %fp <== NOT EXECUTED
0004a058 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
4a058: 4e56 fffc linkw %fp,#-4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
4a05c: 204e moveal %fp,%a0
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
4a05e: 2f02 movel %d2,%sp@-
4a060: 242e 0008 movel %fp@(8),%d2
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
4a064: 42a0 clrl %a0@-
sc = rtems_event_receive (event,
4a066: 2f08 movel %a0,%sp@-
4a068: 42a7 clrl %sp@-
4a06a: 42a7 clrl %sp@-
4a06c: 2f02 movel %d2,%sp@-
4a06e: 4eb9 0004 6104 jsr 46104 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
4a074: 4fef 0010 lea %sp@(16),%sp
4a078: 4a80 tstl %d0
4a07a: 6606 bnes 4a082 <rtems_bdbuf_wait_for_event+0x2a><== NEVER TAKEN
4a07c: b4ae fffc cmpl %fp@(-4),%d2
4a080: 670c beqs 4a08e <rtems_bdbuf_wait_for_event+0x36><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
4a082: 2f3c 4200 001a movel #1107296282,%sp@- <== NOT EXECUTED
4a088: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
4a08e: 242e fff8 movel %fp@(-8),%d2
4a092: 4e5e unlk %fp <== NOT EXECUTED
0004a256 <rtems_bdbuf_wake>:
* Wake a blocked resource. The resource has a counter that lets us know if
* there are any waiters.
*/
static void
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)
{
4a256: 4e56 0000 linkw %fp,#0
4a25a: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
4a25e: 2010 movel %a0@,%d0
4a260: 671c beqs 4a27e <rtems_bdbuf_wake+0x28>
{
sc = rtems_semaphore_flush (waiters->sema);
4a262: 2f28 0004 movel %a0@(4),%sp@-
4a266: 4eb9 0004 d6cc jsr 4d6cc <rtems_semaphore_flush>
if (sc != RTEMS_SUCCESSFUL)
4a26c: 588f addql #4,%sp
4a26e: 4a80 tstl %d0
4a270: 670c beqs 4a27e <rtems_bdbuf_wake+0x28> <== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
4a272: 2f3c 4200 0013 movel #1107296275,%sp@- <== NOT EXECUTED
4a278: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
4a27e: 4e5e unlk %fp <== NOT EXECUTED
0004a00c <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
4a00c: 4e56 0000 linkw %fp,#0
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4a010: 4878 0004 pea 4 <CONTEXT_ARG>
4a014: 2f39 0006 0378 movel 60378 <bdbuf_cache>,%sp@-
4a01a: 4eb9 0004 626c jsr 4626c <rtems_event_send>
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4a020: 508f addql #8,%sp
4a022: 4a80 tstl %d0
4a024: 670c beqs 4a032 <rtems_bdbuf_wake_swapper+0x26> <== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
4a026: 2f3c 4200 0014 movel #1107296276,%sp@- <== NOT EXECUTED
4a02c: 4eb9 0004 6d3c jsr 46d3c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
4a032: 4e5e unlk %fp <== NOT EXECUTED
0004bf98 <rtems_blkdev_generic_ioctl>:
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
4bf98: 4e56 0000 linkw %fp,#0
4bf9c: 2f0a movel %a2,%sp@-
4bf9e: 246e 0010 moveal %fp@(16),%a2
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
4bfa2: 2052 moveal %a2@,%a0
int rc;
switch (args->command)
4bfa4: 202a 0004 movel %a2@(4),%d0
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
4bfa8: 2068 0034 moveal %a0@(52),%a0
int rc;
switch (args->command)
4bfac: 0c80 4004 4203 cmpil #1074020867,%d0
4bfb2: 6738 beqs 4bfec <rtems_blkdev_generic_ioctl+0x54><== NEVER TAKEN
4bfb4: 6212 bhis 4bfc8 <rtems_blkdev_generic_ioctl+0x30><== ALWAYS TAKEN
4bfb6: 0c80 2000 4206 cmpil #536887814,%d0 <== NOT EXECUTED
4bfbc: 6750 beqs 4c00e <rtems_blkdev_generic_ioctl+0x76><== NOT EXECUTED
4bfbe: 0c80 4004 4202 cmpil #1074020866,%d0 <== NOT EXECUTED
4bfc4: 6666 bnes 4c02c <rtems_blkdev_generic_ioctl+0x94><== NOT EXECUTED
4bfc6: 601a bras 4bfe2 <rtems_blkdev_generic_ioctl+0x4a><== NOT EXECUTED
4bfc8: 0c80 8004 4204 cmpil #-2147204604,%d0
4bfce: 672a beqs 4bffa <rtems_blkdev_generic_ioctl+0x62><== ALWAYS TAKEN
4bfd0: 0c80 c018 4201 cmpil #-1072152063,%d0 <== NOT EXECUTED
4bfd6: 674c beqs 4c024 <rtems_blkdev_generic_ioctl+0x8c><== NOT EXECUTED
4bfd8: 0c80 4004 4205 cmpil #1074020869,%d0 <== NOT EXECUTED
4bfde: 664c bnes 4c02c <rtems_blkdev_generic_ioctl+0x94><== NOT EXECUTED
4bfe0: 6022 bras 4c004 <rtems_blkdev_generic_ioctl+0x6c><== NOT EXECUTED
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*((uint32_t *) args->buffer) = dd->media_block_size;
4bfe2: 226a 0008 moveal %a2@(8),%a1 <== NOT EXECUTED
4bfe6: 22a8 0024 movel %a0@(36),%a1@ <== NOT EXECUTED
4bfea: 6008 bras 4bff4 <rtems_blkdev_generic_ioctl+0x5c><== NOT EXECUTED
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*((uint32_t *) args->buffer) = dd->block_size;
4bfec: 226a 0008 moveal %a2@(8),%a1 <== NOT EXECUTED
4bff0: 22a8 0020 movel %a0@(32),%a1@ <== NOT EXECUTED
args->ioctl_return = 0;
4bff4: 42aa 000c clrl %a2@(12)
break;
4bff8: 604a bras 4c044 <rtems_blkdev_generic_ioctl+0xac>
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *((uint32_t *) args->buffer);
4bffa: 226a 0008 moveal %a2@(8),%a1
4bffe: 2151 0020 movel %a1@,%a0@(32)
4c002: 60f0 bras 4bff4 <rtems_blkdev_generic_ioctl+0x5c>
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETSIZE:
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
4c004: 226a 0008 moveal %a2@(8),%a1 <== NOT EXECUTED
4c008: 22a8 001c movel %a0@(28),%a1@ <== NOT EXECUTED
4c00c: 60e6 bras 4bff4 <rtems_blkdev_generic_ioctl+0x5c><== NOT EXECUTED
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SYNCDEV:
rc = rtems_bdbuf_syncdev(dd->dev);
4c00e: 2f28 0004 movel %a0@(4),%sp@- <== NOT EXECUTED
4c012: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4c014: 4eb9 0004 bcb2 jsr 4bcb2 <rtems_bdbuf_syncdev> <== NOT EXECUTED
args->ioctl_return = (uint32_t) (rc == RTEMS_SUCCESSFUL ? 0 : -1);
4c01a: 508f addql #8,%sp <== NOT EXECUTED
4c01c: 4a80 tstl %d0 <== NOT EXECUTED
4c01e: 56c0 sne %d0 <== NOT EXECUTED
4c020: 49c0 extbl %d0 <== NOT EXECUTED
4c022: 6002 bras 4c026 <rtems_blkdev_generic_ioctl+0x8e><== NOT EXECUTED
case RTEMS_BLKIO_REQUEST:
/*
* It is not allowed to directly access the driver circumventing
* the cache.
*/
args->ioctl_return = (uint32_t) -1;
4c024: 70ff moveq #-1,%d0 <== NOT EXECUTED
4c026: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
break;
4c02a: 6018 bras 4c044 <rtems_blkdev_generic_ioctl+0xac><== NOT EXECUTED
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
4c02c: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4c030: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c032: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
4c036: 2068 0028 moveal %a0@(40),%a0 <== NOT EXECUTED
4c03a: 4e90 jsr %a0@ <== NOT EXECUTED
args->command,
args->buffer);
break;
4c03c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
*/
args->ioctl_return = (uint32_t) -1;
break;
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
4c040: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
4c044: 246e fffc moveal %fp@(-4),%a2
4c048: 4280 clrl %d0
4c04a: 4e5e unlk %fp <== NOT EXECUTED
0004bf4a <rtems_blkdev_generic_open>:
rtems_device_driver
rtems_blkdev_generic_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg)
{
4bf4a: 4e56 0000 linkw %fp,#0
rtems_libio_open_close_args_t *oc = arg;
rtems_libio_t *iop = oc->iop;
4bf4e: 206e 0010 moveal %fp@(16),%a0
rtems_device_driver
rtems_blkdev_generic_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg)
{
4bf52: 2f0a movel %a2,%sp@-
rtems_libio_open_close_args_t *oc = arg;
rtems_libio_t *iop = oc->iop;
4bf54: 2450 moveal %a0@,%a2
temp.__overlay.minor = _minor;
4bf56: 222e 000c movel %fp@(12),%d1
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
4bf5a: 202e 0008 movel %fp@(8),%d0
dev_t dev = rtems_filesystem_make_dev_t(major, minor);
rtems_disk_device *dd = rtems_disk_obtain(dev);
4bf5e: 2f01 movel %d1,%sp@-
4bf60: 2f00 movel %d0,%sp@-
4bf62: 4eb9 0004 2912 jsr 42912 <rtems_disk_obtain>
iop->data1 = dd;
if (dd != NULL)
4bf68: 508f addql #8,%sp
rtems_libio_open_close_args_t *oc = arg;
rtems_libio_t *iop = oc->iop;
dev_t dev = rtems_filesystem_make_dev_t(major, minor);
rtems_disk_device *dd = rtems_disk_obtain(dev);
iop->data1 = dd;
4bf6a: 2540 0034 movel %d0,%a2@(52)
if (dd != NULL)
4bf6e: 6704 beqs 4bf74 <rtems_blkdev_generic_open+0x2a> <== NEVER TAKEN
return RTEMS_SUCCESSFUL;
4bf70: 4280 clrl %d0
4bf72: 6002 bras 4bf76 <rtems_blkdev_generic_open+0x2c>
else
return RTEMS_UNSATISFIED;
4bf74: 700d moveq #13,%d0 <== NOT EXECUTED
}
4bf76: 246e fffc moveal %fp@(-4),%a2
4bf7a: 4e5e unlk %fp <== NOT EXECUTED
0004bd78 <rtems_blkdev_generic_read>:
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
4bd78: 4e56 ffc8 linkw %fp,#-56
4bd7c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4bd80: 246e 0010 moveal %fp@(16),%a2
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4bd84: 4286 clrl %d6
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
4bd86: 2052 moveal %a2@,%a0
4bd88: 2668 0034 moveal %a0@(52),%a3
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
4bd8c: 262a 000c movel %a2@(12),%d3
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
4bd90: 282b 0020 movel %a3@(32),%d4
char *buf = args->buffer;
uint32_t count = args->count;
4bd94: 242a 0010 movel %a2@(16),%d2
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4bd98: 286a 0004 moveal %a2@(4),%a4
4bd9c: 2a6a 0008 moveal %a2@(8),%a5
4bda0: 2f04 movel %d4,%sp@-
4bda2: 2f06 movel %d6,%sp@-
4bda4: 2f0d movel %a5,%sp@-
4bda6: 2f0c movel %a4,%sp@-
4bda8: 4eb9 0005 bbd0 jsr 5bbd0 <__divdi3>
4bdae: 4fef 0010 lea %sp@(16),%sp
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4bdb2: 2f04 movel %d4,%sp@-
4bdb4: 2f06 movel %d6,%sp@-
4bdb6: 2f0d movel %a5,%sp@-
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
4bdb8: 4bf9 0004 b858 lea 4b858 <rtems_bdbuf_read>,%a5
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4bdbe: 2f0c movel %a4,%sp@-
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
4bdc0: 49f9 0004 fe5c lea 4fe5c <memcpy>,%a4
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4bdc6: 2d41 fff8 movel %d1,%fp@(-8)
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4bdca: 4eb9 0005 c018 jsr 5c018 <__moddi3>
4bdd0: 4fef 0010 lea %sp@(16),%sp
4bdd4: 2e01 movel %d1,%d7
dev_t dev = dd->dev;
4bdd6: 2013 movel %a3@,%d0
4bdd8: 222b 0004 movel %a3@(4),%d1
args->bytes_moved = 0;
4bddc: 42aa 0018 clrl %a2@(24)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
4bde0: 47f9 0004 ba72 lea 4ba72 <rtems_bdbuf_release>,%a3
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
4bde6: 2d40 fff0 movel %d0,%fp@(-16)
4bdea: 2d41 fff4 movel %d1,%fp@(-12)
args->bytes_moved = 0;
while (count > 0)
4bdee: 604c bras 4be3c <rtems_blkdev_generic_read+0xc4>
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
4bdf0: 486e fffc pea %fp@(-4)
4bdf4: 2f00 movel %d0,%sp@-
4bdf6: 2f2e fff4 movel %fp@(-12),%sp@-
4bdfa: 2f2e fff0 movel %fp@(-16),%sp@-
4bdfe: 4e95 jsr %a5@
if (rc != RTEMS_SUCCESSFUL)
4be00: 4fef 0010 lea %sp@(16),%sp
4be04: 4a80 tstl %d0
4be06: 6640 bnes 4be48 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
break;
copy = block_size - blkofs;
4be08: 2a04 movel %d4,%d5
4be0a: 9a87 subl %d7,%d5
4be0c: b485 cmpl %d5,%d2
4be0e: 6402 bccs 4be12 <rtems_blkdev_generic_read+0x9a> <== ALWAYS TAKEN
4be10: 2a02 movel %d2,%d5 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
4be12: 206e fffc moveal %fp@(-4),%a0
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
4be16: 5286 addql #1,%d6
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
4be18: 2f05 movel %d5,%sp@-
4be1a: dea8 001e addl %a0@(30),%d7
4be1e: 2f07 movel %d7,%sp@-
4be20: 2f03 movel %d3,%sp@-
4be22: 4e94 jsr %a4@
rc = rtems_bdbuf_release(diskbuf);
4be24: 2f2e fffc movel %fp@(-4),%sp@-
4be28: 4e93 jsr %a3@
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
4be2a: 4fef 0010 lea %sp@(16),%sp
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
4be2e: dbaa 0018 addl %d5,%a2@(24)
if (rc != RTEMS_SUCCESSFUL)
4be32: 4a80 tstl %d0
4be34: 6612 bnes 4be48 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
break;
count -= copy;
4be36: 9485 subl %d5,%d2
buf += copy;
4be38: d685 addl %d5,%d3
blkofs = 0;
4be3a: 4287 clrl %d7
/* rtems_blkdev_generic_read --
* Generic block device read primitive. Implemented using block device
* buffer management primitives.
*/
rtems_device_driver
rtems_blkdev_generic_read(
4be3c: 202e fff8 movel %fp@(-8),%d0
4be40: d086 addl %d6,%d0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
4be42: 4a82 tstl %d2
4be44: 66aa bnes 4bdf0 <rtems_blkdev_generic_read+0x78>
4be46: 4280 clrl %d0
blkofs = 0;
block++;
}
return rc;
}
4be48: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4be4e: 4e5e unlk %fp <== NOT EXECUTED
0004be52 <rtems_blkdev_generic_write>:
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
4be52: 4e56 ffc8 linkw %fp,#-56
4be56: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4be5a: 246e 0010 moveal %fp@(16),%a2
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4be5e: 4286 clrl %d6
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
4be60: 4287 clrl %d7
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
4be62: 2052 moveal %a2@,%a0
4be64: 2668 0034 moveal %a0@(52),%a3
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
4be68: 282a 000c movel %a2@(12),%d4
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
4be6c: 262b 0020 movel %a3@(32),%d3
char *buf = args->buffer;
uint32_t count = args->count;
4be70: 242a 0010 movel %a2@(16),%d2
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4be74: 286a 0004 moveal %a2@(4),%a4
4be78: 2a6a 0008 moveal %a2@(8),%a5
4be7c: 2f03 movel %d3,%sp@-
4be7e: 2f06 movel %d6,%sp@-
4be80: 2f0d movel %a5,%sp@-
4be82: 2f0c movel %a4,%sp@-
4be84: 4eb9 0005 bbd0 jsr 5bbd0 <__divdi3>
4be8a: 4fef 0010 lea %sp@(16),%sp
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4be8e: 2f03 movel %d3,%sp@-
4be90: 2f06 movel %d6,%sp@-
4be92: 2f0d movel %a5,%sp@-
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dev, block, &diskbuf);
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
4be94: 4bf9 0004 b858 lea 4b858 <rtems_bdbuf_read>,%a5
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4be9a: 2f0c movel %a4,%sp@-
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dev, block, &diskbuf);
4be9c: 49f9 0004 b794 lea 4b794 <rtems_bdbuf_get>,%a4
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4bea2: 2d41 fff0 movel %d1,%fp@(-16)
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4bea6: 4eb9 0005 c018 jsr 5c018 <__moddi3>
4beac: 4fef 0010 lea %sp@(16),%sp
4beb0: 2c01 movel %d1,%d6
dev_t dev = dd->dev;
4beb2: 2013 movel %a3@,%d0
4beb4: 222b 0004 movel %a3@(4),%d1
args->bytes_moved = 0;
4beb8: 42aa 0018 clrl %a2@(24)
4bebc: 47ee fffc lea %fp@(-4),%a3
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
4bec0: 2d40 fff4 movel %d0,%fp@(-12)
4bec4: 2d41 fff8 movel %d1,%fp@(-8)
args->bytes_moved = 0;
while (count > 0)
4bec8: 606a bras 4bf34 <rtems_blkdev_generic_write+0xe2>
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
4beca: 4a86 tstl %d6
4becc: 6614 bnes 4bee2 <rtems_blkdev_generic_write+0x90><== NEVER TAKEN
4bece: b682 cmpl %d2,%d3
4bed0: 6210 bhis 4bee2 <rtems_blkdev_generic_write+0x90><== NEVER TAKEN
rc = rtems_bdbuf_get(dev, block, &diskbuf);
4bed2: 2f0b movel %a3,%sp@-
4bed4: 2f00 movel %d0,%sp@-
4bed6: 2f2e fff8 movel %fp@(-8),%sp@-
4beda: 2f2e fff4 movel %fp@(-12),%sp@-
4bede: 4e94 jsr %a4@
4bee0: 600e bras 4bef0 <rtems_blkdev_generic_write+0x9e>
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
4bee2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4bee4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4bee6: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4beea: 2f2e fff4 movel %fp@(-12),%sp@- <== NOT EXECUTED
4beee: 4e95 jsr %a5@ <== NOT EXECUTED
4bef0: 4fef 0010 lea %sp@(16),%sp
if (rc != RTEMS_SUCCESSFUL)
4bef4: 4a80 tstl %d0
4bef6: 6648 bnes 4bf40 <rtems_blkdev_generic_write+0xee><== NEVER TAKEN
break;
copy = block_size - blkofs;
4bef8: 2a03 movel %d3,%d5
4befa: 9a86 subl %d6,%d5
4befc: b485 cmpl %d5,%d2
4befe: 6402 bccs 4bf02 <rtems_blkdev_generic_write+0xb0><== ALWAYS TAKEN
4bf00: 2a02 movel %d2,%d5 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
4bf02: 2f05 movel %d5,%sp@-
4bf04: 206e fffc moveal %fp@(-4),%a0
args->bytes_moved += copy;
rc = rtems_bdbuf_release_modified(diskbuf);
4bf08: 5287 addql #1,%d7
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
4bf0a: 2f04 movel %d4,%sp@-
4bf0c: dca8 001e addl %a0@(30),%d6
4bf10: 2f06 movel %d6,%sp@-
4bf12: 4eb9 0004 fe5c jsr 4fe5c <memcpy>
args->bytes_moved += copy;
4bf18: dbaa 0018 addl %d5,%a2@(24)
rc = rtems_bdbuf_release_modified(diskbuf);
4bf1c: 2f2e fffc movel %fp@(-4),%sp@-
4bf20: 4eb9 0004 bb1c jsr 4bb1c <rtems_bdbuf_release_modified>
if (rc != RTEMS_SUCCESSFUL)
4bf26: 4fef 0010 lea %sp@(16),%sp
4bf2a: 4a80 tstl %d0
4bf2c: 6612 bnes 4bf40 <rtems_blkdev_generic_write+0xee><== NEVER TAKEN
break;
count -= copy;
4bf2e: 9485 subl %d5,%d2
buf += copy;
4bf30: d885 addl %d5,%d4
blkofs = 0;
4bf32: 4286 clrl %d6
/* rtems_blkdev_generic_write --
* Generic block device write primitive. Implemented using block device
* buffer management primitives.
*/
rtems_device_driver
rtems_blkdev_generic_write(
4bf34: 202e fff0 movel %fp@(-16),%d0
4bf38: d087 addl %d7,%d0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
4bf3a: 4a82 tstl %d2
4bf3c: 668c bnes 4beca <rtems_blkdev_generic_write+0x78>
4bf3e: 4280 clrl %d0
blkofs = 0;
block++;
}
return rc;
}
4bf40: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4bf46: 4e5e unlk %fp <== NOT EXECUTED
0004c04e <rtems_blkdev_ioctl>:
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4c04e: 4e56 0000 linkw %fp,#0
4c052: 226e 0008 moveal %fp@(8),%a1
4c056: 202e 000c movel %fp@(12),%d0
4c05a: 206e 0010 moveal %fp@(16),%a0
size_t *arg_size = argp;
int rc = 0;
switch (req)
4c05e: 0c80 4004 4203 cmpil #1074020867,%d0
4c064: 6724 beqs 4c08a <rtems_blkdev_ioctl+0x3c> <== NEVER TAKEN
4c066: 620a bhis 4c072 <rtems_blkdev_ioctl+0x24>
4c068: 0c80 4004 4202 cmpil #1074020866,%d0
4c06e: 662e bnes 4c09e <rtems_blkdev_ioctl+0x50> <== ALWAYS TAKEN
4c070: 6012 bras 4c084 <rtems_blkdev_ioctl+0x36> <== NOT EXECUTED
4c072: 0c80 4004 4205 cmpil #1074020869,%d0
4c078: 671e beqs 4c098 <rtems_blkdev_ioctl+0x4a> <== NEVER TAKEN
4c07a: 0c80 8004 4204 cmpil #-2147204604,%d0
4c080: 661c bnes 4c09e <rtems_blkdev_ioctl+0x50> <== NEVER TAKEN
4c082: 600e bras 4c092 <rtems_blkdev_ioctl+0x44>
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
4c084: 20a9 0024 movel %a1@(36),%a0@ <== NOT EXECUTED
4c088: 6004 bras 4c08e <rtems_blkdev_ioctl+0x40> <== NOT EXECUTED
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
4c08a: 20a9 0020 movel %a1@(32),%a0@ <== NOT EXECUTED
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
4c08e: 4280 clrl %d0
*arg_size = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
break;
4c090: 601a bras 4c0ac <rtems_blkdev_ioctl+0x5e>
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
4c092: 2350 0020 movel %a0@,%a1@(32)
4c096: 60f6 bras 4c08e <rtems_blkdev_ioctl+0x40>
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
4c098: 20a9 001c movel %a1@(28),%a0@ <== NOT EXECUTED
4c09c: 60f0 bras 4c08e <rtems_blkdev_ioctl+0x40> <== NOT EXECUTED
break;
default:
errno = EINVAL;
4c09e: 4eb9 0004 f63c jsr 4f63c <__errno>
4c0a4: 2040 moveal %d0,%a0
4c0a6: 7016 moveq #22,%d0
4c0a8: 2080 movel %d0,%a0@
rc = -1;
4c0aa: 70ff moveq #-1,%d0
break;
}
return rc;
}
4c0ac: 4e5e unlk %fp <== NOT EXECUTED
000423c4 <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
423c4: 4e56 ffec linkw %fp,#-20
423c8: 202e 0008 movel %fp@(8),%d0
423cc: 48d7 043c moveml %d2-%d5/%a2,%sp@
423d0: 246e 000c moveal %fp@(12),%a2
423d4: 242e 0010 movel %fp@(16),%d2
const char *p;
if ( !name )
423d8: 4a80 tstl %d0
423da: 674e beqs 4242a <rtems_bsp_cmdline_get_param+0x66><== NEVER TAKEN
return NULL;
if ( !value )
423dc: 4a8a tstl %a2
423de: 674c beqs 4242c <rtems_bsp_cmdline_get_param+0x68><== NEVER TAKEN
return NULL;
if ( !length )
423e0: 4a82 tstl %d2
423e2: 6746 beqs 4242a <rtems_bsp_cmdline_get_param+0x66><== NEVER TAKEN
return NULL;
value[0] = '\0';
423e4: 4212 clrb %a2@
p = rtems_bsp_cmdline_get_param_raw( name );
423e6: 2f00 movel %d0,%sp@-
423e8: 4eb9 0004 2438 jsr 42438 <rtems_bsp_cmdline_get_param_raw>
if ( !p )
423ee: 588f addql #4,%sp
423f0: 4a80 tstl %d0
423f2: 6736 beqs 4242a <rtems_bsp_cmdline_get_param+0x66><== NEVER TAKEN
423f4: 2240 moveal %d0,%a1
423f6: 204a moveal %a2,%a0
423f8: 4283 clrl %d3
423fa: 4281 clrl %d1
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
423fc: 5382 subql #1,%d2
423fe: 6020 bras 42420 <rtems_bsp_cmdline_get_param+0x5c>
if ( *p == '\"' ) {
42400: 7a22 moveq #34,%d5
42402: 1004 moveb %d4,%d0
42404: 49c0 extbl %d0
42406: ba80 cmpl %d0,%d5
42408: 6604 bnes 4240e <rtems_bsp_cmdline_get_param+0x4a>
quotes++;
4240a: 5283 addql #1,%d3
4240c: 600c bras 4241a <rtems_bsp_cmdline_get_param+0x56>
} else if ( ((quotes % 2) == 0) && *p == ' ' )
4240e: 0803 0000 btst #0,%d3
42412: 6606 bnes 4241a <rtems_bsp_cmdline_get_param+0x56>
42414: 7a20 moveq #32,%d5
42416: ba80 cmpl %d0,%d5
42418: 6712 beqs 4242c <rtems_bsp_cmdline_get_param+0x68>
break;
value[i++] = *p++;
4241a: 5281 addql #1,%d1
4241c: 10c4 moveb %d4,%a0@+
value[i] = '\0';
4241e: 4210 clrb %a0@
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
42420: 1819 moveb %a1@+,%d4
42422: 6708 beqs 4242c <rtems_bsp_cmdline_get_param+0x68>
42424: b481 cmpl %d1,%d2
42426: 62d8 bhis 42400 <rtems_bsp_cmdline_get_param+0x3c>
42428: 6002 bras 4242c <rtems_bsp_cmdline_get_param+0x68>
value[0] = '\0';
p = rtems_bsp_cmdline_get_param_raw( name );
if ( !p )
return NULL;
4242a: 95ca subal %a2,%a2
copy_string( p, value, length );
return value;
}
4242c: 200a movel %a2,%d0
4242e: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
42434: 4e5e unlk %fp <== NOT EXECUTED
000463cc <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
463cc: 4e56 0000 linkw %fp,#0
463d0: 2f03 movel %d3,%sp@-
463d2: 262e 0010 movel %fp@(16),%d3
463d6: 2f02 movel %d2,%sp@-
RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node **node
)
{
return _Chain_Get_with_empty_check( chain, node );
463d8: 2f2e 0014 movel %fp@(20),%sp@-
463dc: 2f2e 0008 movel %fp@(8),%sp@-
463e0: 242e 000c movel %fp@(12),%d2
463e4: 4eb9 0004 6970 jsr 46970 <_Chain_Get_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
463ea: 508f addql #8,%sp
463ec: 4a00 tstb %d0
463ee: 6718 beqs 46408 <rtems_chain_get_with_notification+0x3c><== NEVER TAKEN
sc = rtems_event_send( task, events );
463f0: 2d43 000c movel %d3,%fp@(12)
}
return sc;
}
463f4: 262e fffc movel %fp@(-4),%d3
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
463f8: 2d42 0008 movel %d2,%fp@(8)
}
return sc;
}
463fc: 242e fff8 movel %fp@(-8),%d2
46400: 4e5e unlk %fp
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
46402: 4ef9 0004 59f8 jmp 459f8 <rtems_event_send>
}
return sc;
}
46408: 242e fff8 movel %fp@(-8),%d2
4640c: 4280 clrl %d0
4640e: 262e fffc movel %fp@(-4),%d3
46412: 4e5e unlk %fp
...
00046418 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
46418: 4e56 ffe0 linkw %fp,#-32
4641c: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
46420: 260e movel %fp,%d3
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
46422: 47f9 0004 69b8 lea 469b8 <_Chain_Get>,%a3
46428: 5983 subql #4,%d3
4642a: 45f9 0004 5890 lea 45890 <rtems_event_receive>,%a2
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
46430: 2c2e 0008 movel %fp@(8),%d6
46434: 2a2e 000c movel %fp@(12),%d5
46438: 282e 0010 movel %fp@(16),%d4
4643c: 6012 bras 46450 <rtems_chain_get_with_wait+0x38>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
4643e: 2f03 movel %d3,%sp@-
46440: 2f04 movel %d4,%sp@-
46442: 42a7 clrl %sp@-
46444: 2f05 movel %d5,%sp@-
46446: 4e92 jsr %a2@
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
46448: 4fef 0010 lea %sp@(16),%sp
4644c: 4a80 tstl %d0
4644e: 660c bnes 4645c <rtems_chain_get_with_wait+0x44> <== ALWAYS TAKEN
46450: 2f06 movel %d6,%sp@-
46452: 4e93 jsr %a3@
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
46454: 588f addql #4,%sp
46456: 2400 movel %d0,%d2
46458: 67e4 beqs 4643e <rtems_chain_get_with_wait+0x26>
4645a: 4280 clrl %d0
timeout,
&out
);
}
*node_ptr = node;
4645c: 206e 0014 moveal %fp@(20),%a0
46460: 2082 movel %d2,%a0@
return sc;
}
46462: 4cee 0c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a3
46468: 4e5e unlk %fp <== NOT EXECUTED
00042a88 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
42a88: 4e56 ff90 linkw %fp,#-112
42a8c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
42a90: 242e 0008 movel %fp@(8),%d2
42a94: 246e 000c moveal %fp@(12),%a2
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
42a98: 4a8a tstl %a2
42a9a: 6700 0184 beqw 42c20 <rtems_cpu_usage_report_with_plugin+0x198>
}
}
}
#endif
(*print)(
42a9e: 4879 0005 c6a1 pea 5c6a1 <map.6391+0x11>
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
42aa4: 2c0e movel %fp,%d6
42aa6: 260e movel %fp,%d3
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
42aa8: 2a0e movel %fp,%d5
}
}
}
#endif
(*print)(
42aaa: 49f9 0005 f9a8 lea 5f9a8 <_Objects_Information_table+0x4>,%a4
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
42ab0: 0686 ffff ffbb addil #-69,%d6
42ab6: 0683 ffff ffc8 addil #-56,%d3
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
42abc: 0685 ffff ffd0 addil #-48,%d5
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
42ac2: 2039 0005 fbf0 movel 5fbf0 <CPU_usage_Uptime_at_last_reset>,%d0
42ac8: 2239 0005 fbf4 movel 5fbf4 <CPU_usage_Uptime_at_last_reset+0x4>,%d1
}
}
}
#endif
(*print)(
42ace: 2f02 movel %d2,%sp@-
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
42ad0: 2d40 ffe0 movel %d0,%fp@(-32)
42ad4: 2d41 ffe4 movel %d1,%fp@(-28)
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
42ad8: 42ae ffd0 clrl %fp@(-48)
42adc: 42ae ffd4 clrl %fp@(-44)
}
}
}
#endif
(*print)(
42ae0: 4e92 jsr %a2@
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
42ae2: 508f addql #8,%sp
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
42ae4: 205c moveal %a4@+,%a0
42ae6: 4a88 tstl %a0
42ae8: 6700 010a beqw 42bf4 <rtems_cpu_usage_report_with_plugin+0x16c>
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
42aec: 2a68 0004 moveal %a0@(4),%a5
if ( information ) {
42af0: 4a8d tstl %a5
42af2: 6600 00f2 bnew 42be6 <rtems_cpu_usage_report_with_plugin+0x15e>
42af6: 6000 00fc braw 42bf4 <rtems_cpu_usage_report_with_plugin+0x16c><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
42afa: 206d 0018 moveal %a5@(24),%a0
42afe: 2670 4c00 moveal %a0@(00000000,%d4:l:4),%a3
if ( !the_thread )
42b02: 4a8b tstl %a3
42b04: 6700 00dc beqw 42be2 <rtems_cpu_usage_report_with_plugin+0x15a>
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
42b08: 2f06 movel %d6,%sp@-
42b0a: 4878 000d pea d <OPER1+0x1>
42b0e: 2f2b 0008 movel %a3@(8),%sp@-
42b12: 4eb9 0004 65f0 jsr 465f0 <rtems_object_get_name>
(*print)(
42b18: 2f06 movel %d6,%sp@-
42b1a: 2f2b 0008 movel %a3@(8),%sp@-
42b1e: 4879 0005 c813 pea 5c813 <map.6391+0x183>
42b24: 2f02 movel %d2,%sp@-
42b26: 4e92 jsr %a2@
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
42b28: 2079 0005 fbb4 moveal 5fbb4 <_Per_CPU_Information+0xc>,%a0
42b2e: 4fef 001c lea %sp@(28),%sp
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
42b32: 202b 0082 movel %a3@(130),%d0
42b36: 222b 0086 movel %a3@(134),%d1
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
42b3a: 266b 0008 moveal %a3@(8),%a3
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
42b3e: 2d40 ffd8 movel %d0,%fp@(-40)
42b42: 2d41 ffdc movel %d1,%fp@(-36)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
42b46: b7e8 0008 cmpal %a0@(8),%a3
42b4a: 6640 bnes 42b8c <rtems_cpu_usage_report_with_plugin+0x104>
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
42b4c: 2f03 movel %d3,%sp@-
_Timestamp_Subtract( &last, &uptime, &used );
42b4e: 47ee fff0 lea %fp@(-16),%a3
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
*time_of_context_switch = _Thread_Time_of_last_context_switch;
42b52: 2039 0005 fbc2 movel 5fbc2 <_Per_CPU_Information+0x1a>,%d0
42b58: 2239 0005 fbc6 movel 5fbc6 <_Per_CPU_Information+0x1e>,%d1
42b5e: 2d40 ffe8 movel %d0,%fp@(-24)
42b62: 2d41 ffec movel %d1,%fp@(-20)
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
42b66: 4eb9 0004 77d0 jsr 477d0 <_TOD_Get_uptime>
_Timestamp_Subtract( &last, &uptime, &used );
42b6c: 2f0b movel %a3,%sp@-
42b6e: 2f03 movel %d3,%sp@-
42b70: 486e ffe8 pea %fp@(-24)
42b74: 4eb9 0004 9868 jsr 49868 <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
42b7a: 2f0b movel %a3,%sp@-
42b7c: 486e ffd8 pea %fp@(-40)
42b80: 4eb9 0004 9754 jsr 49754 <_Timespec_Add_to>
42b86: 4fef 0018 lea %sp@(24),%sp
42b8a: 600a bras 42b96 <rtems_cpu_usage_report_with_plugin+0x10e>
} else {
_TOD_Get_uptime( &uptime );
42b8c: 2f03 movel %d3,%sp@-
42b8e: 4eb9 0004 77d0 jsr 477d0 <_TOD_Get_uptime>
42b94: 588f addql #4,%sp
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
42b96: 2f05 movel %d5,%sp@-
42b98: 2f03 movel %d3,%sp@-
42b9a: 486e ffe0 pea %fp@(-32)
42b9e: 4eb9 0004 9868 jsr 49868 <_Timespec_Subtract>
_Timestamp_Divide( &ran, &total, &ival, &fval );
42ba4: 486e fffc pea %fp@(-4)
42ba8: 486e fff8 pea %fp@(-8)
42bac: 2f05 movel %d5,%sp@-
42bae: 486e ffd8 pea %fp@(-40)
42bb2: 4eb9 0004 978c jsr 4978c <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
42bb8: 2f2e fffc movel %fp@(-4),%sp@-
42bbc: 223c 0000 03e8 movel #1000,%d1
42bc2: 202e ffdc movel %fp@(-36),%d0
42bc6: 2f2e fff8 movel %fp@(-8),%sp@-
42bca: 4c41 0000 remul %d1,%d0,%d0
42bce: 2f00 movel %d0,%sp@-
42bd0: 2f2e ffd8 movel %fp@(-40),%sp@-
42bd4: 4879 0005 c826 pea 5c826 <map.6391+0x196>
42bda: 2f02 movel %d2,%sp@-
42bdc: 4e92 jsr %a2@
42bde: 4fef 0034 lea %sp@(52),%sp
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
42be2: 5284 addql #1,%d4
42be4: 6002 bras 42be8 <rtems_cpu_usage_report_with_plugin+0x160>
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
42be6: 7801 moveq #1,%d4
for ( i=1 ; i <= information->maximum ; i++ ) {
42be8: 4280 clrl %d0
42bea: 302d 000e movew %a5@(14),%d0
42bee: b084 cmpl %d4,%d0
42bf0: 6400 ff08 bccw 42afa <rtems_cpu_usage_report_with_plugin+0x72>
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
42bf4: b9fc 0005 f9b4 cmpal #391604,%a4
42bfa: 6600 fee8 bnew 42ae4 <rtems_cpu_usage_report_with_plugin+0x5c>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
42bfe: 202e ffd4 movel %fp@(-44),%d0
42c02: 263c 0000 03e8 movel #1000,%d3
42c08: 4c43 0000 remul %d3,%d0,%d0
42c0c: 2f00 movel %d0,%sp@-
42c0e: 2f2e ffd0 movel %fp@(-48),%sp@-
42c12: 4879 0005 c83e pea 5c83e <map.6391+0x1ae>
42c18: 2f02 movel %d2,%sp@-
42c1a: 4e92 jsr %a2@
42c1c: 4fef 0010 lea %sp@(16),%sp
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
42c20: 4cee 3cfc ff90 moveml %fp@(-112),%d2-%d7/%a2-%a5
42c26: 4e5e unlk %fp <== NOT EXECUTED
0004bfc8 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
4bfc8: 4e56 0000 linkw %fp,#0
4bfcc: 202e 0008 movel %fp@(8),%d0
4bfd0: 2f02 movel %d2,%sp@-
if (sc == RTEMS_SUCCESSFUL) {
4bfd2: 4a80 tstl %d0
4bfd4: 6722 beqs 4bff8 <rtems_deviceio_errno+0x30>
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
4bfd6: 721c moveq #28,%d1
4bfd8: b280 cmpl %d0,%d1
4bfda: 650c bcss 4bfe8 <rtems_deviceio_errno+0x20> <== NEVER TAKEN
eno = status_code_to_errno [sc];
4bfdc: 41f9 0005 b584 lea 5b584 <status_code_to_errno>,%a0
4bfe2: 2430 0c00 movel %a0@(00000000,%d0:l:4),%d2
4bfe6: 6002 bras 4bfea <rtems_deviceio_errno+0x22>
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
4bfe8: 7416 moveq #22,%d2 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
4bfea: 4eb9 0004 c034 jsr 4c034 <__errno>
4bff0: 2040 moveal %d0,%a0
return -1;
4bff2: 70ff moveq #-1,%d0
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
4bff4: 2082 movel %d2,%a0@
return -1;
4bff6: 6002 bras 4bffa <rtems_deviceio_errno+0x32>
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
4bff8: 4280 clrl %d0
errno = eno;
return -1;
}
}
4bffa: 242e fffc movel %fp@(-4),%d2
4bffe: 4e5e unlk %fp
...
00042742 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
42742: 4e56 ffec linkw %fp,#-20
42746: 48d7 041c moveml %d2-%d4/%a2,%sp@
4274a: 242e 0018 movel %fp@(24),%d2
4274e: 262e 001c movel %fp@(28),%d3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
42752: 42ae fffc clrl %fp@(-4)
rtems_blkdev_bnum end_block = begin_block + block_count;
sc = disk_lock();
42756: 4eba fd80 jsr %pc@(424d8 <disk_lock>)
4275a: 2800 movel %d0,%d4
if (sc != RTEMS_SUCCESSFUL) {
4275c: 6600 0094 bnew 427f2 <rtems_disk_create_log+0xb0>
return sc;
}
physical_disk = get_disk_entry(phys, true);
42760: 4878 0001 pea 1 <ADD>
42764: 2f2e 0014 movel %fp@(20),%sp@-
42768: 2f2e 0010 movel %fp@(16),%sp@-
4276c: 4eba fcc2 jsr %pc@(42430 <get_disk_entry>)
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
42770: 4fef 000c lea %sp@(12),%sp
42774: 4a80 tstl %d0
42776: 670a beqs 42782 <rtems_disk_create_log+0x40>
}
static bool
is_physical_disk(const rtems_disk_device *dd)
{
return dd->phys_dev == dd;
42778: 2040 moveal %d0,%a0
4277a: 2468 0008 moveal %a0@(8),%a2
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
physical_disk = get_disk_entry(phys, true);
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
4277e: b08a cmpl %a2,%d0
42780: 6708 beqs 4278a <rtems_disk_create_log+0x48>
disk_unlock();
42782: 4eba fd82 jsr %pc@(42506 <disk_unlock>)
return RTEMS_INVALID_ID;
42786: 7804 moveq #4,%d4
42788: 6068 bras 427f2 <rtems_disk_create_log+0xb0>
}
if (
begin_block >= physical_disk->size
4278a: 202a 001c movel %a2@(28),%d0
disk_unlock();
return RTEMS_INVALID_ID;
}
if (
4278e: b082 cmpl %d2,%d0
42790: 630c blss 4279e <rtems_disk_create_log+0x5c>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
rtems_blkdev_bnum end_block = begin_block + block_count;
42792: 2203 movel %d3,%d1
42794: d282 addl %d2,%d1
return RTEMS_INVALID_ID;
}
if (
begin_block >= physical_disk->size
|| end_block <= begin_block
42796: b481 cmpl %d1,%d2
42798: 6404 bccs 4279e <rtems_disk_create_log+0x5c> <== NEVER TAKEN
|| end_block > physical_disk->size
4279a: b081 cmpl %d1,%d0
4279c: 6408 bccs 427a6 <rtems_disk_create_log+0x64>
) {
disk_unlock();
4279e: 4eba fd66 jsr %pc@(42506 <disk_unlock>)
return RTEMS_INVALID_NUMBER;
427a2: 780a moveq #10,%d4
427a4: 604c bras 427f2 <rtems_disk_create_log+0xb0>
}
sc = create_disk(dev, name, &dd);
427a6: 486e fffc pea %fp@(-4)
427aa: 2f2e 0020 movel %fp@(32),%sp@-
427ae: 2f2e 000c movel %fp@(12),%sp@-
427b2: 2f2e 0008 movel %fp@(8),%sp@-
427b6: 4eba fd7c jsr %pc@(42534 <create_disk>)
if (sc != RTEMS_SUCCESSFUL) {
427ba: 4fef 0010 lea %sp@(16),%sp
disk_unlock();
return RTEMS_INVALID_NUMBER;
}
sc = create_disk(dev, name, &dd);
427be: 2800 movel %d0,%d4
if (sc != RTEMS_SUCCESSFUL) {
427c0: 662c bnes 427ee <rtems_disk_create_log+0xac>
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
427c2: 206e fffc moveal %fp@(-4),%a0
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
dd->ioctl = physical_disk->ioctl;
dd->driver_data = physical_disk->driver_data;
++physical_disk->uses;
427c6: 52aa 0014 addql #1,%a2@(20)
}
dd->phys_dev = physical_disk;
dd->start = begin_block;
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
427ca: 202a 0020 movel %a2@(32),%d0
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
427ce: 214a 0008 movel %a2,%a0@(8)
dd->start = begin_block;
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
dd->ioctl = physical_disk->ioctl;
427d2: 216a 0028 0028 movel %a2@(40),%a0@(40)
dd->driver_data = physical_disk->driver_data;
427d8: 216a 002c 002c movel %a2@(44),%a0@(44)
return sc;
}
dd->phys_dev = physical_disk;
dd->start = begin_block;
427de: 2142 0018 movel %d2,%a0@(24)
dd->size = block_count;
427e2: 2143 001c movel %d3,%a0@(28)
dd->block_size = dd->media_block_size = physical_disk->block_size;
427e6: 2140 0024 movel %d0,%a0@(36)
427ea: 2140 0020 movel %d0,%a0@(32)
dd->ioctl = physical_disk->ioctl;
dd->driver_data = physical_disk->driver_data;
++physical_disk->uses;
disk_unlock();
427ee: 4eba fd16 jsr %pc@(42506 <disk_unlock>)
return RTEMS_SUCCESSFUL;
}
427f2: 2004 movel %d4,%d0
427f4: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
427fa: 4e5e unlk %fp <== NOT EXECUTED
000426a8 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
426a8: 4e56 fff0 linkw %fp,#-16
426ac: 48d7 040c moveml %d2-%d3/%a2,%sp@
426b0: 262e 0010 movel %fp@(16),%d3
426b4: 246e 0018 moveal %fp@(24),%a2
rtems_disk_device *dd = NULL;
426b8: 42ae fffc clrl %fp@(-4)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
426bc: 4a8a tstl %a2
426be: 6770 beqs 42730 <rtems_disk_create_phys+0x88>
return RTEMS_INVALID_ADDRESS;
}
if (block_size == 0) {
426c0: 4a83 tstl %d3
426c2: 6770 beqs 42734 <rtems_disk_create_phys+0x8c>
return RTEMS_INVALID_NUMBER;
}
sc = disk_lock();
426c4: 4eba fe12 jsr %pc@(424d8 <disk_lock>)
426c8: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
426ca: 666a bnes 42736 <rtems_disk_create_phys+0x8e> <== NEVER TAKEN
return sc;
}
sc = create_disk(dev, name, &dd);
426cc: 486e fffc pea %fp@(-4)
426d0: 2f2e 0020 movel %fp@(32),%sp@-
426d4: 2f2e 000c movel %fp@(12),%sp@-
426d8: 2f2e 0008 movel %fp@(8),%sp@-
426dc: 4eba fe56 jsr %pc@(42534 <create_disk>)
if (sc != RTEMS_SUCCESSFUL) {
426e0: 4fef 0010 lea %sp@(16),%sp
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
sc = create_disk(dev, name, &dd);
426e4: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
426e6: 6642 bnes 4272a <rtems_disk_create_phys+0x82>
disk_unlock();
return sc;
}
dd->phys_dev = dd;
426e8: 206e fffc moveal %fp@(-4),%a0
dd->start = 0;
dd->size = block_count;
426ec: 216e 0014 001c movel %fp@(20),%a0@(28)
dd->block_size = dd->media_block_size = block_size;
dd->ioctl = handler;
dd->driver_data = driver_data;
426f2: 216e 001c 002c movel %fp@(28),%a0@(44)
disk_unlock();
return sc;
}
dd->phys_dev = dd;
426f8: 2148 0008 movel %a0,%a0@(8)
dd->start = 0;
426fc: 42a8 0018 clrl %a0@(24)
dd->size = block_count;
dd->block_size = dd->media_block_size = block_size;
42700: 2143 0024 movel %d3,%a0@(36)
42704: 2143 0020 movel %d3,%a0@(32)
dd->ioctl = handler;
42708: 214a 0028 movel %a2,%a0@(40)
dd->driver_data = driver_data;
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
4270c: 4868 000c pea %a0@(12)
42710: 2f3c 2000 4208 movel #536887816,%sp@-
42716: 2f08 movel %a0,%sp@-
42718: 4e92 jsr %a2@
4271a: 4fef 000c lea %sp@(12),%sp
4271e: 4a80 tstl %d0
42720: 6c08 bges 4272a <rtems_disk_create_phys+0x82> <== NEVER TAKEN
dd->capabilities = 0;
42722: 206e fffc moveal %fp@(-4),%a0
42726: 42a8 000c clrl %a0@(12)
}
disk_unlock();
4272a: 4eba fdda jsr %pc@(42506 <disk_unlock>)
return RTEMS_SUCCESSFUL;
4272e: 6006 bras 42736 <rtems_disk_create_phys+0x8e>
{
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
42730: 7409 moveq #9,%d2
42732: 6002 bras 42736 <rtems_disk_create_phys+0x8e>
}
if (block_size == 0) {
return RTEMS_INVALID_NUMBER;
42734: 740a moveq #10,%d2
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
42736: 2002 movel %d2,%d0
42738: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
4273e: 4e5e unlk %fp <== NOT EXECUTED
000427fe <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
427fe: 4e56 ffd8 linkw %fp,#-40
42802: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
42806: 4eba fcd0 jsr %pc@(424d8 <disk_lock>)
4280a: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
4280c: 6600 00f8 bnew 42906 <rtems_disk_delete+0x108>
return sc;
}
dd = get_disk_entry(dev, true);
42810: 4878 0001 pea 1 <ADD>
42814: 2f2e 000c movel %fp@(12),%sp@-
42818: 2f2e 0008 movel %fp@(8),%sp@-
4281c: 4eba fc12 jsr %pc@(42430 <get_disk_entry>)
if (dd == NULL) {
42820: 4fef 000c lea %sp@(12),%sp
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
dd = get_disk_entry(dev, true);
42824: 2040 moveal %d0,%a0
if (dd == NULL) {
42826: 4a80 tstl %d0
42828: 660c bnes 42836 <rtems_disk_delete+0x38> <== ALWAYS TAKEN
disk_unlock();
4282a: 4eba fcda jsr %pc@(42506 <disk_unlock>) <== NOT EXECUTED
return RTEMS_INVALID_ID;
4282e: 143c 0004 moveb #4,%d2 <== NOT EXECUTED
42832: 6000 00d2 braw 42906 <rtems_disk_delete+0x108> <== NOT EXECUTED
}
static void
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
42836: 2468 0008 moveal %a0@(8),%a2
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
4283a: 7001 moveq #1,%d0
4283c: 1140 0030 moveb %d0,%a0@(48)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
42840: 4a2a 0030 tstb %a2@(48)
42844: 6700 0094 beqw 428da <rtems_disk_delete+0xdc>
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
42848: 4287 clrl %d7
for (major = 0; major < disktab_size; ++major) {
4284a: 4283 clrl %d3
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
4284c: 49fa fc3c lea %pc@(4248a <free_disk_device>),%a4
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
42850: 2812 movel %a2@,%d4
42852: 2a2a 0004 movel %a2@(4),%d5
42856: 6054 bras 428ac <rtems_disk_delete+0xae>
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
42858: 2003 movel %d3,%d0
for (minor = 0; minor < dtab->size; ++minor) {
4285a: 4286 clrl %d6
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
4285c: e788 lsll #3,%d0
4285e: 2679 0006 0262 moveal 60262 <disktab>,%a3
42864: d7c0 addal %d0,%a3
42866: 603c bras 428a4 <rtems_disk_delete+0xa6>
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
42868: 2006 movel %d6,%d0
4286a: e588 lsll #2,%d0
4286c: 2253 moveal %a3@,%a1
4286e: d3c0 addal %d0,%a1
42870: 2051 moveal %a1@,%a0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
42872: 4a88 tstl %a0
42874: 672c beqs 428a2 <rtems_disk_delete+0xa4>
42876: 2a68 0008 moveal %a0@(8),%a5
4287a: 2015 movel %a5@,%d0
4287c: 222d 0004 movel %a5@(4),%d1
42880: 9285 subl %d5,%d1
42882: 9184 subxl %d4,%d0
42884: 661c bnes 428a2 <rtems_disk_delete+0xa4> <== NEVER TAKEN
42886: b5c8 cmpal %a0,%a2
42888: 6718 beqs 428a2 <rtems_disk_delete+0xa4>
if (dd->uses == 0) {
4288a: 4aa8 0014 tstl %a0@(20)
4288e: 660c bnes 4289c <rtems_disk_delete+0x9e>
++deleted_count;
dtab->minor [minor] = NULL;
42890: 4291 clrl %a1@
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
42892: 5287 addql #1,%d7
dtab->minor [minor] = NULL;
free_disk_device(dd);
42894: 2f08 movel %a0,%sp@-
42896: 4e94 jsr %a4@
42898: 588f addql #4,%sp
4289a: 6006 bras 428a2 <rtems_disk_delete+0xa4>
} else {
dd->deleted = true;
4289c: 7201 moveq #1,%d1
4289e: 1141 0030 moveb %d1,%a0@(48)
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
428a2: 5286 addql #1,%d6
428a4: bcab 0004 cmpl %a3@(4),%d6
428a8: 65be bcss 42868 <rtems_disk_delete+0x6a>
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
428aa: 5283 addql #1,%d3
428ac: b6b9 0006 025e cmpl 6025e <disktab_size>,%d3
428b2: 65a4 bcss 42858 <rtems_disk_delete+0x5a>
}
}
}
}
physical_disk->uses -= deleted_count;
428b4: 202a 0014 movel %a2@(20),%d0
428b8: 9087 subl %d7,%d0
428ba: 2540 0014 movel %d0,%a2@(20)
if (physical_disk->uses == 0) {
428be: 6642 bnes 42902 <rtems_disk_delete+0x104>
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
428c0: 2012 movel %a2@,%d0
disktab [major].minor [minor] = NULL;
428c2: 2079 0006 0262 moveal 60262 <disktab>,%a0
428c8: e788 lsll #3,%d0
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
428ca: 222a 0004 movel %a2@(4),%d1
disktab [major].minor [minor] = NULL;
428ce: 2070 0800 moveal %a0@(00000000,%d0:l),%a0
428d2: 42b0 1c00 clrl %a0@(00000000,%d1:l:4)
free_disk_device(physical_disk);
428d6: 2f0a movel %a2,%sp@-
428d8: 6022 bras 428fc <rtems_disk_delete+0xfe>
}
} else {
if (disk_to_remove->uses == 0) {
428da: 4aa8 0014 tstl %a0@(20)
428de: 6622 bnes 42902 <rtems_disk_delete+0x104> <== NEVER TAKEN
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
428e0: 2010 movel %a0@,%d0
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
428e2: 53aa 0014 subql #1,%a2@(20)
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
428e6: 2279 0006 0262 moveal 60262 <disktab>,%a1
428ec: e788 lsll #3,%d0
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
428ee: 2228 0004 movel %a0@(4),%d1
disktab [major].minor [minor] = NULL;
428f2: 2271 0800 moveal %a1@(00000000,%d0:l),%a1
428f6: 42b1 1c00 clrl %a1@(00000000,%d1:l:4)
free_disk_device(disk_to_remove);
428fa: 2f08 movel %a0,%sp@-
428fc: 4eba fb8c jsr %pc@(4248a <free_disk_device>)
42900: 588f addql #4,%sp
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
42902: 4eba fc02 jsr %pc@(42506 <disk_unlock>)
return RTEMS_SUCCESSFUL;
}
42906: 2002 movel %d2,%d0
42908: 4cee 3cfc ffd8 moveml %fp@(-40),%d2-%d7/%a2-%a5
4290e: 4e5e unlk %fp <== NOT EXECUTED
00042a74 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
42a74: 4e56 0000 linkw %fp,#0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
42a78: 4ab9 0006 025e tstl 6025e <disktab_size>
42a7e: 6600 008a bnew 42b0a <rtems_disk_io_initialize+0x96>
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
42a82: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
42a86: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
42a8a: 4eb9 0004 3294 jsr 43294 <calloc>
if (disktab == NULL) {
42a90: 508f addql #8,%sp
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
42a92: 23c0 0006 0262 movel %d0,60262 <disktab>
if (disktab == NULL) {
42a98: 6774 beqs 42b0e <rtems_disk_io_initialize+0x9a> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
42a9a: 4879 0006 025a pea 6025a <diskdevs_mutex>
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
42aa0: 4200 clrb %d0
sc = rtems_semaphore_create(
42aa2: 42a7 clrl %sp@-
42aa4: 4878 0010 pea 10 <INVALID_OPERATION>
42aa8: 4878 0001 pea 1 <ADD>
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
42aac: 13c0 0006 0258 moveb %d0,60258 <diskdevs_protected>
sc = rtems_semaphore_create(
42ab2: 2f3c 4444 4556 movel #1145324886,%sp@-
42ab8: 4eb9 0004 648c jsr 4648c <rtems_semaphore_create>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
42abe: 4fef 0014 lea %sp@(20),%sp
42ac2: 4a80 tstl %d0
42ac4: 6710 beqs 42ad6 <rtems_disk_io_initialize+0x62> <== ALWAYS TAKEN
free(disktab);
42ac6: 2f39 0006 0262 movel 60262 <disktab>,%sp@- <== NOT EXECUTED
42acc: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
42ad2: 588f addql #4,%sp <== NOT EXECUTED
42ad4: 6038 bras 42b0e <rtems_disk_io_initialize+0x9a> <== NOT EXECUTED
}
sc = rtems_bdbuf_init();
42ad6: 4eb9 0004 b3fa jsr 4b3fa <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
42adc: 4a80 tstl %d0
42ade: 671e beqs 42afe <rtems_disk_io_initialize+0x8a> <== ALWAYS TAKEN
rtems_semaphore_delete(diskdevs_mutex);
42ae0: 2f39 0006 025a movel 6025a <diskdevs_mutex>,%sp@- <== NOT EXECUTED
42ae6: 4eb9 0004 662c jsr 4662c <rtems_semaphore_delete> <== NOT EXECUTED
free(disktab);
42aec: 2f39 0006 0262 movel 60262 <disktab>,%sp@- <== NOT EXECUTED
42af2: 4eb9 0004 3630 jsr 43630 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
42af8: 508f addql #8,%sp <== NOT EXECUTED
42afa: 700d moveq #13,%d0 <== NOT EXECUTED
42afc: 6012 bras 42b10 <rtems_disk_io_initialize+0x9c> <== NOT EXECUTED
}
disktab_size = size;
42afe: 7008 moveq #8,%d0
42b00: 23c0 0006 025e movel %d0,6025e <disktab_size>
return RTEMS_SUCCESSFUL;
42b06: 4200 clrb %d0
42b08: 6006 bras 42b10 <rtems_disk_io_initialize+0x9c>
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
42b0a: 4280 clrl %d0 <== NOT EXECUTED
42b0c: 6002 bras 42b10 <rtems_disk_io_initialize+0x9c> <== NOT EXECUTED
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
42b0e: 701a moveq #26,%d0 <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
42b10: 4e5e unlk %fp <== NOT EXECUTED
000429ca <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
429ca: 4e56 fff0 linkw %fp,#-16
429ce: 202e 0008 movel %fp@(8),%d0
429d2: 222e 000c movel %fp@(12),%d1
429d6: 48d7 041c moveml %d2-%d4/%a2,%sp@
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
429da: 74ff moveq #-1,%d2
429dc: 76ff moveq #-1,%d3
429de: 9681 subl %d1,%d3
429e0: 9580 subxl %d0,%d2
429e2: 6718 beqs 429fc <rtems_disk_next+0x32>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
429e4: 2601 movel %d1,%d3
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
429e6: 2040 moveal %d0,%a0
429e8: 5283 addql #1,%d3
429ea: 74ff moveq #-1,%d2
429ec: b481 cmpl %d1,%d2
429ee: 6212 bhis 42a02 <rtems_disk_next+0x38> <== ALWAYS TAKEN
/* If major wraps around */
if ((major + 1) < major) {
429f0: 2408 movel %a0,%d2 <== NOT EXECUTED
429f2: 5282 addql #1,%d2 <== NOT EXECUTED
429f4: b1c2 cmpal %d2,%a0 <== NOT EXECUTED
429f6: 6270 bhis 42a68 <rtems_disk_next+0x9e> <== NOT EXECUTED
return NULL;
}
++major;
minor = 0;
429f8: 4283 clrl %d3 <== NOT EXECUTED
429fa: 6008 bras 42a04 <rtems_disk_next+0x3a> <== NOT EXECUTED
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
429fc: 4283 clrl %d3
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
429fe: 4282 clrl %d2
42a00: 6002 bras 42a04 <rtems_disk_next+0x3a>
return temp.__overlay.major;
42a02: 2400 movel %d0,%d2
} else {
++minor;
}
}
sc = disk_lock();
42a04: 4eba fad2 jsr %pc@(424d8 <disk_lock>)
if (sc != RTEMS_SUCCESSFUL) {
42a08: 4a80 tstl %d0
42a0a: 665c bnes 42a68 <rtems_disk_next+0x9e> <== NEVER TAKEN
return NULL;
}
if (major >= disktab_size) {
42a0c: 2239 0006 025e movel 6025e <disktab_size>,%d1
42a12: b282 cmpl %d2,%d1
42a14: 6320 blss 42a36 <rtems_disk_next+0x6c> <== NEVER TAKEN
disk_unlock();
return NULL;
}
dtab = disktab + major;
42a16: 2802 movel %d2,%d4
42a18: 2039 0006 0262 movel 60262 <disktab>,%d0
42a1e: 2440 moveal %d0,%a2
42a20: e78c lsll #3,%d4
42a22: d5c4 addal %d4,%a2
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
42a24: 2052 moveal %a2@,%a0
42a26: 4a88 tstl %a0
42a28: 6706 beqs 42a30 <rtems_disk_next+0x66>
42a2a: b6aa 0004 cmpl %a2@(4),%d3
42a2e: 6518 bcss 42a48 <rtems_disk_next+0x7e> <== NEVER TAKEN
minor = 0;
++major;
42a30: 5282 addql #1,%d2
if (major >= disktab_size) {
42a32: b282 cmpl %d2,%d1
42a34: 6206 bhis 42a3c <rtems_disk_next+0x72>
disk_unlock();
42a36: 4eba face jsr %pc@(42506 <disk_unlock>)
42a3a: 602c bras 42a68 <rtems_disk_next+0x9e>
return NULL;
}
dtab = disktab + major;
42a3c: 2602 movel %d2,%d3
42a3e: 2440 moveal %d0,%a2
42a40: e78b lsll #3,%d3
42a42: d5c3 addal %d3,%a2
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
42a44: 4283 clrl %d3
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
42a46: 60dc bras 42a24 <rtems_disk_next+0x5a>
} else if (dtab->minor [minor] == NULL) {
42a48: 2803 movel %d3,%d4
42a4a: e58c lsll #2,%d4
42a4c: 2070 4800 moveal %a0@(00000000,%d4:l),%a0
42a50: 4a88 tstl %a0
42a52: 6604 bnes 42a58 <rtems_disk_next+0x8e>
++minor;
42a54: 5283 addql #1,%d3
42a56: 60cc bras 42a24 <rtems_disk_next+0x5a>
} else {
++dtab->minor [minor]->uses;
42a58: 52a8 0014 addql #1,%a0@(20)
disk_unlock();
42a5c: 4eba faa8 jsr %pc@(42506 <disk_unlock>)
return dtab->minor [minor];
42a60: 2052 moveal %a2@,%a0
42a62: 2030 4800 movel %a0@(00000000,%d4:l),%d0
42a66: 6002 bras 42a6a <rtems_disk_next+0xa0>
}
}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
42a68: 4280 clrl %d0
disk_unlock();
return dtab->minor [minor];
}
}
}
42a6a: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
42a70: 4e5e unlk %fp <== NOT EXECUTED
00042912 <rtems_disk_obtain>:
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
rtems_interrupt_level level;
rtems_interrupt_disable(level);
42912: 203c 0000 0700 movel #1792,%d0
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
42918: 4e56 fff0 linkw %fp,#-16
4291c: 48d7 001c moveml %d2-%d4,%sp@
42920: 242e 0008 movel %fp@(8),%d2
42924: 262e 000c movel %fp@(12),%d3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
rtems_interrupt_level level;
rtems_interrupt_disable(level);
42928: 40c4 movew %sr,%d4
4292a: 8084 orl %d4,%d0
4292c: 46c0 movew %d0,%sr
if (!diskdevs_protected) {
4292e: 1039 0006 0258 moveb 60258 <diskdevs_protected>,%d0
42934: 6612 bnes 42948 <rtems_disk_obtain+0x36> <== NEVER TAKEN
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
42936: 42a7 clrl %sp@-
42938: 2f03 movel %d3,%sp@-
4293a: 2f02 movel %d2,%sp@-
4293c: 4eba faf2 jsr %pc@(42430 <get_disk_entry>)
rtems_interrupt_enable(level);
42940: 46c4 movew %d4,%sr
42942: 4fef 000c lea %sp@(12),%sp
42946: 6028 bras 42970 <rtems_disk_obtain+0x5e>
} else {
rtems_interrupt_enable(level);
42948: 46c4 movew %d4,%sr <== NOT EXECUTED
sc = disk_lock();
4294a: 4eba fb8c jsr %pc@(424d8 <disk_lock>) <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
4294e: 4a80 tstl %d0 <== NOT EXECUTED
42950: 661c bnes 4296e <rtems_disk_obtain+0x5c> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
42952: 42a7 clrl %sp@- <== NOT EXECUTED
42954: 2f03 movel %d3,%sp@- <== NOT EXECUTED
42956: 2f02 movel %d2,%sp@- <== NOT EXECUTED
42958: 4eba fad6 jsr %pc@(42430 <get_disk_entry>) <== NOT EXECUTED
disk_unlock();
4295c: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
42960: 4eba fba4 jsr %pc@(42506 <disk_unlock>) <== NOT EXECUTED
42964: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
42968: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4296c: 6002 bras 42970 <rtems_disk_obtain+0x5e> <== NOT EXECUTED
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
4296e: 4280 clrl %d0 <== NOT EXECUTED
disk_unlock();
}
}
return dd;
}
42970: 4cee 001c fff0 moveml %fp@(-16),%d2-%d4
42976: 4e5e unlk %fp <== NOT EXECUTED
00046ff4 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
46ff4: 4e56 fff4 linkw %fp,#-12
46ff8: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
46ffc: 242e 0008 movel %fp@(8),%d2
47000: 266e 0010 moveal %fp@(16),%a3
Extension_Control *the_extension;
if ( !id )
47004: 4a8b tstl %a3
47006: 6778 beqs 47080 <rtems_extension_create+0x8c> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
47008: 4a82 tstl %d2
4700a: 6778 beqs 47084 <rtems_extension_create+0x90> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
4700c: 2039 0005 f9e8 movel 5f9e8 <_Thread_Dispatch_disable_level>,%d0
47012: 5280 addql #1,%d0
47014: 23c0 0005 f9e8 movel %d0,5f9e8 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
4701a: 2039 0005 f9e8 movel 5f9e8 <_Thread_Dispatch_disable_level>,%d0
#ifndef __EXTENSION_MANAGER_inl
#define __EXTENSION_MANAGER_inl
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
47020: 4879 0005 fb44 pea 5fb44 <_Extension_Information>
47026: 4eb9 0004 7d88 jsr 47d88 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
4702c: 588f addql #4,%sp
4702e: 2440 moveal %d0,%a2
47030: 4a80 tstl %d0
47032: 660a bnes 4703e <rtems_extension_create+0x4a>
_Thread_Enable_dispatch();
47034: 4eb9 0004 8e68 jsr 48e68 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
4703a: 7005 moveq #5,%d0
4703c: 6048 bras 47086 <rtems_extension_create+0x92>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
4703e: 4878 0020 pea 20 <OPER2+0xc>
47042: 2f2e 000c movel %fp@(12),%sp@-
47046: 486a 0024 pea %a2@(36)
4704a: 4eb9 0004 d9dc jsr 4d9dc <memcpy>
_User_extensions_Add_set( extension );
47050: 486a 0010 pea %a2@(16)
47054: 4eb9 0004 98b0 jsr 498b0 <_User_extensions_Add_set>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
4705a: 202a 0008 movel %a2@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4705e: 4281 clrl %d1
47060: 2079 0005 fb5c moveal 5fb5c <_Extension_Information+0x18>,%a0
47066: 3200 movew %d0,%d1
47068: 218a 1c00 movel %a2,%a0@(00000000,%d1:l:4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
4706c: 2542 000c movel %d2,%a2@(12)
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
47070: 2680 movel %d0,%a3@
_Thread_Enable_dispatch();
47072: 4eb9 0004 8e68 jsr 48e68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
47078: 4fef 0010 lea %sp@(16),%sp
4707c: 4280 clrl %d0
4707e: 6006 bras 47086 <rtems_extension_create+0x92>
)
{
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
47080: 7009 moveq #9,%d0
47082: 6002 bras 47086 <rtems_extension_create+0x92>
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
47084: 7003 moveq #3,%d0
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
47086: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
4708c: 4e5e unlk %fp <== NOT EXECUTED
00049fb4 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
49fb4: 4e56 fff8 linkw %fp,#-8
49fb8: 202e 0008 movel %fp@(8),%d0
find_arg fa = {
49fbc: 42ae fffc clrl %fp@(-4)
49fc0: 2d40 fff8 movel %d0,%fp@(-8)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
49fc4: 6710 beqs 49fd6 <rtems_filesystem_get_mount_handler+0x22><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
49fc6: 486e fff8 pea %fp@(-8)
49fca: 487a ff14 pea %pc@(49ee0 <find_handler>)
49fce: 4eb9 0004 9f4a jsr 49f4a <rtems_filesystem_iterate>
49fd4: 508f addql #8,%sp
}
return fa.mount_h;
}
49fd6: 202e fffc movel %fp@(-4),%d0
49fda: 4e5e unlk %fp <== NOT EXECUTED
000426d8 <rtems_filesystem_initialize>:
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
426d8: 7012 moveq #18,%d0
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
426da: 4e56 ffe0 linkw %fp,#-32
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
426de: 2079 0005 c130 moveal 5c130 <rtems_current_user_env>,%a0
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
426e4: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
426e8: 2140 002c movel %d0,%a0@(44)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
426ec: 4ab9 0005 a4d4 tstl 5a4d4 <rtems_filesystem_mount_table_size>
426f2: 6608 bnes 426fc <rtems_filesystem_initialize+0x24><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
426f4: 2f3c abcd 0001 movel #-1412628479,%sp@- <== NOT EXECUTED
426fa: 602c bras 42728 <rtems_filesystem_initialize+0x50><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
426fc: 2079 0005 bfea moveal 5bfea <rtems_filesystem_mount_table>,%a0
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
42702: 42a7 clrl %sp@-
42704: 2f28 0004 movel %a0@(4),%sp@-
42708: 2f10 movel %a0@,%sp@-
4270a: 2f28 000c movel %a0@(12),%sp@-
4270e: 2f28 0008 movel %a0@(8),%sp@-
42712: 4eb9 0004 3066 jsr 43066 <mount>
if ( status == -1 )
42718: 4fef 0014 lea %sp@(20),%sp
4271c: 72ff moveq #-1,%d1
4271e: b280 cmpl %d0,%d1
42720: 660c bnes 4272e <rtems_filesystem_initialize+0x56><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
42722: 2f3c abcd 0002 movel #-1412628478,%sp@- <== NOT EXECUTED
42728: 4eb9 0004 60a0 jsr 460a0 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_filesystem_link_counts = 0;
4272e: 2079 0005 c130 moveal 5c130 <rtems_current_user_env>,%a0
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
42734: 240e movel %fp,%d2
42736: 0682 ffff ffec addil #-20,%d2
4273c: 47f9 0004 2a88 lea 42a88 <rtems_filesystem_evaluate_path>,%a3
rtems_filesystem_root = loc;
42742: 45f9 0004 c854 lea 4c854 <memcpy>,%a2
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
42748: 4240 clrw %d0
4274a: 3140 0030 movew %d0,%a0@(48)
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
4274e: 42a7 clrl %sp@-
42750: 2f02 movel %d2,%sp@-
42752: 42a7 clrl %sp@-
42754: 4878 0001 pea 1 <ADD>
42758: 4879 0005 ac98 pea 5ac98 <IMFS_ops+0x48>
4275e: 4e93 jsr %a3@
rtems_filesystem_root = loc;
42760: 4878 0014 pea 14 <OPER2>
42764: 2079 0005 c130 moveal 5c130 <rtems_current_user_env>,%a0
4276a: 41e8 0018 lea %a0@(24),%a0
4276e: 2f02 movel %d2,%sp@-
42770: 2f08 movel %a0,%sp@-
42772: 4e92 jsr %a2@
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
42774: 4fef 001c lea %sp@(28),%sp
42778: 4297 clrl %sp@
4277a: 2f02 movel %d2,%sp@-
4277c: 42a7 clrl %sp@-
4277e: 4878 0001 pea 1 <ADD>
42782: 4879 0005 ac98 pea 5ac98 <IMFS_ops+0x48>
42788: 4e93 jsr %a3@
rtems_filesystem_current = loc;
4278a: 4878 0014 pea 14 <OPER2>
4278e: 2039 0005 c130 movel 5c130 <rtems_current_user_env>,%d0
42794: 5880 addql #4,%d0
42796: 2f02 movel %d2,%sp@-
42798: 2f00 movel %d0,%sp@-
4279a: 4e92 jsr %a2@
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
4279c: 4fef 0020 lea %sp@(32),%sp
427a0: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
427a4: 4879 0005 ac9a pea 5ac9a <IMFS_ops+0x4a>
427aa: 4eb9 0004 2f00 jsr 42f00 <mkdir>
if ( status != 0 )
427b0: 508f addql #8,%sp
427b2: 4a80 tstl %d0
427b4: 670a beqs 427c0 <rtems_filesystem_initialize+0xe8><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
427b6: 2f3c abcd 0003 movel #-1412628477,%sp@- <== NOT EXECUTED
427bc: 6000 ff6a braw 42728 <rtems_filesystem_initialize+0x50><== NOT EXECUTED
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
427c0: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3
427c6: 4e5e unlk %fp
...
00049f4a <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
49f4a: 4e56 fff0 linkw %fp,#-16
49f4e: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
49f52: 266e 0008 moveal %fp@(8),%a3
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
49f56: 45f9 0005 a4e8 lea 5a4e8 <rtems_filesystem_table>,%a2
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
49f5c: 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;
49f60: 4203 clrb %d3
while ( table_entry->type && !stop ) {
49f62: 600c bras 49f70 <rtems_filesystem_iterate+0x26>
stop = (*routine)( table_entry, routine_arg );
49f64: 2f02 movel %d2,%sp@-
49f66: 2f0a movel %a2,%sp@-
++table_entry;
49f68: 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 );
49f6a: 4e93 jsr %a3@
++table_entry;
49f6c: 508f addql #8,%sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
stop = (*routine)( table_entry, routine_arg );
49f6e: 1600 moveb %d0,%d3
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
49f70: 4a92 tstl %a2@
49f72: 6706 beqs 49f7a <rtems_filesystem_iterate+0x30>
49f74: 4a03 tstb %d3
49f76: 67ec beqs 49f64 <rtems_filesystem_iterate+0x1a>
49f78: 602e bras 49fa8 <rtems_filesystem_iterate+0x5e>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
49f7a: 4a03 tstb %d3
49f7c: 662a bnes 49fa8 <rtems_filesystem_iterate+0x5e>
rtems_libio_lock();
49f7e: 4eba ff98 jsr %pc@(49f18 <rtems_libio_lock>)
49f82: 2479 0005 c138 moveal 5c138 <filesystem_chain>,%a2
for (
49f88: 600e bras 49f98 <rtems_filesystem_iterate+0x4e>
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
49f8a: 2f02 movel %d2,%sp@-
49f8c: 486a 0008 pea %a2@(8)
49f90: 4e93 jsr %a3@
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
49f92: 2452 moveal %a2@,%a2
49f94: 508f addql #8,%sp
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
49f96: 1600 moveb %d0,%d3
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
49f98: b5fc 0005 c13c cmpal #377148,%a2
49f9e: 6704 beqs 49fa4 <rtems_filesystem_iterate+0x5a>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
49fa0: 4a03 tstb %d3
49fa2: 67e6 beqs 49f8a <rtems_filesystem_iterate+0x40> <== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
49fa4: 4eba ff8e jsr %pc@(49f34 <rtems_libio_unlock>)
}
return stop;
}
49fa8: 1003 moveb %d3,%d0
49faa: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
49fb0: 4e5e unlk %fp <== NOT EXECUTED
00043018 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
43018: 4e56 fff0 linkw %fp,#-16
4301c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
43020: 266e 0008 moveal %fp@(8),%a3
43024: 262e 000c movel %fp@(12),%d3
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
43028: 4eba ffd2 jsr %pc@(42ffc <rtems_libio_lock>)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4302c: 2479 0005 c014 moveal 5c014 <mount_chain>,%a2
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
43032: 4202 clrb %d2
rtems_libio_lock();
for (
43034: 600c bras 43042 <rtems_filesystem_mount_iterate+0x2a>
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
43036: 2f03 movel %d3,%sp@-
43038: 2f0a movel %a2,%sp@-
4303a: 4e93 jsr %a3@
}
rtems_libio_unlock();
return stop;
}
4303c: 2452 moveal %a2@,%a2
4303e: 508f addql #8,%sp
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
43040: 1400 moveb %d0,%d2
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
43042: b5fc 0005 c018 cmpal #376856,%a2
43048: 6704 beqs 4304e <rtems_filesystem_mount_iterate+0x36>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
4304a: 4a02 tstb %d2
4304c: 67e8 beqs 43036 <rtems_filesystem_mount_iterate+0x1e><== ALWAYS TAKEN
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4304e: 2f39 0005 d6e0 movel 5d6e0 <rtems_libio_semaphore>,%sp@-
43054: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
4305a: 1002 moveb %d2,%d0
4305c: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
43062: 4e5e unlk %fp <== NOT EXECUTED
0004324e <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
4324e: 4e56 0000 linkw %fp,#0
43252: 2f0a movel %a2,%sp@-
43254: 2f02 movel %d2,%sp@-
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
43256: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
4325a: 242e 000c movel %fp@(12),%d2
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
4325e: 4eb9 0004 3638 jsr 43638 <malloc>
*key = new_key;
43264: 206e 0008 moveal %fp@(8),%a0
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
43268: 2440 moveal %d0,%a2
*key = new_key;
4326a: 2080 movel %d0,%a0@
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
4326c: 2f02 movel %d2,%sp@-
4326e: 2f00 movel %d0,%sp@-
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
*key = new_key;
new_key->val = NULL;
43270: 4292 clrl %a2@
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
43272: 42a7 clrl %sp@-
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
*key = new_key;
new_key->val = NULL;
new_key->dtor = dtor;
43274: 2542 0004 movel %d2,%a2@(4)
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
43278: 4eb9 0004 6784 jsr 46784 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
4327e: 4fef 0010 lea %sp@(16),%sp
43282: 4a80 tstl %d0
43284: 670e beqs 43294 <rtems_gxx_key_create+0x46> <== ALWAYS TAKEN
return 0;
free( new_key );
43286: 2f0a movel %a2,%sp@- <== NOT EXECUTED
43288: 4eb9 0004 30e8 jsr 430e8 <free> <== NOT EXECUTED
return -1;
4328e: 588f addql #4,%sp <== NOT EXECUTED
43290: 70ff moveq #-1,%d0 <== NOT EXECUTED
43292: 6002 bras 43296 <rtems_gxx_key_create+0x48> <== NOT EXECUTED
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
if ( status == RTEMS_SUCCESSFUL )
return 0;
43294: 4280 clrl %d0
free( new_key );
return -1;
}
43296: 242e fff8 movel %fp@(-8),%d2
4329a: 246e fffc moveal %fp@(-4),%a2
4329e: 4e5e unlk %fp <== NOT EXECUTED
000432b2 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
432b2: 4e56 0000 linkw %fp,#0
432b6: 2f0a movel %a2,%sp@-
432b8: 246e 0008 moveal %fp@(8),%a2
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
432bc: 2f0a movel %a2,%sp@-
432be: 42a7 clrl %sp@-
432c0: 4eb9 0004 6814 jsr 46814 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
432c6: 508f addql #8,%sp
432c8: 4a80 tstl %d0
432ca: 660e bnes 432da <rtems_gxx_key_delete+0x28> <== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
432cc: 4a8a tstl %a2
432ce: 670a beqs 432da <rtems_gxx_key_delete+0x28> <== NEVER TAKEN
432d0: 2f12 movel %a2@,%sp@-
432d2: 4eb9 0004 30e8 jsr 430e8 <free>
432d8: 588f addql #4,%sp
return 0;
}
key = NULL;
return 0;
}
432da: 246e fffc moveal %fp@(-4),%a2
432de: 4280 clrl %d0
432e0: 4e5e unlk %fp <== NOT EXECUTED
000431f4 <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
431f4: 4e56 fff0 linkw %fp,#-16
431f8: 48d7 040c moveml %d2-%d3/%a2,%sp@
431fc: 246e 0008 moveal %fp@(8),%a2
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
43200: 2012 movel %a2@,%d0
43202: 663e bnes 43242 <rtems_gxx_once+0x4e>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
43204: 260e movel %fp,%d3
43206: 5983 subql #4,%d3
43208: 2f03 movel %d3,%sp@-
4320a: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
4320e: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
43212: 4eb9 0004 65b0 jsr 465b0 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
43218: 2412 movel %a2@,%d2
4321a: 4fef 000c lea %sp@(12),%sp
4321e: 6604 bnes 43224 <rtems_gxx_once+0x30> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
43220: 7001 moveq #1,%d0
43222: 2480 movel %d0,%a2@
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
43224: 2f03 movel %d3,%sp@-
43226: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
4322a: 2f2e fffc movel %fp@(-4),%sp@-
4322e: 4eb9 0004 65b0 jsr 465b0 <rtems_task_mode>
if ( o == 0 )
43234: 4fef 000c lea %sp@(12),%sp
43238: 4a82 tstl %d2
4323a: 6606 bnes 43242 <rtems_gxx_once+0x4e> <== NEVER TAKEN
(*func)();
4323c: 206e 000c moveal %fp@(12),%a0
43240: 4e90 jsr %a0@
}
return 0;
}
43242: 4280 clrl %d0
43244: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
4324a: 4e5e unlk %fp <== NOT EXECUTED
00043340 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
43340: 4e56 0000 linkw %fp,#0
43344: 2f0a movel %a2,%sp@-
43346: 246e 0008 moveal %fp@(8),%a2
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
4334a: 2f2a 0004 movel %a2@(4),%sp@-
4334e: 2f0a movel %a2,%sp@-
43350: 42a7 clrl %sp@-
43352: 4eb9 0004 6784 jsr 46784 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
43358: 4fef 000c lea %sp@(12),%sp
4335c: 4a80 tstl %d0
4335e: 6606 bnes 43366 <rtems_gxx_setspecific+0x26> <== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
43360: 24ae 000c movel %fp@(12),%a2@
return 0;
43364: 6002 bras 43368 <rtems_gxx_setspecific+0x28>
}
return -1;
43366: 70ff moveq #-1,%d0 <== NOT EXECUTED
}
43368: 246e fffc moveal %fp@(-4),%a2
4336c: 4e5e unlk %fp <== NOT EXECUTED
00046e08 <rtems_heap_allocate_aligned_with_boundary>:
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
if (
46e08: 7003 moveq #3,%d0
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
46e0a: 4e56 0000 linkw %fp,#0
if (
46e0e: b0b9 0006 2f44 cmpl 62f44 <_System_state_Current>,%d0
46e14: 660a bnes 46e20 <rtems_heap_allocate_aligned_with_boundary+0x18><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
46e16: 4eb9 0004 5f70 jsr 45f70 <malloc_is_system_state_OK>
46e1c: 4a00 tstb %d0
46e1e: 6724 beqs 46e44 <rtems_heap_allocate_aligned_with_boundary+0x3c>
) {
return NULL;
}
malloc_deferred_frees_process();
46e20: 4eb9 0004 5fae jsr 45fae <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
46e26: 2f2e 0010 movel %fp@(16),%sp@-
46e2a: 2f2e 000c movel %fp@(12),%sp@-
46e2e: 2f2e 0008 movel %fp@(8),%sp@-
46e32: 2f39 0006 0cae movel 60cae <RTEMS_Malloc_Heap>,%sp@-
46e38: 4eb9 0004 b3b0 jsr 4b3b0 <_Protected_heap_Allocate_aligned_with_boundary>
46e3e: 4fef 0010 lea %sp@(16),%sp
46e42: 6002 bras 46e46 <rtems_heap_allocate_aligned_with_boundary+0x3e>
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
) {
return NULL;
46e44: 4280 clrl %d0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
46e46: 4e5e unlk %fp
...
00042648 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
42648: 4e56 ffd4 linkw %fp,#-44
4264c: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
42650: 262e 0008 movel %fp@(8),%d3
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
42654: 49f9 0004 d3a0 lea 4d3a0 <strlen>,%a4
4265a: 240e movel %fp,%d2
4265c: 0682 ffff ffec addil #-20,%d2
42662: 2f03 movel %d3,%sp@-
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
42664: 246e 000c moveal %fp@(12),%a2
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
42668: 4e94 jsr %a4@
4266a: 7201 moveq #1,%d1
4266c: 2e81 movel %d1,%sp@
4266e: 2f02 movel %d2,%sp@-
42670: 42a7 clrl %sp@-
42672: 2f00 movel %d0,%sp@-
42674: 2f03 movel %d3,%sp@-
42676: 4eb9 0004 2a88 jsr 42a88 <rtems_filesystem_evaluate_path>
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
4267c: 206e fff8 moveal %fp@(-8),%a0
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
42680: 2800 movel %d0,%d4
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
42682: 2f02 movel %d2,%sp@-
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
42684: 266e ffec moveal %fp@(-20),%a3
node_type = (*loc.ops->node_type_h)( &loc );
42688: 2068 0010 moveal %a0@(16),%a0
4268c: 4e90 jsr %a0@
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
4268e: 4fef 0018 lea %sp@(24),%sp
42692: 4a84 tstl %d4
42694: 6606 bnes 4269c <rtems_io_lookup_name+0x54> <== NEVER TAKEN
42696: 7202 moveq #2,%d1
42698: b280 cmpl %d0,%d1
4269a: 670e beqs 426aa <rtems_io_lookup_name+0x62>
rtems_filesystem_freenode( &loc );
4269c: 2f02 movel %d2,%sp@-
4269e: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
426a4: 588f addql #4,%sp
426a6: 700d moveq #13,%d0
426a8: 6022 bras 426cc <rtems_io_lookup_name+0x84>
}
device_info->device_name = (char *) name;
426aa: 2483 movel %d3,%a2@
device_info->device_name_length = strlen( name );
426ac: 2f03 movel %d3,%sp@-
426ae: 4e94 jsr %a4@
426b0: 2540 0004 movel %d0,%a2@(4)
device_info->major = the_jnode->info.device.major;
426b4: 256b 004c 0008 movel %a3@(76),%a2@(8)
device_info->minor = the_jnode->info.device.minor;
426ba: 256b 0050 000c movel %a3@(80),%a2@(12)
rtems_filesystem_freenode( &loc );
426c0: 2e82 movel %d2,%sp@
426c2: 4eb9 0004 2b54 jsr 42b54 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
426c8: 588f addql #4,%sp
426ca: 4280 clrl %d0
}
426cc: 4cee 1c1c ffd4 moveml %fp@(-44),%d2-%d4/%a2-%a4
426d2: 4e5e unlk %fp
...
00046e18 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
46e18: 4e56 0000 linkw %fp,#0
46e1c: 206e 000c moveal %fp@(12),%a0
46e20: 2f0a movel %a2,%sp@-
46e22: 226e 0010 moveal %fp@(16),%a1
46e26: 2f02 movel %d2,%sp@-
46e28: 242e 0008 movel %fp@(8),%d2
rtems_device_major_number major_limit = _IO_Number_of_drivers;
46e2c: 2039 0006 0e4c movel 60e4c <_IO_Number_of_drivers>,%d0
if ( rtems_interrupt_is_in_progress() )
46e32: 4ab9 0006 0dd0 tstl 60dd0 <_Per_CPU_Information+0x8>
46e38: 6600 00de bnew 46f18 <rtems_io_register_driver+0x100>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
46e3c: 4a89 tstl %a1
46e3e: 6700 00dc beqw 46f1c <rtems_io_register_driver+0x104>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
46e42: 2280 movel %d0,%a1@
if ( driver_table == NULL )
46e44: 4a88 tstl %a0
46e46: 6700 00d4 beqw 46f1c <rtems_io_register_driver+0x104>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46e4a: 4a90 tstl %a0@
46e4c: 6600 00e0 bnew 46f2e <rtems_io_register_driver+0x116>
46e50: 4aa8 0004 tstl %a0@(4)
46e54: 6600 00d8 bnew 46f2e <rtems_io_register_driver+0x116>
46e58: 6000 00c2 braw 46f1c <rtems_io_register_driver+0x104>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
46e5c: 2039 0006 0c40 movel 60c40 <_Thread_Dispatch_disable_level>,%d0
46e62: 5280 addql #1,%d0
46e64: 23c0 0006 0c40 movel %d0,60c40 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
46e6a: 2039 0006 0c40 movel 60c40 <_Thread_Dispatch_disable_level>,%d0
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
46e70: 4a82 tstl %d2
46e72: 662c bnes 46ea0 <rtems_io_register_driver+0x88>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
46e74: 2039 0006 0e4c movel 60e4c <_IO_Number_of_drivers>,%d0
46e7a: 2479 0006 0e50 moveal 60e50 <_IO_Driver_address_table>,%a2
46e80: 6010 bras 46e92 <rtems_io_register_driver+0x7a>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46e82: 4a92 tstl %a2@
46e84: 6600 00b0 bnew 46f36 <rtems_io_register_driver+0x11e>
46e88: 4aaa 0004 tstl %a2@(4)
46e8c: 6600 00a8 bnew 46f36 <rtems_io_register_driver+0x11e>
46e90: 6004 bras 46e96 <rtems_io_register_driver+0x7e>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
46e92: b082 cmpl %d2,%d0
46e94: 66ec bnes 46e82 <rtems_io_register_driver+0x6a>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
46e96: 2282 movel %d2,%a1@
if ( m != n )
46e98: b082 cmpl %d2,%d0
46e9a: 6638 bnes 46ed4 <rtems_io_register_driver+0xbc>
46e9c: 6000 00a2 braw 46f40 <rtems_io_register_driver+0x128>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
46ea0: 2202 movel %d2,%d1
46ea2: 2002 movel %d2,%d0
46ea4: e789 lsll #3,%d1
46ea6: eb88 lsll #5,%d0
46ea8: 2479 0006 0e50 moveal 60e50 <_IO_Driver_address_table>,%a2
46eae: 9081 subl %d1,%d0
46eb0: d5c0 addal %d0,%a2
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46eb2: 4a92 tstl %a2@
46eb4: 660c bnes 46ec2 <rtems_io_register_driver+0xaa>
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
}
rtems_status_code rtems_io_register_driver(
46eb6: 4aaa 0004 tstl %a2@(4)
46eba: 57c0 seq %d0
46ebc: 49c0 extbl %d0
46ebe: 4480 negl %d0
46ec0: 6002 bras 46ec4 <rtems_io_register_driver+0xac>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46ec2: 4280 clrl %d0
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
46ec4: 4a00 tstb %d0
46ec6: 660a bnes 46ed2 <rtems_io_register_driver+0xba>
_Thread_Enable_dispatch();
46ec8: 4eb9 0004 8b0c jsr 48b0c <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
46ece: 700c moveq #12,%d0
46ed0: 6050 bras 46f22 <rtems_io_register_driver+0x10a>
}
*registered_major = major;
46ed2: 2282 movel %d2,%a1@
}
_IO_Driver_address_table [major] = *driver_table;
46ed4: 2202 movel %d2,%d1
46ed6: 2002 movel %d2,%d0
46ed8: 4878 0018 pea 18 <OPER2+0x4>
46edc: e789 lsll #3,%d1
46ede: eb88 lsll #5,%d0
46ee0: 2f08 movel %a0,%sp@-
46ee2: 9081 subl %d1,%d0
46ee4: d0b9 0006 0e50 addl 60e50 <_IO_Driver_address_table>,%d0
46eea: 2f00 movel %d0,%sp@-
46eec: 4eb9 0004 fe5c jsr 4fe5c <memcpy>
_Thread_Enable_dispatch();
46ef2: 4eb9 0004 8b0c jsr 48b0c <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
}
46ef8: 246e fffc moveal %fp@(-4),%a2
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46efc: 4fef 000c lea %sp@(12),%sp
46f00: 2d42 0008 movel %d2,%fp@(8)
}
46f04: 242e fff8 movel %fp@(-8),%d2
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46f08: 42ae 0010 clrl %fp@(16)
46f0c: 42ae 000c clrl %fp@(12)
}
46f10: 4e5e unlk %fp
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46f12: 4ef9 0004 db1c jmp 4db1c <rtems_io_initialize>
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
46f18: 7012 moveq #18,%d0
46f1a: 6006 bras 46f22 <rtems_io_register_driver+0x10a>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
46f1c: 7009 moveq #9,%d0
46f1e: 6002 bras 46f22 <rtems_io_register_driver+0x10a>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
46f20: 700a moveq #10,%d0
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
46f22: 242e fff8 movel %fp@(-8),%d2
46f26: 246e fffc moveal %fp@(-4),%a2
46f2a: 4e5e unlk %fp
46f2c: 4e75 rts
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
46f2e: b082 cmpl %d2,%d0
46f30: 63ee blss 46f20 <rtems_io_register_driver+0x108>
46f32: 6000 ff28 braw 46e5c <rtems_io_register_driver+0x44>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
46f36: 5282 addql #1,%d2
46f38: 45ea 0018 lea %a2@(24),%a2
46f3c: 6000 ff54 braw 46e92 <rtems_io_register_driver+0x7a>
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
46f40: 4eb9 0004 8b0c jsr 48b0c <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
46f46: 7005 moveq #5,%d0
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
46f48: 60d8 bras 46f22 <rtems_io_register_driver+0x10a>
...
00047d30 <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)
{
47d30: 4e56 fff0 linkw %fp,#-16
47d34: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
47d38: 286e 0008 moveal %fp@(8),%a4
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
47d3c: 4a8c tstl %a4
47d3e: 673c beqs 47d7c <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
47d40: 45f9 0005 f9a8 lea 5f9a8 <_Objects_Information_table+0x4>,%a2
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
47d46: 205a moveal %a2@+,%a0
47d48: 4a88 tstl %a0
47d4a: 6728 beqs 47d74 <rtems_iterate_over_all_threads+0x44>
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
47d4c: 2668 0004 moveal %a0@(4),%a3
if ( !information )
47d50: 4a8b tstl %a3
47d52: 6720 beqs 47d74 <rtems_iterate_over_all_threads+0x44>
47d54: 7401 moveq #1,%d2
47d56: 6012 bras 47d6a <rtems_iterate_over_all_threads+0x3a>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
47d58: 206b 0018 moveal %a3@(24),%a0
47d5c: 2030 2c00 movel %a0@(00000000,%d2:l:4),%d0
if ( !the_thread )
47d60: 6706 beqs 47d68 <rtems_iterate_over_all_threads+0x38><== NEVER TAKEN
continue;
(*routine)(the_thread);
47d62: 2f00 movel %d0,%sp@-
47d64: 4e94 jsr %a4@
47d66: 588f addql #4,%sp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
47d68: 5282 addql #1,%d2
47d6a: 4280 clrl %d0
47d6c: 302b 000e movew %a3@(14),%d0
47d70: b082 cmpl %d2,%d0
47d72: 64e4 bccs 47d58 <rtems_iterate_over_all_threads+0x28>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
47d74: b5fc 0005 f9b4 cmpal #391604,%a2
47d7a: 66ca bnes 47d46 <rtems_iterate_over_all_threads+0x16>
(*routine)(the_thread);
}
}
}
47d7c: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
47d82: 4e5e unlk %fp
...
00049df6 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
49df6: 4e56 0000 linkw %fp,#0
49dfa: 2f0a movel %a2,%sp@-
49dfc: 246e 0008 moveal %fp@(8),%a2
rtems_libio_lock();
49e00: 4eba fea2 jsr %pc@(49ca4 <rtems_libio_lock>)
if (iop->sem)
49e04: 202a 002c movel %a2@(44),%d0
49e08: 670a beqs 49e14 <rtems_libio_free+0x1e> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
49e0a: 2f00 movel %d0,%sp@-
49e0c: 4eb9 0004 5944 jsr 45944 <rtems_semaphore_delete>
49e12: 588f addql #4,%sp
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
49e14: 41f9 0005 d6dc lea 5d6dc <rtems_libio_iop_freelist>,%a0
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
49e1a: 203c ffff feff movel #-257,%d0
iop->data1 = rtems_libio_iop_freelist;
49e20: 2550 0034 movel %a0@,%a2@(52)
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
49e24: c1aa 0014 andl %d0,%a2@(20)
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
49e28: 23ca 0005 d6dc movel %a2,5d6dc <rtems_libio_iop_freelist>
rtems_libio_unlock();
}
49e2e: 246e fffc moveal %fp@(-4),%a2
49e32: 4e5e unlk %fp
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
49e34: 6000 fe8a braw 49cc0 <rtems_libio_unlock>
00042c74 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
42c74: 4e56 0000 linkw %fp,#0
42c78: 2f02 movel %d2,%sp@-
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
42c7a: 2439 0005 bff2 movel 5bff2 <rtems_libio_number_iops>,%d2
42c80: 6744 beqs 42cc6 <rtems_libio_init+0x52> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
42c82: 4878 0038 pea 38 <DBL_MANT_DIG+0x3>
42c86: 2f02 movel %d2,%sp@-
42c88: 4eb9 0004 27cc jsr 427cc <calloc>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
42c8e: 508f addql #8,%sp
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
42c90: 23c0 0005 d6d8 movel %d0,5d6d8 <rtems_libio_iops>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
42c96: 6606 bnes 42c9e <rtems_libio_init+0x2a>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
42c98: 4878 001a pea 1a <OPER2+0x6>
42c9c: 604e bras 42cec <rtems_libio_init+0x78>
iop = rtems_libio_iop_freelist = rtems_libio_iops;
42c9e: 23c0 0005 d6dc movel %d0,5d6dc <rtems_libio_iop_freelist>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
42ca4: 2040 moveal %d0,%a0
42ca6: 4281 clrl %d1
42ca8: 6008 bras 42cb2 <rtems_libio_init+0x3e>
iop->data1 = iop + 1;
42caa: 41e8 0038 lea %a0@(56),%a0
42cae: 2148 fffc movel %a0,%a0@(-4)
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
42cb2: 5281 addql #1,%d1
42cb4: b481 cmpl %d1,%d2
42cb6: 66f2 bnes 42caa <rtems_libio_init+0x36>
iop->data1 = iop + 1;
iop->data1 = NULL;
42cb8: 2401 movel %d1,%d2
42cba: 2040 moveal %d0,%a0
42cbc: e78a lsll #3,%d2
42cbe: ed89 lsll #6,%d1
42cc0: 9282 subl %d2,%d1
42cc2: 42b0 18fc clrl %a0@(fffffffc,%d1:l)
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
42cc6: 4879 0005 d6e0 pea 5d6e0 <rtems_libio_semaphore>
42ccc: 42a7 clrl %sp@-
42cce: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
42cd2: 4878 0001 pea 1 <ADD>
42cd6: 2f3c 4c42 494f movel #1279412559,%sp@-
42cdc: 4eb9 0004 57a4 jsr 457a4 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
42ce2: 4fef 0014 lea %sp@(20),%sp
42ce6: 4a80 tstl %d0
42ce8: 6708 beqs 42cf2 <rtems_libio_init+0x7e> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
42cea: 2f00 movel %d0,%sp@- <== NOT EXECUTED
42cec: 4eb9 0004 60a0 jsr 460a0 <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
42cf2: 2279 0005 bff6 moveal 5bff6 <rtems_fs_init_helper>,%a1
42cf8: 4a89 tstl %a1
42cfa: 6708 beqs 42d04 <rtems_libio_init+0x90> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
42cfc: 242e fffc movel %fp@(-4),%d2
42d00: 4e5e unlk %fp
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
42d02: 4ed1 jmp %a1@
}
42d04: 242e fffc movel %fp@(-4),%d2 <== NOT EXECUTED
42d08: 4e5e unlk %fp <== NOT EXECUTED
00045d2c <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
45d2c: 4e56 fff8 linkw %fp,#-8
45d30: 2f03 movel %d3,%sp@-
45d32: 262e 0008 movel %fp@(8),%d3
45d36: 2f02 movel %d2,%sp@-
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
45d38: 4eb9 0004 87d8 jsr 487d8 <rtems_task_self>
45d3e: 2400 movel %d0,%d2
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
45d40: b083 cmpl %d3,%d0
45d42: 6740 beqs 45d84 <rtems_libio_share_private_env+0x58><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
45d44: 486e fffc pea %fp@(-4)
45d48: 4879 0005 ed50 pea 5ed50 <rtems_current_user_env>
45d4e: 2f03 movel %d3,%sp@-
45d50: 4eb9 0004 8924 jsr 48924 <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
45d56: 4fef 000c lea %sp@(12),%sp
45d5a: 4a80 tstl %d0
45d5c: 6628 bnes 45d86 <rtems_libio_share_private_env+0x5a>
* If we have a current environment in place, we need to
* free it, since we will be sharing the variable with the
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
45d5e: 2079 0005 ed50 moveal 5ed50 <rtems_current_user_env>,%a0
45d64: b490 cmpl %a0@,%d2
45d66: 6610 bnes 45d78 <rtems_libio_share_private_env+0x4c>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
45d68: 2f08 movel %a0,%sp@-
45d6a: 2d40 fff8 movel %d0,%fp@(-8)
45d6e: 4eba fe70 jsr %pc@(45be0 <free_user_env>)
45d72: 202e fff8 movel %fp@(-8),%d0
45d76: 588f addql #4,%sp
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
45d78: 41ee fffc lea %fp@(-4),%a0
45d7c: 23d0 0005 ed50 movel %a0@,5ed50 <rtems_current_user_env>
/* increase the reference count */
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
45d82: 6002 bras 45d86 <rtems_libio_share_private_env+0x5a>
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
45d84: 4280 clrl %d0 <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
45d86: 242e fff0 movel %fp@(-16),%d2
45d8a: 262e fff4 movel %fp@(-12),%d3
45d8e: 4e5e unlk %fp
...
00049d16 <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49d16: 7006 moveq #6,%d0
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
49d18: 4e56 0000 linkw %fp,#0
49d1c: 222e 0008 movel %fp@(8),%d1
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49d20: c081 andl %d1,%d0
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
49d22: 2f02 movel %d2,%sp@-
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
49d24: 7406 moveq #6,%d2
49d26: b480 cmpl %d0,%d2
49d28: 6710 beqs 49d3a <rtems_libio_to_fcntl_flags+0x24><== NEVER TAKEN
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
49d2a: 0801 0001 btst #1,%d1
49d2e: 660e bnes 49d3e <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;
49d30: 44c1 movew %d1,%ccr <== NOT EXECUTED
49d32: 57c0 seq %d0 <== NOT EXECUTED
49d34: 49c0 extbl %d0 <== NOT EXECUTED
49d36: 4480 negl %d0 <== NOT EXECUTED
49d38: 6006 bras 49d40 <rtems_libio_to_fcntl_flags+0x2a><== NOT EXECUTED
49d3a: 7002 moveq #2,%d0 <== NOT EXECUTED
49d3c: 6002 bras 49d40 <rtems_libio_to_fcntl_flags+0x2a><== NOT EXECUTED
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
49d3e: 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 ) {
49d40: 0801 0000 btst #0,%d1
49d44: 6704 beqs 49d4a <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_NONBLOCK;
49d46: 08c0 000e bset #14,%d0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
49d4a: 0801 0009 btst #9,%d1
49d4e: 6704 beqs 49d54 <rtems_libio_to_fcntl_flags+0x3e>
fcntl_flags |= O_APPEND;
49d50: 7408 moveq #8,%d2
49d52: 8082 orl %d2,%d0
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
49d54: 0801 000a btst #10,%d1
49d58: 6704 beqs 49d5e <rtems_libio_to_fcntl_flags+0x48>
fcntl_flags |= O_CREAT;
49d5a: 08c0 0009 bset #9,%d0
}
return fcntl_flags;
}
49d5e: 241f movel %sp@+,%d2
49d60: 4e5e unlk %fp <== NOT EXECUTED
00046288 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
46288: 4e56 fffc linkw %fp,#-4
4628c: 2f03 movel %d3,%sp@-
4628e: 2f02 movel %d2,%sp@-
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
46290: 486e fffc pea %fp@(-4)
46294: 2f2e 0008 movel %fp@(8),%sp@-
46298: 2f39 0006 0cae movel 60cae <RTEMS_Malloc_Heap>,%sp@-
4629e: 4eb9 0004 b468 jsr 4b468 <_Protected_heap_Get_block_size>
462a4: 4fef 000c lea %sp@(12),%sp
462a8: 4a00 tstb %d0
462aa: 671a beqs 462c6 <rtems_malloc_statistics_at_free+0x3e><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
462ac: 262e fffc movel %fp@(-4),%d3
462b0: 4282 clrl %d2
462b2: d7b9 0006 2cf4 addl %d3,62cf4 <rtems_malloc_statistics+0x28>
462b8: 2039 0006 2cf0 movel 62cf0 <rtems_malloc_statistics+0x24>,%d0
462be: d182 addxl %d2,%d0
462c0: 23c0 0006 2cf0 movel %d0,62cf0 <rtems_malloc_statistics+0x24>
}
}
462c6: 242e fff4 movel %fp@(-12),%d2
462ca: 262e fff8 movel %fp@(-8),%d3
462ce: 4e5e unlk %fp <== NOT EXECUTED
000462d2 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
462d2: 4e56 fffc linkw %fp,#-4
462d6: 202e 0008 movel %fp@(8),%d0
462da: 2f03 movel %d3,%sp@-
uintptr_t actual_size = 0;
462dc: 42ae fffc clrl %fp@(-4)
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
462e0: 2f02 movel %d2,%sp@-
uintptr_t actual_size = 0;
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
462e2: 4a80 tstl %d0
462e4: 674c beqs 46332 <rtems_malloc_statistics_at_malloc+0x60><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
462e6: 486e fffc pea %fp@(-4)
MSBUMP(lifetime_allocated, actual_size);
462ea: 4282 clrl %d2
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
462ec: 2f00 movel %d0,%sp@-
462ee: 2f39 0006 0cae movel 60cae <RTEMS_Malloc_Heap>,%sp@-
462f4: 4eb9 0004 b468 jsr 4b468 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
462fa: 262e fffc movel %fp@(-4),%d3
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
462fe: 4fef 000c lea %sp@(12),%sp
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
46302: 2039 0006 2ce8 movel 62ce8 <rtems_malloc_statistics+0x1c>,%d0
46308: d6b9 0006 2cec addl 62cec <rtems_malloc_statistics+0x20>,%d3
4630e: d580 addxl %d0,%d2
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
46310: 2003 movel %d3,%d0
46312: 90b9 0006 2cf4 subl 62cf4 <rtems_malloc_statistics+0x28>,%d0
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
46318: 23c2 0006 2ce8 movel %d2,62ce8 <rtems_malloc_statistics+0x1c>
4631e: 23c3 0006 2cec movel %d3,62cec <rtems_malloc_statistics+0x20>
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
46324: b0b9 0006 2ce4 cmpl 62ce4 <rtems_malloc_statistics+0x18>,%d0
4632a: 6306 blss 46332 <rtems_malloc_statistics_at_malloc+0x60>
s->max_depth = current_depth;
4632c: 23c0 0006 2ce4 movel %d0,62ce4 <rtems_malloc_statistics+0x18>
}
46332: 242e fff4 movel %fp@(-12),%d2
46336: 262e fff8 movel %fp@(-8),%d3
4633a: 4e5e unlk %fp <== NOT EXECUTED
0004d49c <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
4d49c: 4e56 0000 linkw %fp,#0
4d4a0: 2f0a movel %a2,%sp@-
4d4a2: 246e 0008 moveal %fp@(8),%a2
4d4a6: 2f02 movel %d2,%sp@-
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
4d4a8: 4a8a tstl %a2
4d4aa: 6754 beqs 4d500 <rtems_memalign+0x64>
return EINVAL;
*pointer = NULL;
4d4ac: 4292 clrl %a2@
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
4d4ae: 7003 moveq #3,%d0
4d4b0: b0b9 0006 0d80 cmpl 60d80 <_System_state_Current>,%d0
4d4b6: 660a bnes 4d4c2 <rtems_memalign+0x26> <== NEVER TAKEN
!malloc_is_system_state_OK() )
4d4b8: 4eb9 0004 37d4 jsr 437d4 <malloc_is_system_state_OK>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
4d4be: 4a00 tstb %d0
4d4c0: 673e beqs 4d500 <rtems_memalign+0x64> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
4d4c2: 4eb9 0004 3812 jsr 43812 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
4d4c8: 42a7 clrl %sp@-
4d4ca: 2f2e 000c movel %fp@(12),%sp@-
4d4ce: 2f2e 0010 movel %fp@(16),%sp@-
4d4d2: 2f39 0005 f2f2 movel 5f2f2 <RTEMS_Malloc_Heap>,%sp@-
4d4d8: 4eb9 0004 80dc jsr 480dc <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
4d4de: 4fef 0010 lea %sp@(16),%sp
4d4e2: 2400 movel %d0,%d2
4d4e4: 671e beqs 4d504 <rtems_memalign+0x68>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
4d4e6: 2079 0005 fa28 moveal 5fa28 <rtems_malloc_statistics_helpers>,%a0
4d4ec: 4a88 tstl %a0
4d4ee: 670a beqs 4d4fa <rtems_memalign+0x5e>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
4d4f0: 2f0a movel %a2,%sp@-
4d4f2: 2068 0004 moveal %a0@(4),%a0
4d4f6: 4e90 jsr %a0@
4d4f8: 588f addql #4,%sp
*pointer = return_this;
4d4fa: 2482 movel %d2,%a2@
return 0;
4d4fc: 4280 clrl %d0
4d4fe: 6006 bras 4d506 <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;
4d500: 7016 moveq #22,%d0
4d502: 6002 bras 4d506 <rtems_memalign+0x6a>
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
4d504: 700c moveq #12,%d0
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
4d506: 242e fff8 movel %fp@(-8),%d2
4d50a: 246e fffc moveal %fp@(-4),%a2
4d50e: 4e5e unlk %fp
...
0004af50 <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
4af50: 4e56 fffc linkw %fp,#-4
4af54: 2f0a movel %a2,%sp@-
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
4af56: 486e fffc pea %fp@(-4)
4af5a: 2f2e 0008 movel %fp@(8),%sp@-
4af5e: 4879 0005 fb94 pea 5fb94 <_Message_queue_Information>
4af64: 4eb9 0004 7a20 jsr 47a20 <_Objects_Get>
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
4af6a: 4fef 000c lea %sp@(12),%sp
4af6e: 2440 moveal %d0,%a2
4af70: 4aae fffc tstl %fp@(-4)
4af74: 663a bnes 4afb0 <rtems_message_queue_delete+0x60><== NEVER TAKEN
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
4af76: 2f00 movel %d0,%sp@-
4af78: 4879 0005 fb94 pea 5fb94 <_Message_queue_Information>
4af7e: 4eb9 0004 763c jsr 4763c <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
4af84: 4878 0005 pea 5 <COMPARE>
4af88: 42a7 clrl %sp@-
4af8a: 486a 0014 pea %a2@(20)
4af8e: 4eb9 0004 b4d0 jsr 4b4d0 <_CORE_message_queue_Close>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
4af94: 2f0a movel %a2,%sp@-
4af96: 4879 0005 fb94 pea 5fb94 <_Message_queue_Information>
4af9c: 4eb9 0004 78bc jsr 478bc <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
4afa2: 4eb9 0004 85d4 jsr 485d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4afa8: 4fef 001c lea %sp@(28),%sp
4afac: 4280 clrl %d0
4afae: 6002 bras 4afb2 <rtems_message_queue_delete+0x62>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4afb0: 7004 moveq #4,%d0
}
4afb2: 246e fff8 moveal %fp@(-8),%a2
4afb6: 4e5e unlk %fp
...
0004bcb8 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
4bcb8: 4e56 ff90 linkw %fp,#-112
4bcbc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int success = 0;
char *dup_path = strdup(path);
4bcc0: 2f2e 0008 movel %fp@(8),%sp@-
4bcc4: 4eb9 0004 e15c jsr 4e15c <strdup>
if (dup_path != NULL) {
4bcca: 588f addql #4,%sp
int
rtems_mkdir(const char *path, mode_t mode)
{
int success = 0;
char *dup_path = strdup(path);
4bccc: 2440 moveal %d0,%a2
if (dup_path != NULL) {
4bcce: 4a80 tstl %d0
4bcd0: 6700 0134 beqw 4be06 <rtems_mkdir+0x14e>
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bcd4: 722f moveq #47,%d1
4bcd6: 1012 moveb %a2@,%d0
4bcd8: 49c0 extbl %d0
4bcda: b280 cmpl %d0,%d1
4bcdc: 6606 bnes 4bce4 <rtems_mkdir+0x2c>
++p;
4bcde: 47ea 0001 lea %a2@(1),%a3
4bce2: 6002 bras 4bce6 <rtems_mkdir+0x2e>
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bce4: 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) {
4bce6: 2c0e movel %fp,%d6
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4bce8: 7601 moveq #1,%d3
4bcea: 4284 clrl %d4
4bcec: 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) {
4bcee: 2e3c 0004 3f8c movel #278412,%d7
if (errno == EEXIST || errno == EISDIR) {
4bcf4: 4bf9 0004 d240 lea 4d240 <__errno>,%a5
if (stat(path, &sb) < 0) {
4bcfa: 0686 ffff ffba addil #-70,%d6
4bd00: 2a3c 0004 be18 movel #310808,%d5
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
4bd06: 49f9 0004 bebc lea 4bebc <umask>,%a4
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
4bd0c: 1213 moveb %a3@,%d1
4bd0e: 670e beqs 4bd1e <rtems_mkdir+0x66>
last = 1;
else if (p[0] != '/')
4bd10: 49c1 extbl %d1
4bd12: 742f moveq #47,%d2
4bd14: b481 cmpl %d1,%d2
4bd16: 6600 00bc bnew 4bdd4 <rtems_mkdir+0x11c>
4bd1a: 4281 clrl %d1
4bd1c: 6002 bras 4bd20 <rtems_mkdir+0x68>
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
4bd1e: 7201 moveq #1,%d1
else if (p[0] != '/')
continue;
*p = '\0';
4bd20: 4213 clrb %a3@
if (!last && p[1] == '\0')
4bd22: 4a81 tstl %d1
4bd24: 660c bnes 4bd32 <rtems_mkdir+0x7a>
4bd26: 4a2b 0001 tstb %a3@(1)
4bd2a: 57c2 seq %d2
4bd2c: 49c2 extbl %d2
4bd2e: 4482 negl %d2
4bd30: 6002 bras 4bd34 <rtems_mkdir+0x7c>
4bd32: 7401 moveq #1,%d2
last = 1;
if (first) {
4bd34: 4a80 tstl %d0
4bd36: 6712 beqs 4bd4a <rtems_mkdir+0x92>
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
4bd38: 42a7 clrl %sp@-
4bd3a: 4e94 jsr %a4@
4bd3c: 2800 movel %d0,%d4
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
4bd3e: 0280 ffff ff3f andil #-193,%d0
4bd44: 2f00 movel %d0,%sp@-
4bd46: 4e94 jsr %a4@
4bd48: 508f addql #8,%sp
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bd4a: 203c 0000 01ff movel #511,%d0
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
4bd50: 4a82 tstl %d2
4bd52: 670a beqs 4bd5e <rtems_mkdir+0xa6>
(void)umask(oumask);
4bd54: 2f04 movel %d4,%sp@-
4bd56: 4e94 jsr %a4@
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bd58: 202e 000c movel %fp@(12),%d0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
4bd5c: 588f addql #4,%sp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4bd5e: 2f00 movel %d0,%sp@-
4bd60: 2047 moveal %d7,%a0
4bd62: 2f0a movel %a2,%sp@-
4bd64: 4e90 jsr %a0@
4bd66: 508f addql #8,%sp
4bd68: 4a80 tstl %d0
4bd6a: 6c5c bges 4bdc8 <rtems_mkdir+0x110>
if (errno == EEXIST || errno == EISDIR) {
4bd6c: 4e95 jsr %a5@
4bd6e: 7211 moveq #17,%d1
4bd70: 2040 moveal %d0,%a0
4bd72: b290 cmpl %a0@,%d1
4bd74: 670c beqs 4bd82 <rtems_mkdir+0xca>
4bd76: 4e95 jsr %a5@
4bd78: 7215 moveq #21,%d1
4bd7a: 2040 moveal %d0,%a0
4bd7c: b290 cmpl %a0@,%d1
4bd7e: 6600 0092 bnew 4be12 <rtems_mkdir+0x15a>
if (stat(path, &sb) < 0) {
4bd82: 2f06 movel %d6,%sp@-
4bd84: 2045 moveal %d5,%a0
4bd86: 2f0a movel %a2,%sp@-
4bd88: 4e90 jsr %a0@
4bd8a: 508f addql #8,%sp
4bd8c: 4a80 tstl %d0
4bd8e: 6d00 0082 bltw 4be12 <rtems_mkdir+0x15a>
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
4bd92: 202e ffc6 movel %fp@(-58),%d0
4bd96: 0280 0000 f000 andil #61440,%d0
4bd9c: 0c80 0000 4000 cmpil #16384,%d0
4bda2: 671e beqs 4bdc2 <rtems_mkdir+0x10a>
4bda4: 41f9 0004 d240 lea 4d240 <__errno>,%a0
if (last)
4bdaa: 4a82 tstl %d2
4bdac: 670a beqs 4bdb8 <rtems_mkdir+0x100>
errno = EEXIST;
4bdae: 4e90 jsr %a0@
4bdb0: 7211 moveq #17,%d1
4bdb2: 2040 moveal %d0,%a0
4bdb4: 2081 movel %d1,%a0@
4bdb6: 603a bras 4bdf2 <rtems_mkdir+0x13a>
else
errno = ENOTDIR;
4bdb8: 4e90 jsr %a0@
4bdba: 2040 moveal %d0,%a0
4bdbc: 7014 moveq #20,%d0
4bdbe: 2080 movel %d0,%a0@
4bdc0: 6026 bras 4bde8 <rtems_mkdir+0x130>
retval = 0;
break;
}
if (last)
4bdc2: 4a82 tstl %d2
4bdc4: 6612 bnes 4bdd8 <rtems_mkdir+0x120>
4bdc6: 6004 bras 4bdcc <rtems_mkdir+0x114>
} else {
retval = 0;
break;
}
}
if (!last)
4bdc8: 4a82 tstl %d2
4bdca: 660e bnes 4bdda <rtems_mkdir+0x122>
*p = '/';
4bdcc: 4281 clrl %d1
4bdce: 16bc 002f moveb #47,%a3@
4bdd2: 6008 bras 4bddc <rtems_mkdir+0x124>
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
4bdd4: 4281 clrl %d1
4bdd6: 6006 bras 4bdde <rtems_mkdir+0x126>
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
4bdd8: 7602 moveq #2,%d3
} else {
retval = 0;
break;
}
}
if (!last)
4bdda: 7201 moveq #1,%d1
4bddc: 4280 clrl %d0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
4bdde: 528b addql #1,%a3
4bde0: 4a81 tstl %d1
4bde2: 6700 ff28 beqw 4bd0c <rtems_mkdir+0x54>
4bde6: 600c bras 4bdf4 <rtems_mkdir+0x13c>
}
if (!last)
*p = '/';
}
if (!first && !last)
(void)umask(oumask);
4bde8: 2f04 movel %d4,%sp@-
4bdea: 4eb9 0004 bebc jsr 4bebc <umask>
4bdf0: 588f addql #4,%sp
4bdf2: 4283 clrl %d3
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
4bdf4: 2f0a movel %a2,%sp@-
4bdf6: 4eb9 0004 399c jsr 4399c <free>
}
return success != 0 ? 0 : -1;
4bdfc: 588f addql #4,%sp
4bdfe: 4a83 tstl %d3
4be00: 57c0 seq %d0
4be02: 49c0 extbl %d0
4be04: 6002 bras 4be08 <rtems_mkdir+0x150>
4be06: 70ff moveq #-1,%d0 <== NOT EXECUTED
}
4be08: 4cee 3cfc ff90 moveml %fp@(-112),%d2-%d7/%a2-%a5
4be0e: 4e5e unlk %fp
4be10: 4e75 rts
}
}
if (!last)
*p = '/';
}
if (!first && !last)
4be12: 4a82 tstl %d2
4be14: 67d2 beqs 4bde8 <rtems_mkdir+0x130> <== NEVER TAKEN
4be16: 60da bras 4bdf2 <rtems_mkdir+0x13a>
0004f7dc <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
rtems_id id,
void **buffer
)
{
4f7dc: 4e56 fff0 linkw %fp,#-16
4f7e0: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
4f7e4: 266e 000c moveal %fp@(12),%a3
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
4f7e8: 4a8b tstl %a3
4f7ea: 6748 beqs 4f834 <rtems_partition_get_buffer+0x58><== NEVER TAKEN
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
4f7ec: 486e fffc pea %fp@(-4)
4f7f0: 2f2e 0008 movel %fp@(8),%sp@-
4f7f4: 4879 0007 5504 pea 75504 <_Partition_Information>
4f7fa: 4eb9 0005 3d18 jsr 53d18 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
4f800: 4fef 000c lea %sp@(12),%sp
4f804: 2440 moveal %d0,%a2
4f806: 4aae fffc tstl %fp@(-4)
4f80a: 662c bnes 4f838 <rtems_partition_get_buffer+0x5c>
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
4f80c: 486a 0024 pea %a2@(36)
4f810: 4eb9 0005 2468 jsr 52468 <_Chain_Get>
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
4f816: 588f addql #4,%sp
4f818: 41f9 0005 4940 lea 54940 <_Thread_Enable_dispatch>,%a0
4f81e: 2400 movel %d0,%d2
4f820: 670c beqs 4f82e <rtems_partition_get_buffer+0x52>
the_partition->number_of_used_blocks += 1;
4f822: 52aa 0020 addql #1,%a2@(32)
_Thread_Enable_dispatch();
4f826: 4e90 jsr %a0@
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
4f828: 4280 clrl %d0
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
4f82a: 2682 movel %d2,%a3@
return RTEMS_SUCCESSFUL;
4f82c: 600c bras 4f83a <rtems_partition_get_buffer+0x5e>
}
_Thread_Enable_dispatch();
4f82e: 4e90 jsr %a0@
return RTEMS_UNSATISFIED;
4f830: 700d moveq #13,%d0
4f832: 6006 bras 4f83a <rtems_partition_get_buffer+0x5e>
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
4f834: 7009 moveq #9,%d0
4f836: 6002 bras 4f83a <rtems_partition_get_buffer+0x5e>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4f838: 7004 moveq #4,%d0
}
4f83a: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4f840: 4e5e unlk %fp <== NOT EXECUTED
0004f870 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
4f870: 4e56 fffc linkw %fp,#-4
4f874: 2f0a movel %a2,%sp@-
4f876: 2f02 movel %d2,%sp@-
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
4f878: 486e fffc pea %fp@(-4)
4f87c: 2f2e 0008 movel %fp@(8),%sp@-
4f880: 4879 0007 5504 pea 75504 <_Partition_Information>
4f886: 242e 000c movel %fp@(12),%d2
4f88a: 4eb9 0005 3d18 jsr 53d18 <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
4f890: 4fef 000c lea %sp@(12),%sp
4f894: 2440 moveal %d0,%a2
4f896: 4aae fffc tstl %fp@(-4)
4f89a: 663e bnes 4f8da <rtems_partition_return_buffer+0x6a>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
4f89c: 202a 0010 movel %a2@(16),%d0
ending = _Addresses_Add_offset( starting, the_partition->length );
4f8a0: 222a 0014 movel %a2@(20),%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
4f8a4: b082 cmpl %d2,%d0
4f8a6: 6240 bhis 4f8e8 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
4f8a8: d280 addl %d0,%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
4f8aa: b282 cmpl %d2,%d1
4f8ac: 653a bcss 4f8e8 <rtems_partition_return_buffer+0x78><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
4f8ae: 2202 movel %d2,%d1
4f8b0: 9280 subl %d0,%d1
4f8b2: 2001 movel %d1,%d0
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
4f8b4: 4c6a 0001 0018 remul %a2@(24),%d1,%d0
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
4f8ba: 4a81 tstl %d1
4f8bc: 662a bnes 4f8e8 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
4f8be: 2f02 movel %d2,%sp@-
4f8c0: 486a 0024 pea %a2@(36)
4f8c4: 4eb9 0005 2408 jsr 52408 <_Chain_Append>
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
4f8ca: 53aa 0020 subql #1,%a2@(32)
_Thread_Enable_dispatch();
4f8ce: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4f8d4: 508f addql #8,%sp
4f8d6: 4280 clrl %d0
4f8d8: 6002 bras 4f8dc <rtems_partition_return_buffer+0x6c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4f8da: 7004 moveq #4,%d0
}
4f8dc: 242e fff4 movel %fp@(-12),%d2
4f8e0: 246e fff8 moveal %fp@(-8),%a2
4f8e4: 4e5e unlk %fp
4f8e6: 4e75 rts
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
4f8e8: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
4f8ee: 7009 moveq #9,%d0
4f8f0: 60ea bras 4f8dc <rtems_partition_return_buffer+0x6c>
...
0004b79c <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
4b79c: 4e56 fffc linkw %fp,#-4
4b7a0: 2f0a movel %a2,%sp@-
4b7a2: 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 )
4b7a6: 4a8a tstl %a2
4b7a8: 6700 0096 beqw 4b840 <rtems_rate_monotonic_get_statistics+0xa4>
4b7ac: 486e fffc pea %fp@(-4)
4b7b0: 2f2e 0008 movel %fp@(8),%sp@-
4b7b4: 4879 0005 f130 pea 5f130 <_Rate_monotonic_Information>
4b7ba: 4eb9 0004 8510 jsr 48510 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
4b7c0: 4fef 000c lea %sp@(12),%sp
4b7c4: 2040 moveal %d0,%a0
4b7c6: 4aae fffc tstl %fp@(-4)
4b7ca: 6678 bnes 4b844 <rtems_rate_monotonic_get_statistics+0xa8><== NEVER TAKEN
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
4b7cc: 24a8 0054 movel %a0@(84),%a2@
dst->missed_count = src->missed_count;
4b7d0: 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 );
4b7d6: 2028 005c movel %a0@(92),%d0
4b7da: 2228 0060 movel %a0@(96),%d1
4b7de: 2540 0008 movel %d0,%a2@(8)
4b7e2: 2541 000c movel %d1,%a2@(12)
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
4b7e6: 2028 0064 movel %a0@(100),%d0
4b7ea: 2228 0068 movel %a0@(104),%d1
4b7ee: 2540 0010 movel %d0,%a2@(16)
4b7f2: 2541 0014 movel %d1,%a2@(20)
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
4b7f6: 2028 006c movel %a0@(108),%d0
4b7fa: 2228 0070 movel %a0@(112),%d1
4b7fe: 2540 0018 movel %d0,%a2@(24)
4b802: 2541 001c movel %d1,%a2@(28)
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
4b806: 2028 0074 movel %a0@(116),%d0
4b80a: 2228 0078 movel %a0@(120),%d1
4b80e: 2540 0020 movel %d0,%a2@(32)
4b812: 2541 0024 movel %d1,%a2@(36)
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
4b816: 2028 007c movel %a0@(124),%d0
4b81a: 2228 0080 movel %a0@(128),%d1
4b81e: 2540 0028 movel %d0,%a2@(40)
4b822: 2541 002c movel %d1,%a2@(44)
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
4b826: 2028 0084 movel %a0@(132),%d0
4b82a: 2228 0088 movel %a0@(136),%d1
4b82e: 2540 0030 movel %d0,%a2@(48)
4b832: 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();
4b836: 4eb9 0004 9138 jsr 49138 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4b83c: 4280 clrl %d0
4b83e: 6006 bras 4b846 <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;
4b840: 7009 moveq #9,%d0
4b842: 6002 bras 4b846 <rtems_rate_monotonic_get_statistics+0xaa>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4b844: 7004 moveq #4,%d0
}
4b846: 246e fff8 moveal %fp@(-8),%a2
4b84a: 4e5e unlk %fp
...
00046552 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
46552: 4e56 ffec linkw %fp,#-20
46556: 48d7 041c moveml %d2-%d4/%a2,%sp@
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
4655a: 486e fffc pea %fp@(-4)
4655e: 262e 0008 movel %fp@(8),%d3
46562: 2f03 movel %d3,%sp@-
46564: 4879 0005 f130 pea 5f130 <_Rate_monotonic_Information>
4656a: 242e 000c movel %fp@(12),%d2
4656e: 4eb9 0004 8510 jsr 48510 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
46574: 4fef 000c lea %sp@(12),%sp
46578: 2440 moveal %d0,%a2
4657a: 4aae fffc tstl %fp@(-4)
4657e: 6600 015a bnew 466da <rtems_rate_monotonic_period+0x188>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
46582: 2039 0005 f3b4 movel 5f3b4 <_Per_CPU_Information+0xc>,%d0
46588: b0aa 0040 cmpl %a2@(64),%d0
4658c: 670c beqs 4659a <rtems_rate_monotonic_period+0x48>
_Thread_Enable_dispatch();
4658e: 4eb9 0004 9138 jsr 49138 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
46594: 7417 moveq #23,%d2
46596: 6000 0144 braw 466dc <rtems_rate_monotonic_period+0x18a>
}
if ( length == RTEMS_PERIOD_STATUS ) {
4659a: 4a82 tstl %d2
4659c: 6624 bnes 465c2 <rtems_rate_monotonic_period+0x70>
switch ( the_period->state ) {
4659e: 202a 0038 movel %a2@(56),%d0
465a2: 7204 moveq #4,%d1
465a4: b280 cmpl %d0,%d1
465a6: 650e bcss 465b6 <rtems_rate_monotonic_period+0x64><== NEVER TAKEN
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
465a8: 41f9 0005 c9ca lea 5c9ca <CSWTCH.2>,%a0
465ae: 4282 clrl %d2
465b0: 1430 0800 moveb %a0@(00000000,%d0:l),%d2
465b4: 6002 bras 465b8 <rtems_rate_monotonic_period+0x66>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
465b6: 4282 clrl %d2 <== NOT EXECUTED
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
465b8: 4eb9 0004 9138 jsr 49138 <_Thread_Enable_dispatch>
return( return_value );
465be: 6000 011c braw 466dc <rtems_rate_monotonic_period+0x18a>
}
_ISR_Disable( level );
465c2: 203c 0000 0700 movel #1792,%d0
465c8: 40c4 movew %sr,%d4
465ca: 8084 orl %d4,%d0
465cc: 46c0 movew %d0,%sr
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
465ce: 202a 0038 movel %a2@(56),%d0
465d2: 664a bnes 4661e <rtems_rate_monotonic_period+0xcc>
_ISR_Enable( level );
465d4: 46c4 movew %d4,%sr
the_period->next_length = length;
465d6: 2542 003c movel %d2,%a2@(60)
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
465da: 2f0a movel %a2,%sp@-
465dc: 4eb9 0004 63d6 jsr 463d6 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
465e2: 7002 moveq #2,%d0
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
465e4: 223c 0004 692c movel #289068,%d1
465ea: 2540 0038 movel %d0,%a2@(56)
465ee: 2541 002c movel %d1,%a2@(44)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
465f2: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine;
the_watchdog->id = id;
465f6: 2543 0030 movel %d3,%a2@(48)
the_watchdog->user_data = user_data;
465fa: 42aa 0034 clrl %a2@(52)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
465fe: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
46602: 486a 0010 pea %a2@(16)
46606: 4879 0005 f2d8 pea 5f2d8 <_Watchdog_Ticks_chain>
4660c: 4eb9 0004 9e04 jsr 49e04 <_Watchdog_Insert>
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
46612: 4eb9 0004 9138 jsr 49138 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
46618: 4fef 000c lea %sp@(12),%sp
4661c: 606c bras 4668a <rtems_rate_monotonic_period+0x138>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
4661e: 7202 moveq #2,%d1
46620: b280 cmpl %d0,%d1
46622: 666a bnes 4668e <rtems_rate_monotonic_period+0x13c>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
46624: 2f0a movel %a2,%sp@-
46626: 4eb9 0004 6460 jsr 46460 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
4662c: 7001 moveq #1,%d0
the_period->next_length = length;
4662e: 2542 003c movel %d2,%a2@(60)
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
46632: 2540 0038 movel %d0,%a2@(56)
the_period->next_length = length;
_ISR_Enable( level );
46636: 46c4 movew %d4,%sr
_Thread_Executing->Wait.id = the_period->Object.id;
46638: 2079 0005 f3b4 moveal 5f3b4 <_Per_CPU_Information+0xc>,%a0
4663e: 216a 0008 0020 movel %a2@(8),%a0@(32)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
46644: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
46648: 2f08 movel %a0,%sp@-
4664a: 4eb9 0004 9890 jsr 49890 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
46650: 203c 0000 0700 movel #1792,%d0
46656: 40c1 movew %sr,%d1
46658: 8081 orl %d1,%d0
4665a: 46c0 movew %d0,%sr
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
4665c: 7402 moveq #2,%d2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
4665e: 202a 0038 movel %a2@(56),%d0
the_period->state = RATE_MONOTONIC_ACTIVE;
46662: 2542 0038 movel %d2,%a2@(56)
_ISR_Enable( level );
46666: 46c1 movew %d1,%sr
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
46668: 7203 moveq #3,%d1
4666a: 4fef 000c lea %sp@(12),%sp
4666e: b280 cmpl %d0,%d1
46670: 6612 bnes 46684 <rtems_rate_monotonic_period+0x132>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
46672: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
46676: 2f39 0005 f3b4 movel 5f3b4 <_Per_CPU_Information+0xc>,%sp@-
4667c: 4eb9 0004 8dc4 jsr 48dc4 <_Thread_Clear_state>
46682: 508f addql #8,%sp
_Thread_Enable_dispatch();
46684: 4eb9 0004 9138 jsr 49138 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4668a: 4282 clrl %d2
4668c: 604e bras 466dc <rtems_rate_monotonic_period+0x18a>
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
4668e: 7204 moveq #4,%d1
46690: b280 cmpl %d0,%d1
46692: 6646 bnes 466da <rtems_rate_monotonic_period+0x188><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
46694: 2f0a movel %a2,%sp@-
46696: 4eb9 0004 6460 jsr 46460 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
4669c: 46c4 movew %d4,%sr
the_period->state = RATE_MONOTONIC_ACTIVE;
4669e: 7002 moveq #2,%d0
the_period->next_length = length;
466a0: 2542 003c movel %d2,%a2@(60)
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
466a4: 2540 0038 movel %d0,%a2@(56)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
466a8: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
466ac: 486a 0010 pea %a2@(16)
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
466b0: 7406 moveq #6,%d2
466b2: 4879 0005 f2d8 pea 5f2d8 <_Watchdog_Ticks_chain>
466b8: 4eb9 0004 9e04 jsr 49e04 <_Watchdog_Insert>
466be: 2f2a 003c movel %a2@(60),%sp@-
466c2: 2f2a 0040 movel %a2@(64),%sp@-
466c6: 2079 0005 d8f2 moveal 5d8f2 <_Scheduler+0x34>,%a0
466cc: 4e90 jsr %a0@
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
466ce: 4eb9 0004 9138 jsr 49138 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
466d4: 4fef 0014 lea %sp@(20),%sp
466d8: 6002 bras 466dc <rtems_rate_monotonic_period+0x18a>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
466da: 7404 moveq #4,%d2
}
466dc: 2002 movel %d2,%d0
466de: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
466e4: 4e5e unlk %fp <== NOT EXECUTED
0004687c <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
4687c: 4e56 0000 linkw %fp,#0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
46880: 2039 0005 f220 movel 5f220 <_Thread_Dispatch_disable_level>,%d0
46886: 5280 addql #1,%d0
46888: 2f0a movel %a2,%sp@-
4688a: 23c0 0005 f220 movel %d0,5f220 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
46890: 2039 0005 f220 movel 5f220 <_Thread_Dispatch_disable_level>,%d0
46896: 2f02 movel %d2,%sp@-
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
46898: 2439 0005 f136 movel 5f136 <_Rate_monotonic_Information+0x6>,%d2
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
4689e: 45f9 0004 68c8 lea 468c8 <rtems_rate_monotonic_reset_statistics>,%a2
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
468a4: 6008 bras 468ae <rtems_rate_monotonic_reset_all_statistics+0x32>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
468a6: 2f02 movel %d2,%sp@-
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
468a8: 5282 addql #1,%d2
(void) rtems_rate_monotonic_reset_statistics( id );
468aa: 4e92 jsr %a2@
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
468ac: 588f addql #4,%sp
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
468ae: b4b9 0005 f13a cmpl 5f13a <_Rate_monotonic_Information+0xa>,%d2
468b4: 63f0 blss 468a6 <rtems_rate_monotonic_reset_all_statistics+0x2a>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
468b6: 242e fff8 movel %fp@(-8),%d2
468ba: 246e fffc moveal %fp@(-4),%a2
468be: 4e5e unlk %fp
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
468c0: 4ef9 0004 9138 jmp 49138 <_Thread_Enable_dispatch>
...
000504a8 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
504a8: 4e56 fffc linkw %fp,#-4
504ac: 2f03 movel %d3,%sp@-
504ae: 262e 0010 movel %fp@(16),%d3
504b2: 2f02 movel %d2,%sp@-
504b4: 242e 000c movel %fp@(12),%d2
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
504b8: 6768 beqs 50522 <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
if ( !size )
504ba: 4a83 tstl %d3
504bc: 6764 beqs 50522 <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
504be: 2f39 0007 5704 movel 75704 <_RTEMS_Allocator_Mutex>,%sp@-
504c4: 4eb9 0005 2370 jsr 52370 <_API_Mutex_Lock>
504ca: 486e fffc pea %fp@(-4)
504ce: 2f2e 0008 movel %fp@(8),%sp@-
504d2: 4879 0007 5574 pea 75574 <_Region_Information>
504d8: 4eb9 0005 3ce0 jsr 53ce0 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
504de: 222e fffc movel %fp@(-4),%d1
504e2: 4fef 0010 lea %sp@(16),%sp
504e6: 6708 beqs 504f0 <rtems_region_get_segment_size+0x48>
504e8: 7001 moveq #1,%d0
504ea: b081 cmpl %d1,%d0
504ec: 661a bnes 50508 <rtems_region_get_segment_size+0x60><== NEVER TAKEN
504ee: 601c bras 5050c <rtems_region_get_segment_size+0x64>
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
504f0: 2f03 movel %d3,%sp@-
504f2: 2040 moveal %d0,%a0
504f4: 2f02 movel %d2,%sp@-
504f6: 4868 0068 pea %a0@(104)
504fa: 4eb9 0005 374c jsr 5374c <_Heap_Size_of_alloc_area>
50500: 4fef 000c lea %sp@(12),%sp
50504: 4a00 tstb %d0
50506: 6708 beqs 50510 <rtems_region_get_segment_size+0x68><== NEVER TAKEN
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
50508: 4282 clrl %d2
5050a: 6006 bras 50512 <rtems_region_get_segment_size+0x6a>
case OBJECTS_REMOTE: /* this error cannot be returned */
break;
#endif
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
5050c: 7404 moveq #4,%d2
5050e: 6002 bras 50512 <rtems_region_get_segment_size+0x6a>
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
return_status = RTEMS_INVALID_ADDRESS;
50510: 7409 moveq #9,%d2 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
50512: 2f39 0007 5704 movel 75704 <_RTEMS_Allocator_Mutex>,%sp@-
50518: 4eb9 0005 23d0 jsr 523d0 <_API_Mutex_Unlock>
return return_status;
5051e: 588f addql #4,%sp
50520: 6002 bras 50524 <rtems_region_get_segment_size+0x7c>
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
50522: 7409 moveq #9,%d2
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
50524: 2002 movel %d2,%d0
50526: 242e fff4 movel %fp@(-12),%d2
5052a: 262e fff8 movel %fp@(-8),%d3
5052e: 4e5e unlk %fp
...
00054b40 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
54b40: 4e56 ffdc linkw %fp,#-36
54b44: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
54b48: 486e fffc pea %fp@(-4)
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
54b4c: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
54b50: 2f0a movel %a2,%sp@-
54b52: 4eba fb20 jsr %pc@(54674 <rtems_rfs_bitmap_load_map>)
if (rc > 0)
54b56: 508f addql #8,%sp
54b58: 4a80 tstl %d0
54b5a: 6e70 bgts 54bcc <rtems_rfs_bitmap_create_search+0x8c><== NEVER TAKEN
return rc;
control->free = 0;
54b5c: 42aa 0010 clrl %a2@(16)
search_map = control->search_bits;
54b60: 286a 0014 moveal %a2@(20),%a4
size = control->size;
54b64: 242a 000c movel %a2@(12),%d2
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
54b68: 76ff moveq #-1,%d3
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
{
bits = rtems_rfs_bitmap_merge (*map,
54b6a: 4bf9 0005 4868 lea 54868 <rtems_rfs_bitmap_mask_section>,%a5
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
54b70: 7801 moveq #1,%d4
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
54b72: 2883 movel %d3,%a4@
54b74: 266e fffc moveal %fp@(-4),%a3
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
54b78: 4283 clrl %d3
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
54b7a: 604a bras 54bc6 <rtems_rfs_bitmap_create_search+0x86>
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
54b7c: 701f moveq #31,%d0
54b7e: b082 cmpl %d2,%d0
54b80: 650e bcss 54b90 <rtems_rfs_bitmap_create_search+0x50>
{
bits = rtems_rfs_bitmap_merge (*map,
54b82: 2f02 movel %d2,%sp@-
54b84: 42a7 clrl %sp@-
54b86: 4e95 jsr %a5@
54b88: 508f addql #8,%sp
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
54b8a: 2042 moveal %d2,%a0
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
54b8c: c093 andl %a3@,%d0
54b8e: 6006 bras 54b96 <rtems_rfs_bitmap_create_search+0x56>
rtems_rfs_bitmap_mask_section (0, size));
available = size;
}
else
{
bits = *map;
54b90: 2013 movel %a3@,%d0
available = rtems_rfs_bitmap_element_bits ();
54b92: 307c 0020 moveaw #32,%a0
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
54b96: 4a80 tstl %d0
54b98: 6714 beqs 54bae <rtems_rfs_bitmap_create_search+0x6e>
54b9a: 4281 clrl %d1
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
54b9c: 2a04 movel %d4,%d5
54b9e: e3ad lsll %d1,%d5
54ba0: ca80 andl %d0,%d5
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
54ba2: 6704 beqs 54ba8 <rtems_rfs_bitmap_create_search+0x68>
control->free++;
54ba4: 52aa 0010 addql #1,%a2@(16)
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
54ba8: 5281 addql #1,%d1
54baa: b1c1 cmpal %d1,%a0
54bac: 6eee bgts 54b9c <rtems_rfs_bitmap_create_search+0x5c>
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
}
size -= available;
54bae: 9488 subl %a0,%d2
if (bit == rtems_rfs_bitmap_element_bits ())
54bb0: 7020 moveq #32,%d0
54bb2: b083 cmpl %d3,%d0
54bb4: 660c bnes 54bc2 <rtems_rfs_bitmap_create_search+0x82><== ALWAYS TAKEN
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
54bb6: 70ff moveq #-1,%d0 <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
54bb8: 4283 clrl %d3 <== NOT EXECUTED
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
54bba: 2940 0004 movel %d0,%a4@(4) <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
54bbe: 588c addql #4,%a4 <== NOT EXECUTED
54bc0: 6002 bras 54bc4 <rtems_rfs_bitmap_create_search+0x84><== NOT EXECUTED
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
54bc2: 5283 addql #1,%d3
54bc4: 588b addql #4,%a3
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
54bc6: 4a82 tstl %d2
54bc8: 66b2 bnes 54b7c <rtems_rfs_bitmap_create_search+0x3c>
else
bit++;
map++;
}
return 0;
54bca: 4280 clrl %d0
}
54bcc: 4cee 3c3c ffdc moveml %fp@(-36),%d2-%d5/%a2-%a5
54bd2: 4e5e unlk %fp <== NOT EXECUTED
00054674 <rtems_rfs_bitmap_load_map>:
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
54674: 4e56 0000 linkw %fp,#0
54678: 2f0b movel %a3,%sp@-
5467a: 266e 000c moveal %fp@(12),%a3
5467e: 2f0a movel %a2,%sp@-
54680: 246e 0008 moveal %fp@(8),%a2
int rc;
if (!control->buffer)
54684: 4a92 tstl %a2@
54686: 672a beqs 546b2 <rtems_rfs_bitmap_load_map+0x3e> <== NEVER TAKEN
return ENXIO;
*map = NULL;
54688: 4293 clrl %a3@
rc = rtems_rfs_buffer_handle_request (control->fs,
5468a: 4878 0001 pea 1 <ADD>
5468e: 2f2a 0008 movel %a2@(8),%sp@-
54692: 2f12 movel %a2@,%sp@-
54694: 2f2a 0004 movel %a2@(4),%sp@-
54698: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
control->buffer,
control->block,
true);
if (rc)
5469e: 4fef 0010 lea %sp@(16),%sp
546a2: 4a80 tstl %d0
546a4: 660e bnes 546b4 <rtems_rfs_bitmap_load_map+0x40> <== NEVER TAKEN
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
546a6: 2052 moveal %a2@,%a0
546a8: 2068 0006 moveal %a0@(6),%a0
546ac: 26a8 001e movel %a0@(30),%a3@
546b0: 6002 bras 546b4 <rtems_rfs_bitmap_load_map+0x40>
rtems_rfs_bitmap_map* map)
{
int rc;
if (!control->buffer)
return ENXIO;
546b2: 7006 moveq #6,%d0 <== NOT EXECUTED
if (rc)
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
return 0;
}
546b4: 246e fff8 moveal %fp@(-8),%a2
546b8: 266e fffc moveal %fp@(-4),%a3
546bc: 4e5e unlk %fp <== NOT EXECUTED
00054aaa <rtems_rfs_bitmap_map_alloc>:
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
54aaa: 4e56 ffe8 linkw %fp,#-24
54aae: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
54ab2: 266e 0010 moveal %fp@(16),%a3
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
54ab6: 4bfa fc08 lea %pc@(546c0 <rtems_rfs_search_map_for_clear_bit.constprop.1>),%a5
* seed up then from the seed down a window number of bits, then repeat the
* process from the window distance from the seed, again above then
* below. Keep moving out until all bits have been searched.
*/
upper_seed = seed;
lower_seed = seed;
54aba: 242e 000c movel %fp@(12),%d2
* of bits from the original seed above then below. That is search from the
* seed up then from the seed down a window number of bits, then repeat the
* process from the window distance from the seed, again above then
* below. Keep moving out until all bits have been searched.
*/
upper_seed = seed;
54abe: 2602 movel %d2,%d3
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
54ac0: 246e 0008 moveal %fp@(8),%a2
54ac4: 286e 0014 moveal %fp@(20),%a4
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
54ac8: 4213 clrb %a3@
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
54aca: 6054 bras 54b20 <rtems_rfs_bitmap_map_alloc+0x76>
|| ((lower_seed >= 0) && (lower_seed < control->size)))
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
54acc: b6aa 000c cmpl %a2@(12),%d3
54ad0: 641a bccs 54aec <rtems_rfs_bitmap_map_alloc+0x42><== NEVER TAKEN
{
*bit = upper_seed;
54ad2: 2883 movel %d3,%a4@
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
54ad4: 4878 0001 pea 1 <ADD>
54ad8: 2f0b movel %a3,%sp@-
54ada: 2f0c movel %a4,%sp@-
54adc: 2f0a movel %a2,%sp@-
54ade: 4e95 jsr %a5@
window, 1);
if ((rc > 0) || *allocated)
54ae0: 4fef 0010 lea %sp@(16),%sp
54ae4: 4a80 tstl %d0
54ae6: 6e4c bgts 54b34 <rtems_rfs_bitmap_map_alloc+0x8a><== NEVER TAKEN
54ae8: 4a13 tstb %a3@
54aea: 6648 bnes 54b34 <rtems_rfs_bitmap_map_alloc+0x8a>
break;
}
if (lower_seed >= 0)
54aec: 4a82 tstl %d2
54aee: 6d1a blts 54b0a <rtems_rfs_bitmap_map_alloc+0x60><== NEVER TAKEN
{
*bit = lower_seed;
54af0: 2882 movel %d2,%a4@
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
54af2: 4878 ffff pea ffffffff <LESS>
54af6: 2f0b movel %a3,%sp@-
54af8: 2f0c movel %a4,%sp@-
54afa: 2f0a movel %a2,%sp@-
54afc: 4e95 jsr %a5@
window, -1);
if ((rc > 0) || *allocated)
54afe: 4fef 0010 lea %sp@(16),%sp
54b02: 4a80 tstl %d0
54b04: 6e2e bgts 54b34 <rtems_rfs_bitmap_map_alloc+0x8a><== NEVER TAKEN
54b06: 4a13 tstb %a3@
54b08: 662a bnes 54b34 <rtems_rfs_bitmap_map_alloc+0x8a><== NEVER TAKEN
/*
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
54b0a: b6aa 000c cmpl %a2@(12),%d3
54b0e: 6406 bccs 54b16 <rtems_rfs_bitmap_map_alloc+0x6c><== NEVER TAKEN
upper_seed += window;
54b10: 0683 0000 0800 addil #2048,%d3
if (lower_seed >= 0)
54b16: 4a82 tstl %d2
54b18: 6d06 blts 54b20 <rtems_rfs_bitmap_map_alloc+0x76><== NEVER TAKEN
lower_seed -= window;
54b1a: 0682 ffff f800 addil #-2048,%d2
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
54b20: 4a83 tstl %d3
54b22: 6d06 blts 54b2a <rtems_rfs_bitmap_map_alloc+0x80><== NEVER TAKEN
54b24: b6aa 000c cmpl %a2@(12),%d3
54b28: 65a2 bcss 54acc <rtems_rfs_bitmap_map_alloc+0x22>
|| ((lower_seed >= 0) && (lower_seed < control->size)))
54b2a: 4a82 tstl %d2
54b2c: 6d06 blts 54b34 <rtems_rfs_bitmap_map_alloc+0x8a>
54b2e: b4aa 000c cmpl %a2@(12),%d2
54b32: 6598 bcss 54acc <rtems_rfs_bitmap_map_alloc+0x22><== NEVER TAKEN
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
54b34: 4280 clrl %d0
54b36: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
54b3c: 4e5e unlk %fp <== NOT EXECUTED
0005490c <rtems_rfs_bitmap_map_clear>:
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
5490c: 4e56 ffec linkw %fp,#-20
54910: 48d7 041c moveml %d2-%d4/%a2,%sp@
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
54914: 486e fffc pea %fp@(-4)
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
54918: 246e 0008 moveal %fp@(8),%a2
5491c: 242e 000c movel %fp@(12),%d2
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
54920: 2f0a movel %a2,%sp@-
54922: 4eba fd50 jsr %pc@(54674 <rtems_rfs_bitmap_load_map>)
if (rc > 0)
54926: 508f addql #8,%sp
54928: 4a80 tstl %d0
5492a: 6e42 bgts 5496e <rtems_rfs_bitmap_map_clear+0x62><== NEVER TAKEN
return rc;
if (bit >= control->size)
5492c: b4aa 000c cmpl %a2@(12),%d2
54930: 643a bccs 5496c <rtems_rfs_bitmap_map_clear+0x60><== NEVER TAKEN
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
54932: 2202 movel %d2,%d1
54934: ea81 asrl #5,%d1
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
54936: 2001 movel %d1,%d0
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
54938: 761f moveq #31,%d3
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
5493a: e588 lsll #2,%d0
5493c: 226e fffc moveal %fp@(-4),%a1
54940: d3c0 addal %d0,%a1
54942: 7001 moveq #1,%d0
54944: 2800 movel %d0,%d4
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
54946: c682 andl %d2,%d3
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
54948: 206a 0014 moveal %a2@(20),%a0
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
5494c: e7ac lsll %d3,%d4
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
5494e: 760a moveq #10,%d3
54950: e6a2 asrl %d3,%d2
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_clear (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
54952: 8991 orl %d4,%a1@
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
54954: 781f moveq #31,%d4
54956: c284 andl %d4,%d1
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
54958: e3a8 lsll %d1,%d0
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_clear (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
5495a: 81b0 2c00 orl %d0,%a0@(00000000,%d2:l:4)
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
5495e: 2052 moveal %a2@,%a0
control->free++;
return 0;
54960: 4280 clrl %d0
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
54962: 10bc 0001 moveb #1,%a0@
control->free++;
54966: 52aa 0010 addql #1,%a2@(16)
return 0;
5496a: 6002 bras 5496e <rtems_rfs_bitmap_map_clear+0x62>
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
5496c: 7016 moveq #22,%d0 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
return 0;
}
5496e: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
54974: 4e5e unlk %fp <== NOT EXECUTED
00054a2c <rtems_rfs_bitmap_map_clear_all>:
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
54a2c: 4e56 fff0 linkw %fp,#-16
54a30: 48d7 040c moveml %d2-%d3/%a2,%sp@
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
54a34: 486e fffc pea %fp@(-4)
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
54a38: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
54a3c: 2f0a movel %a2,%sp@-
54a3e: 4eba fc34 jsr %pc@(54674 <rtems_rfs_bitmap_load_map>)
if (rc > 0)
54a42: 508f addql #8,%sp
54a44: 4a80 tstl %d0
54a46: 6e58 bgts 54aa0 <rtems_rfs_bitmap_map_clear_all+0x74><== NEVER TAKEN
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
54a48: 202a 000c movel %a2@(12),%d0
54a4c: 5380 subql #1,%d0
54a4e: ea88 lsrl #5,%d0
54a50: 2200 movel %d0,%d1
54a52: 5281 addql #1,%d1
control->free = elements;
for (e = 0; e < elements; e++)
54a54: 91c8 subal %a0,%a0
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
54a56: 2541 0010 movel %d1,%a2@(16)
54a5a: 226e fffc moveal %fp@(-4),%a1
for (e = 0; e < elements; e++)
54a5e: 6006 bras 54a66 <rtems_rfs_bitmap_map_clear_all+0x3a>
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
54a60: 74ff moveq #-1,%d2
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
54a62: 5288 addql #1,%a0
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
54a64: 22c2 movel %d2,%a1@+
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
54a66: b288 cmpl %a0,%d1
54a68: 62f6 bhis 54a60 <rtems_rfs_bitmap_map_clear_all+0x34>
/*
* Set the un-mapped bits in the last search element so the available logic
* works.
*/
last_search_bit = rtems_rfs_bitmap_map_offset (elements);
54a6a: 741f moveq #31,%d2
54a6c: c282 andl %d2,%d1
if (last_search_bit == 0)
54a6e: 6604 bnes 54a74 <rtems_rfs_bitmap_map_clear_all+0x48><== NEVER TAKEN
last_search_bit = rtems_rfs_bitmap_element_bits ();
54a70: 123c 0020 moveb #32,%d1
elements = rtems_rfs_bitmap_elements (elements);
54a74: 2400 movel %d0,%d2
54a76: ea8a lsrl #5,%d2
for (e = 0; e < (elements - 1); e++)
54a78: 4280 clrl %d0
54a7a: 6008 bras 54a84 <rtems_rfs_bitmap_map_clear_all+0x58>
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
54a7c: 76ff moveq #-1,%d3 <== NOT EXECUTED
54a7e: 2183 0c00 movel %d3,%a0@(00000000,%d0:l:4) <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
54a82: 5280 addql #1,%d0 <== NOT EXECUTED
54a84: 206a 0014 moveal %a2@(20),%a0
54a88: b480 cmpl %d0,%d2
54a8a: 66f0 bnes 54a7c <rtems_rfs_bitmap_map_clear_all+0x50><== NEVER TAKEN
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
54a8c: 7420 moveq #32,%d2
54a8e: 9481 subl %d1,%d2
54a90: 72ff moveq #-1,%d1
54a92: e4a9 lsrl %d2,%d1
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
54a94: 2181 0c00 movel %d1,%a0@(00000000,%d0:l:4)
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
54a98: 4280 clrl %d0
control->search_bits[elements - 1] =
rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
54a9a: 2052 moveal %a2@,%a0
54a9c: 10bc 0001 moveb #1,%a0@
return 0;
}
54aa0: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
54aa6: 4e5e unlk %fp <== NOT EXECUTED
00054890 <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
54890: 4e56 ffec linkw %fp,#-20
54894: 48d7 041c moveml %d2-%d4/%a2,%sp@
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
54898: 486e fffc pea %fp@(-4)
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
5489c: 246e 0008 moveal %fp@(8),%a2
548a0: 242e 000c movel %fp@(12),%d2
rtems_rfs_bitmap_map map;
rtems_rfs_bitmap_map search_map;
int index;
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
548a4: 2f0a movel %a2,%sp@-
548a6: 4eba fdcc jsr %pc@(54674 <rtems_rfs_bitmap_load_map>)
if (rc > 0)
548aa: 508f addql #8,%sp
548ac: 4a80 tstl %d0
548ae: 6e52 bgts 54902 <rtems_rfs_bitmap_map_set+0x72> <== NEVER TAKEN
return rc;
if (bit >= control->size)
548b0: b4aa 000c cmpl %a2@(12),%d2
548b4: 6446 bccs 548fc <rtems_rfs_bitmap_map_set+0x6c> <== NEVER TAKEN
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
548b6: 2602 movel %d2,%d3
548b8: ea83 asrl #5,%d3
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
548ba: 2003 movel %d3,%d0
548bc: 7201 moveq #1,%d1
548be: 2801 movel %d1,%d4
548c0: e588 lsll #2,%d0
548c2: 226e fffc moveal %fp@(-4),%a1
548c6: d3c0 addal %d0,%a1
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
548c8: 701f moveq #31,%d0
548ca: c082 andl %d2,%d0
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
548cc: 206a 0014 moveal %a2@(20),%a0
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
548d0: e1ac lsll %d0,%d4
548d2: 2004 movel %d4,%d0
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
548d4: 4680 notl %d0
548d6: c091 andl %a1@,%d0
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
548d8: 2280 movel %d0,%a1@
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
548da: 6624 bnes 54900 <rtems_rfs_bitmap_map_set+0x70> <== ALWAYS TAKEN
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
548dc: 781f moveq #31,%d4 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
548de: 103c 000a moveb #10,%d0 <== NOT EXECUTED
548e2: e0a2 asrl %d0,%d2 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
548e4: 2001 movel %d1,%d0 <== NOT EXECUTED
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
548e6: c684 andl %d4,%d3 <== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
548e8: e7a8 lsll %d3,%d0 <== NOT EXECUTED
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
548ea: 4680 notl %d0 <== NOT EXECUTED
548ec: c1b0 2c00 andl %d0,%a0@(00000000,%d2:l:4) <== NOT EXECUTED
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
548f0: 2052 moveal %a2@,%a0 <== NOT EXECUTED
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
548f2: 53aa 0010 subql #1,%a2@(16) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
548f6: 10bc 0001 moveb #1,%a0@ <== NOT EXECUTED
548fa: 6004 bras 54900 <rtems_rfs_bitmap_map_set+0x70> <== NOT EXECUTED
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
548fc: 7016 moveq #22,%d0 <== NOT EXECUTED
548fe: 6002 bras 54902 <rtems_rfs_bitmap_map_set+0x72> <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
}
return 0;
54900: 4280 clrl %d0
}
54902: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
54908: 4e5e unlk %fp <== NOT EXECUTED
000549ca <rtems_rfs_bitmap_map_set_all>:
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
549ca: 4e56 fffc linkw %fp,#-4 <== NOT EXECUTED
549ce: 2f0a movel %a2,%sp@- <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
549d0: 486e fffc pea %fp@(-4) <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
549d4: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
549d8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
549da: 4eba fc98 jsr %pc@(54674 <rtems_rfs_bitmap_load_map>) <== NOT EXECUTED
if (rc > 0)
549de: 508f addql #8,%sp <== NOT EXECUTED
549e0: 4a80 tstl %d0 <== NOT EXECUTED
549e2: 6e40 bgts 54a24 <rtems_rfs_bitmap_map_set_all+0x5a><== NOT EXECUTED
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
549e4: 202a 000c movel %a2@(12),%d0 <== NOT EXECUTED
549e8: 5380 subql #1,%d0 <== NOT EXECUTED
549ea: ea88 lsrl #5,%d0 <== NOT EXECUTED
549ec: 2240 moveal %d0,%a1 <== NOT EXECUTED
549ee: 5289 addql #1,%a1 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
549f0: 4281 clrl %d1 <== NOT EXECUTED
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
549f2: 42aa 0010 clrl %a2@(16) <== NOT EXECUTED
549f6: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
for (e = 0; e < elements; e++)
549fa: 6004 bras 54a00 <rtems_rfs_bitmap_map_set_all+0x36><== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
549fc: 4298 clrl %a0@+ <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
549fe: 5281 addql #1,%d1 <== NOT EXECUTED
54a00: b3c1 cmpal %d1,%a1 <== NOT EXECUTED
54a02: 62f8 bhis 549fc <rtems_rfs_bitmap_map_set_all+0x32><== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
54a04: ea88 lsrl #5,%d0 <== NOT EXECUTED
54a06: 2200 movel %d0,%d1 <== NOT EXECUTED
54a08: 5281 addql #1,%d1 <== NOT EXECUTED
for (e = 0; e < elements; e++)
54a0a: 4280 clrl %d0 <== NOT EXECUTED
54a0c: 600a bras 54a18 <rtems_rfs_bitmap_map_set_all+0x4e><== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
54a0e: 206a 0014 moveal %a2@(20),%a0 <== NOT EXECUTED
54a12: 42b0 0c00 clrl %a0@(00000000,%d0:l:4) <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
54a16: 5280 addql #1,%d0 <== NOT EXECUTED
54a18: b280 cmpl %d0,%d1 <== NOT EXECUTED
54a1a: 62f2 bhis 54a0e <rtems_rfs_bitmap_map_set_all+0x44><== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
54a1c: 2052 moveal %a2@,%a0 <== NOT EXECUTED
return 0;
54a1e: 4280 clrl %d0 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
54a20: 10bc 0001 moveb #1,%a0@ <== NOT EXECUTED
return 0;
}
54a24: 246e fff8 moveal %fp@(-8),%a2 <== NOT EXECUTED
54a28: 4e5e unlk %fp <== NOT EXECUTED
00054978 <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
54978: 4e56 fffc linkw %fp,#-4 <== NOT EXECUTED
5497c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5497e: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
54982: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
54984: 486e fffc pea %fp@(-4) <== NOT EXECUTED
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
54988: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
5498c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5498e: 4eba fce4 jsr %pc@(54674 <rtems_rfs_bitmap_load_map>) <== NOT EXECUTED
if (rc > 0)
54992: 508f addql #8,%sp <== NOT EXECUTED
54994: 4a80 tstl %d0 <== NOT EXECUTED
54996: 6e26 bgts 549be <rtems_rfs_bitmap_map_test+0x46> <== NOT EXECUTED
return rc;
if (bit >= control->size)
54998: b4aa 000c cmpl %a2@(12),%d2 <== NOT EXECUTED
5499c: 641e bccs 549bc <rtems_rfs_bitmap_map_test+0x44> <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
5499e: 7001 moveq #1,%d0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
549a0: 2202 movel %d2,%d1 <== NOT EXECUTED
549a2: ea81 asrl #5,%d1 <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
549a4: 206e fffc moveal %fp@(-4),%a0 <== NOT EXECUTED
549a8: e5a8 lsll %d2,%d0 <== NOT EXECUTED
549aa: c0b0 1c00 andl %a0@(00000000,%d1:l:4),%d0 <== NOT EXECUTED
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
549ae: 206e 0010 moveal %fp@(16),%a0 <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
549b2: 57c0 seq %d0 <== NOT EXECUTED
549b4: 4480 negl %d0 <== NOT EXECUTED
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
549b6: 1080 moveb %d0,%a0@ <== NOT EXECUTED
return 0;
549b8: 4280 clrl %d0 <== NOT EXECUTED
549ba: 6002 bras 549be <rtems_rfs_bitmap_map_test+0x46> <== NOT EXECUTED
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
549bc: 7016 moveq #22,%d0 <== NOT EXECUTED
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
return 0;
}
549be: 242e fff4 movel %fp@(-12),%d2 <== NOT EXECUTED
549c2: 246e fff8 moveal %fp@(-8),%a2 <== NOT EXECUTED
549c6: 4e5e unlk %fp <== NOT EXECUTED
00054856 <rtems_rfs_bitmap_mask>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
54856: 7220 moveq #32,%d1 <== NOT EXECUTED
return mask;
}
54858: 70ff moveq #-1,%d0 <== NOT EXECUTED
return 0;
}
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
5485a: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
5485e: 92ae 0008 subl %fp@(8),%d1 <== NOT EXECUTED
return mask;
}
54862: 4e5e unlk %fp <== NOT EXECUTED
54864: e2a8 lsrl %d1,%d0 <== NOT EXECUTED
00054868 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
54868: 4e56 0000 linkw %fp,#0
5486c: 222e 0008 movel %fp@(8),%d1
54870: 202e 000c movel %fp@(12),%d0
54874: 2f02 movel %d2,%sp@-
rtems_rfs_bitmap_element mask = 0;
if (end > start)
54876: b280 cmpl %d0,%d1
54878: 640e bccs 54888 <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
mask = rtems_rfs_bitmap_mask (end - start) << start;
5487a: 9081 subl %d1,%d0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
5487c: 7420 moveq #32,%d2
5487e: 9480 subl %d0,%d2
54880: 70ff moveq #-1,%d0
54882: e4a8 lsrl %d2,%d0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
54884: e3a8 lsll %d1,%d0
54886: 6002 bras 5488a <rtems_rfs_bitmap_mask_section+0x22>
}
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
54888: 4280 clrl %d0 <== NOT EXECUTED
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
return mask;
}
5488a: 241f movel %sp@+,%d2
5488c: 4e5e unlk %fp <== NOT EXECUTED
00054bd6 <rtems_rfs_bitmap_open>:
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
54bd6: 720a moveq #10,%d1
rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
54bd8: 4e56 0000 linkw %fp,#0
54bdc: 202e 0014 movel %fp@(20),%d0
54be0: 2f0a movel %a2,%sp@-
54be2: 246e 0008 moveal %fp@(8),%a2
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
54be6: 2540 000c movel %d0,%a2@(12)
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
54bea: 5380 subql #1,%d0
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
54bec: e2a8 lsrl %d1,%d0
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
54bee: e588 lsll #2,%d0
size_t size,
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
54bf0: 24ae 0010 movel %fp@(16),%a2@
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
54bf4: 2040 moveal %d0,%a0
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
control->fs = fs;
54bf6: 256e 000c 0004 movel %fp@(12),%a2@(4)
control->block = block;
54bfc: 256e 0018 0008 movel %fp@(24),%a2@(8)
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
54c02: 4868 0004 pea %a0@(4)
54c06: 4eb9 0004 5af0 jsr 45af0 <malloc>
if (!control->search_bits)
54c0c: 588f addql #4,%sp
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
54c0e: 2540 0014 movel %d0,%a2@(20)
if (!control->search_bits)
54c12: 6710 beqs 54c24 <rtems_rfs_bitmap_open+0x4e> <== NEVER TAKEN
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
54c14: 2d4a 0008 movel %a2,%fp@(8)
}
54c18: 246e fffc moveal %fp@(-4),%a2
54c1c: 4e5e unlk %fp
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
if (!control->search_bits)
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
54c1e: 4ef9 0005 4b40 jmp 54b40 <rtems_rfs_bitmap_create_search>
}
54c24: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
54c28: 700c moveq #12,%d0 <== NOT EXECUTED
54c2a: 4e5e unlk %fp <== NOT EXECUTED
00054d70 <rtems_rfs_block_find_indirect>:
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
54d70: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
54d74: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@ <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
54d78: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
54d7c: 242e 0010 movel %fp@(16),%d2 <== NOT EXECUTED
54d80: 286e 000c moveal %fp@(12),%a4 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
54d84: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
54d86: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
54d8a: 2f0c movel %a4,%sp@- <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
54d8c: 262e 0014 movel %fp@(20),%d3 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
54d90: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
54d92: 246e 0018 moveal %fp@(24),%a2 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
54d96: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
54d9c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
54da0: 4a80 tstl %d0 <== NOT EXECUTED
54da2: 6e76 bgts 54e1a <rtems_rfs_block_find_indirect+0xaa><== NOT EXECUTED
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
54da4: 206c 0006 moveal %a4@(6),%a0 <== NOT EXECUTED
54da8: 2203 movel %d3,%d1 <== NOT EXECUTED
54daa: 4284 clrl %d4 <== NOT EXECUTED
54dac: 4280 clrl %d0 <== NOT EXECUTED
54dae: 7a18 moveq #24,%d5 <== NOT EXECUTED
54db0: e589 lsll #2,%d1 <== NOT EXECUTED
54db2: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
54db6: 1830 1800 moveb %a0@(00000000,%d1:l),%d4 <== NOT EXECUTED
54dba: 1030 1803 moveb %a0@(00000003,%d1:l),%d0 <== NOT EXECUTED
54dbe: ebac lsll %d5,%d4 <== NOT EXECUTED
54dc0: 8084 orl %d4,%d0 <== NOT EXECUTED
54dc2: 4284 clrl %d4 <== NOT EXECUTED
54dc4: 1830 1801 moveb %a0@(00000001,%d1:l),%d4 <== NOT EXECUTED
54dc8: 1230 1802 moveb %a0@(00000002,%d1:l),%d1 <== NOT EXECUTED
54dcc: 4844 swap %d4 <== NOT EXECUTED
54dce: 4244 clrw %d4 <== NOT EXECUTED
54dd0: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
54dd6: 8084 orl %d4,%d0 <== NOT EXECUTED
54dd8: e189 lsll #8,%d1 <== NOT EXECUTED
54dda: 8081 orl %d1,%d0 <== NOT EXECUTED
if ((*result + 1) == 0)
54ddc: 72ff moveq #-1,%d1 <== NOT EXECUTED
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
54dde: 2480 movel %d0,%a2@ <== NOT EXECUTED
if ((*result + 1) == 0)
54de0: b280 cmpl %d0,%d1 <== NOT EXECUTED
54de2: 6602 bnes 54de6 <rtems_rfs_block_find_indirect+0x76><== NOT EXECUTED
*result = 0;
54de4: 4292 clrl %a2@ <== NOT EXECUTED
if (*result >= rtems_rfs_fs_blocks (fs))
54de6: 266b 0004 moveal %a3@(4),%a3 <== NOT EXECUTED
54dea: b7d2 cmpal %a2@,%a3 <== NOT EXECUTED
54dec: 622a bhis 54e18 <rtems_rfs_block_find_indirect+0xa8><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
54dee: 4878 1000 pea 1000 <D_MAX_EXP+0x801> <== NOT EXECUTED
54df2: 42a7 clrl %sp@- <== NOT EXECUTED
54df4: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
54dfa: 508f addql #8,%sp <== NOT EXECUTED
54dfc: 4a00 tstb %d0 <== NOT EXECUTED
54dfe: 6716 beqs 54e16 <rtems_rfs_block_find_indirect+0xa6><== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
54e00: 2f03 movel %d3,%sp@- <== NOT EXECUTED
54e02: 2f02 movel %d2,%sp@- <== NOT EXECUTED
54e04: 2f12 movel %a2@,%sp@- <== NOT EXECUTED
54e06: 4879 0006 b2dd pea 6b2dd <CSWTCH.1+0x37> <== NOT EXECUTED
54e0c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
54e12: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
54e16: 4292 clrl %a2@ <== NOT EXECUTED
*result = rtems_rfs_block_get_number (buffer, offset);
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
54e18: 4280 clrl %d0 <== NOT EXECUTED
*result = 0;
rc = EIO;
}
return 0;
}
54e1a: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4 <== NOT EXECUTED
54e20: 4e5e unlk %fp <== NOT EXECUTED
00054f2e <rtems_rfs_block_get_block_size>:
void
rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_size* size)
{
54f2e: 4e56 ffec linkw %fp,#-20 <== NOT EXECUTED
54f32: 48d7 043c moveml %d2-%d5/%a2,%sp@ <== NOT EXECUTED
54f36: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
54f3a: 262e 0010 movel %fp@(16),%d3 <== NOT EXECUTED
54f3e: 246e 0014 moveal %fp@(20),%a2 <== NOT EXECUTED
if (pos == 0)
54f42: 2002 movel %d2,%d0 <== NOT EXECUTED
54f44: 8083 orl %d3,%d0 <== NOT EXECUTED
54f46: 6608 bnes 54f50 <rtems_rfs_block_get_block_size+0x22><== NOT EXECUTED
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
54f48: 4292 clrl %a2@ <== NOT EXECUTED
size->offset = 0;
54f4a: 42aa 0004 clrl %a2@(4) <== NOT EXECUTED
54f4e: 6036 bras 54f86 <rtems_rfs_block_get_block_size+0x58><== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
54f50: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
54f54: 4284 clrl %d4 <== NOT EXECUTED
54f56: 2a28 0008 movel %a0@(8),%d5 <== NOT EXECUTED
54f5a: 2f05 movel %d5,%sp@- <== NOT EXECUTED
54f5c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
54f5e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
54f60: 2f02 movel %d2,%sp@- <== NOT EXECUTED
54f62: 4eb9 0006 7a1c jsr 67a1c <__udivdi3> <== NOT EXECUTED
54f68: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
54f6c: 5281 addql #1,%d1 <== NOT EXECUTED
54f6e: 2481 movel %d1,%a2@ <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
54f70: 2f05 movel %d5,%sp@- <== NOT EXECUTED
54f72: 2f04 movel %d4,%sp@- <== NOT EXECUTED
54f74: 2f03 movel %d3,%sp@- <== NOT EXECUTED
54f76: 2f02 movel %d2,%sp@- <== NOT EXECUTED
54f78: 4eb9 0006 7e48 jsr 67e48 <__umoddi3> <== NOT EXECUTED
54f7e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
54f82: 2541 0004 movel %d1,%a2@(4) <== NOT EXECUTED
}
}
54f86: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2 <== NOT EXECUTED
54f8c: 4e5e unlk %fp <== NOT EXECUTED
00055168 <rtems_rfs_block_map_close>:
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
55168: 4e56 ffe8 linkw %fp,#-24
5516c: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
55170: 262e 0008 movel %fp@(8),%d3
55174: 246e 000c moveal %fp@(12),%a2
int rc = 0;
int brc;
if (map->dirty && map->inode)
55178: 4a12 tstb %a2@
5517a: 6700 015e beqw 552da <rtems_rfs_block_map_close+0x172>
5517e: 202a 0002 movel %a2@(2),%d0
55182: 6700 0156 beqw 552da <rtems_rfs_block_map_close+0x172>
{
brc = rtems_rfs_inode_load (fs, map->inode);
55186: 2f00 movel %d0,%sp@-
55188: 2f03 movel %d3,%sp@-
5518a: 4eb9 0004 d64c jsr 4d64c <rtems_rfs_inode_load>
if (brc > 0)
55190: 508f addql #8,%sp
55192: 4a80 tstl %d0
55194: 6e00 0148 bgtw 552de <rtems_rfs_block_map_close+0x176>
55198: 7001 moveq #1,%d0
5519a: 4281 clrl %d1
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
5519c: 2432 0821 movel %a2@(00000021,%d0:l),%d2
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
551a0: 7a18 moveq #24,%d5
551a2: 2802 movel %d2,%d4
551a4: eaac lsrl %d5,%d4
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
551a6: 1a3c 0005 moveb #5,%d5
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
551aa: 206a 0002 moveal %a2@(2),%a0
551ae: 2268 000c moveal %a0@(12),%a1
551b2: 1384 1c1c moveb %d4,%a1@(0000001c,%d1:l:4)
551b6: 2802 movel %d2,%d4
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
551b8: 5281 addql #1,%d1
551ba: 2268 000c moveal %a0@(12),%a1
551be: 4244 clrw %d4
551c0: 4844 swap %d4
551c2: 1384 081c moveb %d4,%a1@(0000001c,%d0:l)
551c6: 2802 movel %d2,%d4
551c8: e08c lsrl #8,%d4
551ca: 2268 000c moveal %a0@(12),%a1
551ce: 1384 081d moveb %d4,%a1@(0000001d,%d0:l)
551d2: 2268 000c moveal %a0@(12),%a1
551d6: 1382 081e moveb %d2,%a1@(0000001e,%d0:l)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
551da: 7401 moveq #1,%d2
551dc: 5880 addql #4,%d0
551de: 1142 0010 moveb %d2,%a0@(16)
551e2: ba81 cmpl %d1,%d5
551e4: 66b6 bnes 5519c <rtems_rfs_block_map_close+0x34>
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
551e6: 206a 0002 moveal %a2@(2),%a0
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
551ea: 7418 moveq #24,%d2
551ec: 202a 0006 movel %a2@(6),%d0
551f0: 2200 movel %d0,%d1
551f2: e4a9 lsrl %d2,%d1
551f4: 2268 000c moveal %a0@(12),%a1
551f8: 1341 000c moveb %d1,%a1@(12)
551fc: 2200 movel %d0,%d1
551fe: 2268 000c moveal %a0@(12),%a1
55202: 4241 clrw %d1
55204: 4841 swap %d1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55206: 7a01 moveq #1,%d5
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
55208: 1341 000d moveb %d1,%a1@(13)
5520c: 2200 movel %d0,%d1
5520e: e089 lsrl #8,%d1
55210: 2268 000c moveal %a0@(12),%a1
55214: 1341 000e moveb %d1,%a1@(14)
55218: 2268 000c moveal %a0@(12),%a1
5521c: 1340 000f moveb %d0,%a1@(15)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55220: 1145 0010 moveb %d5,%a0@(16)
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
55224: 206a 0002 moveal %a2@(2),%a0
55228: 302a 000c movew %a2@(12),%d0
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
5522c: 2268 000c moveal %a0@(12),%a1
55230: 2200 movel %d0,%d1
55232: e089 lsrl #8,%d1
55234: 1341 000a moveb %d1,%a1@(10)
55238: 2268 000c moveal %a0@(12),%a1
5523c: 1340 000b moveb %d0,%a1@(11)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
55240: 1145 0010 moveb %d5,%a0@(16)
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
55244: 206a 0002 moveal %a2@(2),%a0
55248: 202a 001a movel %a2@(26),%d0
* @param block_count The last map block number.
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
5524c: 2200 movel %d0,%d1
5524e: e4a9 lsrl %d2,%d1
55250: 2268 000c moveal %a0@(12),%a1
55254: 1341 0030 moveb %d1,%a1@(48)
55258: 2200 movel %d0,%d1
5525a: 2268 000c moveal %a0@(12),%a1
5525e: 4241 clrw %d1
55260: 4841 swap %d1
55262: 1341 0031 moveb %d1,%a1@(49)
55266: 2200 movel %d0,%d1
55268: e089 lsrl #8,%d1
5526a: 2268 000c moveal %a0@(12),%a1
5526e: 1341 0032 moveb %d1,%a1@(50)
55272: 2268 000c moveal %a0@(12),%a1
55276: 1340 0033 moveb %d0,%a1@(51)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
5527a: 1145 0010 moveb %d5,%a0@(16)
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
5527e: 206a 0002 moveal %a2@(2),%a0
55282: 202a 001e movel %a2@(30),%d0
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
55286: 2200 movel %d0,%d1
55288: e4a9 lsrl %d2,%d1
5528a: 2268 000c moveal %a0@(12),%a1
5528e: 1341 0034 moveb %d1,%a1@(52)
55292: 2200 movel %d0,%d1
55294: 2268 000c moveal %a0@(12),%a1
55298: 4241 clrw %d1
5529a: 4841 swap %d1
5529c: 1341 0035 moveb %d1,%a1@(53)
552a0: 2268 000c moveal %a0@(12),%a1
552a4: 2200 movel %d0,%d1
552a6: e089 lsrl #8,%d1
552a8: 1341 0036 moveb %d1,%a1@(54)
552ac: 2268 000c moveal %a0@(12),%a1
552b0: 1340 0037 moveb %d0,%a1@(55)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
552b4: 1145 0010 moveb %d5,%a0@(16)
brc = rtems_rfs_inode_unload (fs, map->inode, true);
552b8: 4878 0001 pea 1 <ADD>
552bc: 2f2a 0002 movel %a2@(2),%sp@-
552c0: 2f03 movel %d3,%sp@-
552c2: 4eb9 0004 d7a0 jsr 4d7a0 <rtems_rfs_inode_unload>
552c8: 4fef 000c lea %sp@(12),%sp
552cc: 2400 movel %d0,%d2
552ce: 4680 notl %d0
552d0: d080 addl %d0,%d0
552d2: 9180 subxl %d0,%d0
if (brc > 0)
rc = brc;
map->dirty = false;
552d4: 4212 clrb %a2@
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
552d6: c480 andl %d0,%d2
552d8: 6006 bras 552e0 <rtems_rfs_block_map_close+0x178>
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
int rc = 0;
552da: 4282 clrl %d2
552dc: 6002 bras 552e0 <rtems_rfs_block_map_close+0x178>
int brc;
if (map->dirty && map->inode)
{
brc = rtems_rfs_inode_load (fs, map->inode);
if (brc > 0)
552de: 2400 movel %d0,%d2 <== NOT EXECUTED
map->dirty = false;
}
}
map->inode = NULL;
552e0: 42aa 0002 clrl %a2@(2)
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
552e4: 486a 0036 pea %a2@(54)
552e8: 47f9 0005 5b88 lea 55b88 <rtems_rfs_buffer_handle_release>,%a3
552ee: 2f03 movel %d3,%sp@-
handle->dirty = false;
552f0: 4205 clrb %d5
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
552f2: 4e93 jsr %a3@
handle->dirty = false;
552f4: 4200 clrb %d0
552f6: 1540 0036 moveb %d0,%a2@(54)
handle->bnum = 0;
552fa: 42aa 0038 clrl %a2@(56)
handle->buffer = NULL;
552fe: 42aa 003c clrl %a2@(60)
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55302: 486a 0040 pea %a2@(64)
55306: 2f03 movel %d3,%sp@-
55308: 4e93 jsr %a3@
rc = brc;
brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
if ((brc > 0) && (rc == 0))
rc = brc;
return rc;
}
5530a: 2002 movel %d2,%d0
handle->dirty = false;
5530c: 1545 0040 moveb %d5,%a2@(64)
handle->bnum = 0;
55310: 42aa 0042 clrl %a2@(66)
handle->buffer = NULL;
55314: 42aa 0046 clrl %a2@(70)
55318: 4cee 0c3c ffe8 moveml %fp@(-24),%d2-%d5/%a2-%a3
5531e: 4e5e unlk %fp <== NOT EXECUTED
00055322 <rtems_rfs_block_map_find>:
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
55322: 4e56 ffe0 linkw %fp,#-32
55326: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
5532a: 266e 0014 moveal %fp@(20),%a3
5532e: 2a6e 0010 moveal %fp@(16),%a5
int rc = 0;
*block = 0;
55332: 4293 clrl %a3@
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
55334: 286e 0008 moveal %fp@(8),%a4
55338: 246e 000c moveal %fp@(12),%a2
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
5533c: 2015 movel %a5@,%d0
5533e: 6708 beqs 55348 <rtems_rfs_block_map_find+0x26>
55340: 4aaa 0006 tstl %a2@(6)
55344: 6700 00bc beqw 55402 <rtems_rfs_block_map_find+0xe0>
55348: 222a 0006 movel %a2@(6),%d1
5534c: b280 cmpl %d0,%d1
5534e: 6300 00b2 blsw 55402 <rtems_rfs_block_map_find+0xe0>
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
55352: b0aa 000e cmpl %a2@(14),%d0
55356: 660e bnes 55366 <rtems_rfs_block_map_find+0x44> <== NEVER TAKEN
55358: 206a 0016 moveal %a2@(22),%a0
5535c: 4a88 tstl %a0
5535e: 6706 beqs 55366 <rtems_rfs_block_map_find+0x44> <== ALWAYS TAKEN
{
*block = map->bpos.block;
55360: 2688 movel %a0,%a3@ <== NOT EXECUTED
55362: 6000 0086 braw 553ea <rtems_rfs_block_map_find+0xc8> <== NOT EXECUTED
/*
* Determine the type of access we need to perform. If the number of blocks
* is less than or equal to the number of slots in the inode the blocks are
* directly accessed.
*/
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
55366: 7405 moveq #5,%d2
55368: b481 cmpl %d1,%d2
5536a: 6506 bcss 55372 <rtems_rfs_block_map_find+0x50> <== NEVER TAKEN
{
*block = map->blocks[bpos->bno];
5536c: 26b2 0c22 movel %a2@(00000022,%d0:l:4),%a3@
55370: 6078 bras 553ea <rtems_rfs_block_map_find+0xc8>
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
55372: 242c 0030 movel %a4@(48),%d2 <== NOT EXECUTED
55376: 4c42 0003 remul %d2,%d3,%d0 <== NOT EXECUTED
5537a: 4c42 0000 remul %d2,%d0,%d0 <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
5537e: 2d40 fffc movel %d0,%fp@(-4) <== NOT EXECUTED
if (map->size.count <= fs->block_map_singly_blocks)
55382: b2ac 0034 cmpl %a4@(52),%d1 <== NOT EXECUTED
55386: 6214 bhis 5539c <rtems_rfs_block_map_find+0x7a> <== NOT EXECUTED
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
55388: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5538a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5538c: 2f32 0c22 movel %a2@(00000022,%d0:l:4),%sp@- <== NOT EXECUTED
55390: 486a 0036 pea %a2@(54) <== NOT EXECUTED
55394: 2f0c movel %a4,%sp@- <== NOT EXECUTED
55396: 4eba f9d8 jsr %pc@(54d70 <rtems_rfs_block_find_indirect>)<== NOT EXECUTED
5539a: 6046 bras 553e2 <rtems_rfs_block_map_find+0xc0> <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
5539c: 4c42 0004 remul %d2,%d4,%d0 <== NOT EXECUTED
553a0: 4c42 0000 remul %d2,%d0,%d0 <== NOT EXECUTED
553a4: 2d44 fffc movel %d4,%fp@(-4) <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
553a8: b2ac 0038 cmpl %a4@(56),%d1 <== NOT EXECUTED
553ac: 6454 bccs 55402 <rtems_rfs_block_map_find+0xe0> <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
553ae: 486e fffc pea %fp@(-4) <== NOT EXECUTED
553b2: 243c 0005 4d70 movel #347504,%d2 <== NOT EXECUTED
553b8: 2042 moveal %d2,%a0 <== NOT EXECUTED
553ba: 2f04 movel %d4,%sp@- <== NOT EXECUTED
553bc: 2f32 0c22 movel %a2@(00000022,%d0:l:4),%sp@- <== NOT EXECUTED
553c0: 486a 0040 pea %a2@(64) <== NOT EXECUTED
553c4: 2f0c movel %a4,%sp@- <== NOT EXECUTED
553c6: 4e90 jsr %a0@ <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
553c8: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
553cc: 4a80 tstl %d0 <== NOT EXECUTED
553ce: 6634 bnes 55404 <rtems_rfs_block_map_find+0xe2> <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
553d0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
553d2: 2042 moveal %d2,%a0 <== NOT EXECUTED
553d4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
553d6: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
553da: 486a 0036 pea %a2@(54) <== NOT EXECUTED
553de: 2f0c movel %a4,%sp@- <== NOT EXECUTED
553e0: 4e90 jsr %a0@ <== NOT EXECUTED
553e2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
}
}
}
}
if (rc == 0)
553e6: 4a80 tstl %d0 <== NOT EXECUTED
553e8: 661a bnes 55404 <rtems_rfs_block_map_find+0xe2> <== NOT EXECUTED
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
553ea: 2555 000e movel %a5@,%a2@(14)
map->bpos.block = *block;
553ee: 4280 clrl %d0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
553f0: 256d 0004 0012 movel %a5@(4),%a2@(18)
553f6: 256d 0008 0016 movel %a5@(8),%a2@(22)
map->bpos.block = *block;
553fc: 2553 0016 movel %a3@,%a2@(22)
55400: 6002 bras 55404 <rtems_rfs_block_map_find+0xe2>
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
return ENXIO;
55402: 7006 moveq #6,%d0
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
}
return rc;
}
55404: 4cee 3c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a5
5540a: 4e5e unlk %fp <== NOT EXECUTED
000554be <rtems_rfs_block_map_grow>:
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
554be: 4e56 ffd0 linkw %fp,#-48
554c2: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
554c6: 4878 2000 pea 2000 <D_MAX_EXP+0x1801>
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
554ca: 266e 0008 moveal %fp@(8),%a3
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
554ce: 42a7 clrl %sp@-
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
554d0: 246e 000c moveal %fp@(12),%a2
554d4: 242e 0010 movel %fp@(16),%d2
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
554d8: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
554de: 508f addql #8,%sp
554e0: 4a00 tstb %d0
554e2: 6716 beqs 554fa <rtems_rfs_block_map_grow+0x3c> <== ALWAYS TAKEN
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
554e4: 2f2a 0006 movel %a2@(6),%sp@- <== NOT EXECUTED
554e8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
554ea: 4879 0006 b328 pea 6b328 <CSWTCH.1+0x82> <== NOT EXECUTED
554f0: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
554f6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
554fa: 2002 movel %d2,%d0
554fc: d0aa 0006 addl %a2@(6),%d0
55500: b0ab 0038 cmpl %a3@(56),%d0
55504: 6400 0262 bccw 55768 <rtems_rfs_block_map_grow+0x2aa>
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
55508: 260a movel %a2,%d3
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
5550a: 4284 clrl %d4
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
5550c: 4bea 0040 lea %a2@(64),%a5
55510: 49f9 0005 5d00 lea 55d00 <rtems_rfs_buffer_handle_request>,%a4
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
55516: 0683 0000 0036 addil #54,%d3
5551c: 6000 0240 braw 5575e <rtems_rfs_block_map_grow+0x2a0>
/*
* Allocate the block. If an indirect block is needed and cannot be
* allocated free this block.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
55520: 486e fff8 pea %fp@(-8)
55524: 42a7 clrl %sp@-
55526: 2f2a 001e movel %a2@(30),%sp@-
5552a: 2f0b movel %a3,%sp@-
5552c: 4eb9 0004 d2c8 jsr 4d2c8 <rtems_rfs_group_bitmap_alloc>
false, &block);
if (rc > 0)
55532: 4fef 0010 lea %sp@(16),%sp
55536: 4a80 tstl %d0
55538: 6e00 0232 bgtw 5576c <rtems_rfs_block_map_grow+0x2ae>
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
5553c: 202a 0006 movel %a2@(6),%d0
55540: 7204 moveq #4,%d1
55542: b280 cmpl %d0,%d1
55544: 650c bcss 55552 <rtems_rfs_block_map_grow+0x94>
map->blocks[map->size.count] = block;
55546: 41ee fff8 lea %fp@(-8),%a0
5554a: 2590 0c22 movel %a0@,%a2@(00000022,%d0:l:4)
5554e: 6000 01ee braw 5573e <rtems_rfs_block_map_grow+0x280>
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
55552: 222b 0030 movel %a3@(48),%d1
55556: 2e00 movel %d0,%d7
55558: 4c41 7005 remul %d1,%d5,%d7
5555c: 4c41 7007 remul %d1,%d7,%d7
singly = map->size.count / fs->blocks_per_block;
if (map->size.count < fs->block_map_singly_blocks)
55560: b0ab 0034 cmpl %a3@(52),%d0
55564: 643c bccs 555a2 <rtems_rfs_block_map_grow+0xe4>
* Singly indirect tables are being used. Allocate a new block for a
* mapping table if direct is 0 or we are moving up (upping). If upping
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
55566: 4a85 tstl %d5
55568: 670a beqs 55574 <rtems_rfs_block_map_grow+0xb6>
5556a: 4a87 tstl %d7
5556c: 6628 bnes 55596 <rtems_rfs_block_map_grow+0xd8>
((singly == 0) && (direct == RTEMS_RFS_INODE_BLOCKS)))
5556e: 7205 moveq #5,%d1
55570: b285 cmpl %d5,%d1
55572: 6622 bnes 55596 <rtems_rfs_block_map_grow+0xd8>
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
55574: 7205 moveq #5,%d1
55576: b280 cmpl %d0,%d1
55578: 57c0 seq %d0
5557a: 49c0 extbl %d0
5557c: 4480 negl %d0
5557e: 2f00 movel %d0,%sp@-
55580: 4872 7c22 pea %a2@(00000022,%d7:l:4)
55584: 2f03 movel %d3,%sp@-
55586: 2f0a movel %a2,%sp@-
55588: 2f0b movel %a3,%sp@-
5558a: 4eba f6bc jsr %pc@(54c48 <rtems_rfs_block_map_indirect_alloc>)
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
((singly == 0) && (direct == RTEMS_RFS_INODE_BLOCKS)))
{
5558e: 4fef 0014 lea %sp@(20),%sp
55592: 6000 0148 braw 556dc <rtems_rfs_block_map_grow+0x21e>
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
55596: 4878 0001 pea 1 <ADD>
5559a: 2f32 7c22 movel %a2@(00000022,%d7:l:4),%sp@-
5559e: 6000 0132 braw 556d2 <rtems_rfs_block_map_grow+0x214>
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
555a2: 4c41 7006 remul %d1,%d6,%d7
555a6: 4c41 7007 remul %d1,%d7,%d7
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
555aa: 4a85 tstl %d5
555ac: 6600 00d2 bnew 55680 <rtems_rfs_block_map_grow+0x1c2>
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
555b0: 42a7 clrl %sp@-
555b2: 486e fffc pea %fp@(-4)
555b6: 2f03 movel %d3,%sp@-
555b8: 2f0a movel %a2,%sp@-
555ba: 2f0b movel %a3,%sp@-
555bc: 4eba f68a jsr %pc@(54c48 <rtems_rfs_block_map_indirect_alloc>)
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
555c0: 4fef 0014 lea %sp@(20),%sp
555c4: 4a80 tstl %d0
555c6: 6e00 0118 bgtw 556e0 <rtems_rfs_block_map_grow+0x222>
/*
* Allocate a new block for a doubly indirect table if singly is 0 as
* it is the first entry of a new singly indirect block.
*/
if ((singly == 0) ||
555ca: 4a86 tstl %d6
555cc: 670a beqs 555d8 <rtems_rfs_block_map_grow+0x11a> <== NEVER TAKEN
555ce: 4a87 tstl %d7
555d0: 662a bnes 555fc <rtems_rfs_block_map_grow+0x13e> <== NEVER TAKEN
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
555d2: 7005 moveq #5,%d0
555d4: b086 cmpl %d6,%d0
555d6: 6624 bnes 555fc <rtems_rfs_block_map_grow+0x13e>
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
555d8: 222b 0034 movel %a3@(52),%d1
555dc: b2aa 0006 cmpl %a2@(6),%d1
555e0: 57c0 seq %d0
555e2: 49c0 extbl %d0
555e4: 4480 negl %d0
555e6: 2f00 movel %d0,%sp@-
555e8: 4872 7c22 pea %a2@(00000022,%d7:l:4)
555ec: 2f0d movel %a5,%sp@-
555ee: 2f0a movel %a2,%sp@-
555f0: 2f0b movel %a3,%sp@-
555f2: 4eba f654 jsr %pc@(54c48 <rtems_rfs_block_map_indirect_alloc>)
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
555f6: 4fef 0014 lea %sp@(20),%sp
555fa: 6012 bras 5560e <rtems_rfs_block_map_grow+0x150>
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
555fc: 4878 0001 pea 1 <ADD>
55600: 2f32 7c22 movel %a2@(00000022,%d7:l:4),%sp@-
55604: 2f0d movel %a5,%sp@-
55606: 2f0b movel %a3,%sp@-
55608: 4e94 jsr %a4@
map->blocks[doubly], true);
if (rc > 0)
5560a: 4fef 0010 lea %sp@(16),%sp
5560e: 4a80 tstl %d0
55610: 6f24 bles 55636 <rtems_rfs_block_map_grow+0x178> <== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
55612: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
55616: 45f9 0004 d44a lea 4d44a <rtems_rfs_group_bitmap_free>,%a2 <== NOT EXECUTED
5561c: 2400 movel %d0,%d2 <== NOT EXECUTED
5561e: 42a7 clrl %sp@- <== NOT EXECUTED
55620: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55622: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
55624: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
55628: 42a7 clrl %sp@- <== NOT EXECUTED
5562a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5562c: 4e92 jsr %a2@ <== NOT EXECUTED
return rc;
5562e: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
55632: 6000 013a braw 5576e <rtems_rfs_block_map_grow+0x2b0> <== NOT EXECUTED
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
55636: 206a 0046 moveal %a2@(70),%a0
5563a: 43ee fffc lea %fp@(-4),%a1
5563e: 2068 001e moveal %a0@(30),%a0
55642: e58e lsll #2,%d6
55644: 7001 moveq #1,%d0
55646: 1191 6800 moveb %a1@,%a0@(00000000,%d6:l)
5564a: 43ee fffd lea %fp@(-3),%a1
5564e: 206a 0046 moveal %a2@(70),%a0
55652: 2068 001e moveal %a0@(30),%a0
55656: 1191 6801 moveb %a1@,%a0@(00000001,%d6:l)
5565a: 43ee fffe lea %fp@(-2),%a1
5565e: 206a 0046 moveal %a2@(70),%a0
55662: 2068 001e moveal %a0@(30),%a0
55666: 1191 6802 moveb %a1@,%a0@(00000002,%d6:l)
5566a: 43ee ffff lea %fp@(-1),%a1
5566e: 206a 0046 moveal %a2@(70),%a0
55672: 2068 001e moveal %a0@(30),%a0
55676: 1191 6803 moveb %a1@,%a0@(00000003,%d6:l)
5567a: 1540 0040 moveb %d0,%a2@(64)
5567e: 6076 bras 556f6 <rtems_rfs_block_map_grow+0x238>
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
55680: 4878 0001 pea 1 <ADD>
55684: 2f32 7c22 movel %a2@(00000022,%d7:l:4),%sp@-
55688: 2f0d movel %a5,%sp@-
5568a: 2f0b movel %a3,%sp@-
5568c: 4e94 jsr %a4@
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
5568e: 4fef 0010 lea %sp@(16),%sp
55692: 4a80 tstl %d0
55694: 6e4a bgts 556e0 <rtems_rfs_block_map_grow+0x222> <== NEVER TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
55696: 206a 0046 moveal %a2@(70),%a0
5569a: 4281 clrl %d1
5569c: 4280 clrl %d0
5569e: 7e18 moveq #24,%d7
556a0: e58e lsll #2,%d6
556a2: 2068 001e moveal %a0@(30),%a0
556a6: 1230 6800 moveb %a0@(00000000,%d6:l),%d1
556aa: 1030 6803 moveb %a0@(00000003,%d6:l),%d0
556ae: efa9 lsll %d7,%d1
556b0: 8081 orl %d1,%d0
556b2: 4281 clrl %d1
556b4: 1230 6801 moveb %a0@(00000001,%d6:l),%d1
556b8: 4841 swap %d1
556ba: 4241 clrw %d1
556bc: 8081 orl %d1,%d0
556be: 4281 clrl %d1
556c0: 1230 6802 moveb %a0@(00000002,%d6:l),%d1
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
556c4: 4878 0001 pea 1 <ADD>
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
556c8: e189 lsll #8,%d1
556ca: 8081 orl %d1,%d0
556cc: 2d40 fffc movel %d0,%fp@(-4)
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
556d0: 2f00 movel %d0,%sp@-
556d2: 2f03 movel %d3,%sp@-
556d4: 2f0b movel %a3,%sp@-
556d6: 4e94 jsr %a4@
singly_block, true);
if (rc > 0)
556d8: 4fef 0010 lea %sp@(16),%sp
556dc: 4a80 tstl %d0
556de: 6f16 bles 556f6 <rtems_rfs_block_map_grow+0x238> <== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, block);
556e0: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
556e4: 2400 movel %d0,%d2 <== NOT EXECUTED
556e6: 42a7 clrl %sp@- <== NOT EXECUTED
556e8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
556ea: 4eb9 0004 d44a jsr 4d44a <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
556f0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
556f4: 6078 bras 5576e <rtems_rfs_block_map_grow+0x2b0> <== NOT EXECUTED
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
556f6: 206a 003c moveal %a2@(60),%a0
556fa: 43ee fff8 lea %fp@(-8),%a1
556fe: 2068 001e moveal %a0@(30),%a0
55702: e58d lsll #2,%d5
55704: 7001 moveq #1,%d0
55706: 1191 5800 moveb %a1@,%a0@(00000000,%d5:l)
5570a: 43ee fff9 lea %fp@(-7),%a1
5570e: 206a 003c moveal %a2@(60),%a0
55712: 2068 001e moveal %a0@(30),%a0
55716: 1191 5801 moveb %a1@,%a0@(00000001,%d5:l)
5571a: 43ee fffa lea %fp@(-6),%a1
5571e: 206a 003c moveal %a2@(60),%a0
55722: 2068 001e moveal %a0@(30),%a0
55726: 1191 5802 moveb %a1@,%a0@(00000002,%d5:l)
5572a: 43ee fffb lea %fp@(-5),%a1
5572e: 206a 003c moveal %a2@(60),%a0
55732: 2068 001e moveal %a0@(30),%a0
55736: 1191 5803 moveb %a1@,%a0@(00000003,%d5:l)
5573a: 1540 0036 moveb %d0,%a2@(54)
}
map->size.count++;
5573e: 52aa 0006 addql #1,%a2@(6)
map->size.offset = 0;
55742: 42aa 000a clrl %a2@(10)
if (b == 0)
55746: 4a84 tstl %d4
55748: 6608 bnes 55752 <rtems_rfs_block_map_grow+0x294> <== NEVER TAKEN
*new_block = block;
5574a: 206e 0014 moveal %fp@(20),%a0
5574e: 20ae fff8 movel %fp@(-8),%a0@
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
55752: 5284 addql #1,%d4
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
map->dirty = true;
55754: 14bc 0001 moveb #1,%a2@
map->size.count++;
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
55758: 256e fff8 001e movel %fp@(-8),%a2@(30)
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
5575e: b484 cmpl %d4,%d2
55760: 6600 fdbe bnew 55520 <rtems_rfs_block_map_grow+0x62>
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
55764: 4282 clrl %d2
55766: 6006 bras 5576e <rtems_rfs_block_map_grow+0x2b0>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
return EFBIG;
55768: 741b moveq #27,%d2 <== NOT EXECUTED
5576a: 6002 bras 5576e <rtems_rfs_block_map_grow+0x2b0> <== NOT EXECUTED
5576c: 2400 movel %d0,%d2
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
5576e: 2002 movel %d2,%d0
55770: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5
55776: 4e5e unlk %fp <== NOT EXECUTED
00054c48 <rtems_rfs_block_map_indirect_alloc>:
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
54c48: 4e56 ffe4 linkw %fp,#-28
54c4c: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
54c50: 486e fffc pea %fp@(-4)
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
54c54: 266e 000c moveal %fp@(12),%a3
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
54c58: 42a7 clrl %sp@-
54c5a: 2f2b 001a movel %a3@(26),%sp@-
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
54c5e: 286e 0008 moveal %fp@(8),%a4
54c62: 246e 0010 moveal %fp@(16),%a2
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
54c66: 2f0c movel %a4,%sp@-
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
54c68: 162e 001b moveb %fp@(27),%d3
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
54c6c: 4eb9 0004 d2c8 jsr 4d2c8 <rtems_rfs_group_bitmap_alloc>
if (rc > 0)
54c72: 4fef 0010 lea %sp@(16),%sp
int rc;
/*
* Save the new block locally because upping can have *block pointing to the
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
54c76: 2400 movel %d0,%d2
if (rc > 0)
54c78: 6e00 00ea bgtw 54d64 <rtems_rfs_block_map_indirect_alloc+0x11c>
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
54c7c: 42a7 clrl %sp@-
54c7e: 2f2e fffc movel %fp@(-4),%sp@-
54c82: 2f0a movel %a2,%sp@-
54c84: 2f0c movel %a4,%sp@-
54c86: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
if (rc > 0)
54c8c: 4fef 0010 lea %sp@(16),%sp
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
if (rc > 0)
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
54c90: 2400 movel %d0,%d2
if (rc > 0)
54c92: 6f16 bles 54caa <rtems_rfs_block_map_indirect_alloc+0x62><== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
54c94: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
54c98: 42a7 clrl %sp@- <== NOT EXECUTED
54c9a: 2f0c movel %a4,%sp@- <== NOT EXECUTED
54c9c: 4eb9 0004 d44a jsr 4d44a <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
54ca2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
54ca6: 6000 00bc braw 54d64 <rtems_rfs_block_map_indirect_alloc+0x11c><== NOT EXECUTED
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
54caa: 2f2c 0008 movel %a4@(8),%sp@-
54cae: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
54cb2: 206a 0006 moveal %a2@(6),%a0
54cb6: 2f28 001e movel %a0@(30),%sp@-
54cba: 4eb9 0005 b28c jsr 5b28c <memset>
if (upping)
54cc0: 4fef 000c lea %sp@(12),%sp
54cc4: 4a03 tstb %d3
54cc6: 6700 0088 beqw 54d50 <rtems_rfs_block_map_indirect_alloc+0x108>
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
54cca: 4878 2000 pea 2000 <D_MAX_EXP+0x1801>
54cce: 42a7 clrl %sp@-
54cd0: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
54cd6: 508f addql #8,%sp
54cd8: 4a00 tstb %d0
54cda: 6712 beqs 54cee <rtems_rfs_block_map_indirect_alloc+0xa6><== ALWAYS TAKEN
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
54cdc: 2f2b 0006 movel %a3@(6),%sp@- <== NOT EXECUTED
54ce0: 4879 0006 b2a9 pea 6b2a9 <CSWTCH.1+0x3> <== NOT EXECUTED
54ce6: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
54cec: 508f addql #8,%sp <== NOT EXECUTED
* @param block The block number of the indirect block allocated.
* @param upping True is upping the map to the next indirect level.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
54cee: 41eb 0022 lea %a3@(34),%a0
54cf2: 4280 clrl %d0
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
54cf4: 226a 0006 moveal %a2@(6),%a1
54cf8: 4be8 0001 lea %a0@(1),%a5
* @param block The block number of the indirect block allocated.
* @param upping True is upping the map to the next indirect level.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
54cfc: 2848 moveal %a0,%a4
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
54cfe: 568c addql #3,%a4
54d00: 2269 001e moveal %a1@(30),%a1
54d04: 1390 0800 moveb %a0@,%a1@(00000000,%d0:l)
54d08: 226a 0006 moveal %a2@(6),%a1
54d0c: 2269 001e moveal %a1@(30),%a1
54d10: 1395 0801 moveb %a5@,%a1@(00000001,%d0:l)
54d14: 226a 0006 moveal %a2@(6),%a1
54d18: 2218 movel %a0@+,%d1
54d1a: e089 lsrl #8,%d1
54d1c: 2269 001e moveal %a1@(30),%a1
54d20: 1381 0802 moveb %d1,%a1@(00000002,%d0:l)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
54d24: 7214 moveq #20,%d1
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
54d26: 226a 0006 moveal %a2@(6),%a1
54d2a: 2269 001e moveal %a1@(30),%a1
54d2e: 1394 0803 moveb %a4@,%a1@(00000003,%d0:l)
54d32: 14bc 0001 moveb #1,%a2@
54d36: 5880 addql #4,%d0
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
54d38: b280 cmpl %d0,%d1
54d3a: 66b8 bnes 54cf4 <rtems_rfs_block_map_indirect_alloc+0xac>
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
54d3c: 4878 0014 pea 14 <OPER2>
54d40: 42a7 clrl %sp@-
54d42: 486b 0022 pea %a3@(34)
54d46: 4eb9 0005 b28c jsr 5b28c <memset>
54d4c: 4fef 000c lea %sp@(12),%sp
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
54d50: 202e fffc movel %fp@(-4),%d0
map->last_map_block = new_block;
return 0;
54d54: 4282 clrl %d2
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
54d56: 206e 0014 moveal %fp@(20),%a0
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
54d5a: 14bc 0001 moveb #1,%a2@
*block = new_block;
54d5e: 2080 movel %d0,%a0@
map->last_map_block = new_block;
54d60: 2740 001a movel %d0,%a3@(26)
return 0;
}
54d64: 2002 movel %d2,%d0
54d66: 4cee 3c0c ffe4 moveml %fp@(-28),%d2-%d3/%a2-%a5
54d6c: 4e5e unlk %fp <== NOT EXECUTED
00054e24 <rtems_rfs_block_map_indirect_shrink.isra.7>:
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
54e24: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
54e28: 202e 0014 movel %fp@(20),%d0 <== NOT EXECUTED
54e2c: 48d7 040c moveml %d2-%d3/%a2,%sp@ <== NOT EXECUTED
54e30: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
54e34: 222e 0018 movel %fp@(24),%d1 <== NOT EXECUTED
* block to be freed and the indirect block is now also free, or we have only
* one indirect table and we can fit the remaining blocks into the inode,
* then either move to the next indirect block or move the remaining blocks
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
54e38: 670a beqs 54e44 <rtems_rfs_block_map_indirect_shrink.isra.7+0x20><== NOT EXECUTED
54e3a: 4a80 tstl %d0 <== NOT EXECUTED
54e3c: 6674 bnes 54eb2 <rtems_rfs_block_map_indirect_shrink.isra.7+0x8e><== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
54e3e: 7405 moveq #5,%d2 <== NOT EXECUTED
54e40: b481 cmpl %d1,%d2 <== NOT EXECUTED
54e42: 666e bnes 54eb2 <rtems_rfs_block_map_indirect_shrink.isra.7+0x8e><== NOT EXECUTED
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
54e44: 2432 0c22 movel %a2@(00000022,%d0:l:4),%d2 <== NOT EXECUTED
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
54e48: 4a80 tstl %d0 <== NOT EXECUTED
54e4a: 6646 bnes 54e92 <rtems_rfs_block_map_indirect_shrink.isra.7+0x6e><== NOT EXECUTED
54e4c: 7605 moveq #5,%d3 <== NOT EXECUTED
54e4e: b681 cmpl %d1,%d3 <== NOT EXECUTED
54e50: 6640 bnes 54e92 <rtems_rfs_block_map_indirect_shrink.isra.7+0x6e><== NOT EXECUTED
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
54e52: 206e 0010 moveal %fp@(16),%a0 <== NOT EXECUTED
54e56: 4281 clrl %d1 <== NOT EXECUTED
54e58: 2050 moveal %a0@,%a0 <== NOT EXECUTED
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
54e5a: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
54e5e: 4280 clrl %d0 <== NOT EXECUTED
54e60: 1010 moveb %a0@,%d0 <== NOT EXECUTED
54e62: 7618 moveq #24,%d3 <== NOT EXECUTED
54e64: e7a8 lsll %d3,%d0 <== NOT EXECUTED
54e66: 4283 clrl %d3 <== NOT EXECUTED
54e68: 1628 0001 moveb %a0@(1),%d3 <== NOT EXECUTED
54e6c: 4843 swap %d3 <== NOT EXECUTED
54e6e: 4243 clrw %d3 <== NOT EXECUTED
54e70: 8083 orl %d3,%d0 <== NOT EXECUTED
54e72: 4283 clrl %d3 <== NOT EXECUTED
54e74: 1628 0003 moveb %a0@(3),%d3 <== NOT EXECUTED
54e78: 8083 orl %d3,%d0 <== NOT EXECUTED
54e7a: 1628 0002 moveb %a0@(2),%d3 <== NOT EXECUTED
54e7e: 5888 addql #4,%a0 <== NOT EXECUTED
54e80: e18b lsll #8,%d3 <== NOT EXECUTED
54e82: 8083 orl %d3,%d0 <== NOT EXECUTED
54e84: 2580 1822 movel %d0,%a2@(00000022,%d1:l) <== NOT EXECUTED
54e88: 5881 addql #4,%d1 <== NOT EXECUTED
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
54e8a: 7014 moveq #20,%d0 <== NOT EXECUTED
54e8c: b081 cmpl %d1,%d0 <== NOT EXECUTED
54e8e: 66ce bnes 54e5e <rtems_rfs_block_map_indirect_shrink.isra.7+0x3a><== NOT EXECUTED
54e90: 6004 bras 54e96 <rtems_rfs_block_map_indirect_shrink.isra.7+0x72><== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
54e92: 42b2 0c22 clrl %a2@(00000022,%d0:l:4) <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
54e96: 2f02 movel %d2,%sp@- <== NOT EXECUTED
54e98: 42a7 clrl %sp@- <== NOT EXECUTED
54e9a: 2f2e 0008 movel %fp@(8),%sp@- <== NOT EXECUTED
54e9e: 4eb9 0004 d44a jsr 4d44a <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
54ea4: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
54ea8: 4a80 tstl %d0 <== NOT EXECUTED
54eaa: 6e08 bgts 54eb4 <rtems_rfs_block_map_indirect_shrink.isra.7+0x90><== NOT EXECUTED
return rc;
map->last_map_block = block_to_free;
54eac: 2542 001a movel %d2,%a2@(26) <== NOT EXECUTED
54eb0: 6002 bras 54eb4 <rtems_rfs_block_map_indirect_shrink.isra.7+0x90><== NOT EXECUTED
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
int rc = 0;
54eb2: 4280 clrl %d0 <== NOT EXECUTED
map->last_map_block = block_to_free;
}
return rc;
}
54eb4: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 <== NOT EXECUTED
54eba: 4e5e unlk %fp <== NOT EXECUTED
00054fe2 <rtems_rfs_block_map_open>:
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
54fe2: 4e56 ffe8 linkw %fp,#-24
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
54fe6: 4200 clrb %d0
54fe8: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
54fec: 246e 0010 moveal %fp@(16),%a2
54ff0: 266e 000c moveal %fp@(12),%a3
* sure the inode has been loaded into memory. If we did not load the inode
* do not unload it. The caller may assume it is still loaded when we return.
*/
map->dirty = false;
map->inode = NULL;
54ff4: 42aa 0002 clrl %a2@(2)
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
54ff8: 242e 0008 movel %fp@(8),%d2
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
54ffc: 42aa 0006 clrl %a2@(6)
* Set the count to 0 so at least find fails, then open the handle and make
* sure the inode has been loaded into memory. If we did not load the inode
* do not unload it. The caller may assume it is still loaded when we return.
*/
map->dirty = false;
55000: 4212 clrb %a2@
size->offset = 0;
55002: 42aa 000a clrl %a2@(10)
55006: 1540 0036 moveb %d0,%a2@(54)
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
5500a: 42aa 000e clrl %a2@(14)
5500e: 1540 0040 moveb %d0,%a2@(64)
bpos->boff = 0;
55012: 42aa 0012 clrl %a2@(18)
bpos->block = 0;
55016: 42aa 0016 clrl %a2@(22)
handle->bnum = 0;
5501a: 42aa 0038 clrl %a2@(56)
handle->buffer = NULL;
5501e: 42aa 003c clrl %a2@(60)
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
55022: 42aa 0042 clrl %a2@(66)
handle->buffer = NULL;
55026: 42aa 0046 clrl %a2@(70)
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
5502a: 2f0b movel %a3,%sp@-
5502c: 2f02 movel %d2,%sp@-
5502e: 4eb9 0004 d64c jsr 4d64c <rtems_rfs_inode_load>
if (rc > 0)
55034: 508f addql #8,%sp
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
55036: 2600 movel %d0,%d3
if (rc > 0)
55038: 6f42 bles 5507c <rtems_rfs_block_map_open+0x9a> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
5503a: 486a 0036 pea %a2@(54) <== NOT EXECUTED
5503e: 47f9 0005 5b88 lea 55b88 <rtems_rfs_buffer_handle_release>,%a3<== NOT EXECUTED
handle->dirty = false;
55044: 4204 clrb %d4 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55046: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55048: 4e93 jsr %a3@ <== NOT EXECUTED
handle->dirty = false;
5504a: 4201 clrb %d1 <== NOT EXECUTED
5504c: 1541 0036 moveb %d1,%a2@(54) <== NOT EXECUTED
handle->bnum = 0;
55050: 42aa 0038 clrl %a2@(56) <== NOT EXECUTED
handle->buffer = NULL;
55054: 42aa 003c clrl %a2@(60) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
55058: 486a 0040 pea %a2@(64) <== NOT EXECUTED
5505c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5505e: 4e93 jsr %a3@ <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &map->singly_buffer);
rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
return rc;
55060: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
55064: 2003 movel %d3,%d0 <== NOT EXECUTED
handle->dirty = false;
55066: 1544 0040 moveb %d4,%a2@(64) <== NOT EXECUTED
handle->bnum = 0;
5506a: 42aa 0042 clrl %a2@(66) <== NOT EXECUTED
handle->buffer = NULL;
5506e: 42aa 0046 clrl %a2@(70) <== NOT EXECUTED
55072: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 <== NOT EXECUTED
55078: 4e5e unlk %fp <== NOT EXECUTED
5507a: 4e75 rts <== NOT EXECUTED
int
rtems_rfs_block_map_free_all (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
return rtems_rfs_block_map_shrink (fs, map, map->size.count);
}
5507c: 206b 000c moveal %a3@(12),%a0
55080: 284a moveal %a2,%a4
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
55082: 43e8 001c lea %a0@(28),%a1
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
55086: 4281 clrl %d1
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
55088: 254b 0002 movel %a3,%a2@(2)
5508c: 4283 clrl %d3
5508e: 1630 1c1c moveb %a0@(0000001c,%d1:l:4),%d3
55092: 4280 clrl %d0
55094: 7818 moveq #24,%d4
55096: 1029 0003 moveb %a1@(3),%d0
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
5509a: 5281 addql #1,%d1
5509c: e9ab lsll %d4,%d3
5509e: 8083 orl %d3,%d0
550a0: 4283 clrl %d3
550a2: 1629 0001 moveb %a1@(1),%d3
550a6: 4843 swap %d3
550a8: 4243 clrw %d3
550aa: 8083 orl %d3,%d0
550ac: 4283 clrl %d3
550ae: 1629 0002 moveb %a1@(2),%d3
550b2: 5889 addql #4,%a1
550b4: e18b lsll #8,%d3
550b6: 8083 orl %d3,%d0
550b8: 2940 0022 movel %d0,%a4@(34)
550bc: 588c addql #4,%a4
550be: 7005 moveq #5,%d0
550c0: b081 cmpl %d1,%d0
550c2: 66c8 bnes 5508c <rtems_rfs_block_map_open+0xaa>
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
550c4: 4280 clrl %d0
550c6: 4281 clrl %d1
550c8: 1028 000c moveb %a0@(12),%d0
550cc: 1228 000d moveb %a0@(13),%d1
550d0: e9a8 lsll %d4,%d0
550d2: 4841 swap %d1
550d4: 4241 clrw %d1
550d6: 8081 orl %d1,%d0
550d8: 4281 clrl %d1
550da: 1228 000f moveb %a0@(15),%d1
550de: 8081 orl %d1,%d0
550e0: 1228 000e moveb %a0@(14),%d1
550e4: e189 lsll #8,%d1
550e6: 8081 orl %d1,%d0
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
550e8: 4281 clrl %d1
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
550ea: 2540 0006 movel %d0,%a2@(6)
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
550ee: 4280 clrl %d0
550f0: 1028 000a moveb %a0@(10),%d0
550f4: 1228 000b moveb %a0@(11),%d1
550f8: e188 lsll #8,%d0
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
550fa: 8081 orl %d1,%d0
550fc: 2540 000a movel %d0,%a2@(10)
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
55100: 4280 clrl %d0
55102: 1028 0030 moveb %a0@(48),%d0
55106: 1228 0031 moveb %a0@(49),%d1
5510a: e9a8 lsll %d4,%d0
5510c: 4841 swap %d1
5510e: 4241 clrw %d1
55110: 8081 orl %d1,%d0
55112: 4281 clrl %d1
55114: 1228 0033 moveb %a0@(51),%d1
55118: 8081 orl %d1,%d0
5511a: 1228 0032 moveb %a0@(50),%d1
5511e: e189 lsll #8,%d1
55120: 8081 orl %d1,%d0
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
55122: 4281 clrl %d1
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
55124: 2540 001a movel %d0,%a2@(26)
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
55128: 4280 clrl %d0
5512a: 1028 0034 moveb %a0@(52),%d0
5512e: 1228 0035 moveb %a0@(53),%d1
55132: e9a8 lsll %d4,%d0
55134: 4841 swap %d1
55136: 4241 clrw %d1
55138: 8081 orl %d1,%d0
5513a: 4281 clrl %d1
5513c: 1228 0037 moveb %a0@(55),%d1
55140: 8081 orl %d1,%d0
55142: 1228 0036 moveb %a0@(54),%d1
55146: e189 lsll #8,%d1
55148: 8081 orl %d1,%d0
5514a: 2540 001e movel %d0,%a2@(30)
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
5514e: 2d4b 000c movel %a3,%fp@(12)
55152: 2d42 0008 movel %d2,%fp@(8)
return rc;
}
55156: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
5515c: 42ae 0010 clrl %fp@(16)
return rc;
}
55160: 4e5e unlk %fp
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
55162: 4ef9 0004 d7a0 jmp 4d7a0 <rtems_rfs_inode_unload>
0005577a <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
5577a: 4e56 ffc0 linkw %fp,#-64
5577e: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
55782: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
55786: 266e 0008 moveal %fp@(8),%a3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
5578a: 42a7 clrl %sp@-
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
5578c: 246e 000c moveal %fp@(12),%a2
55790: 262e 0010 movel %fp@(16),%d3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
55794: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
5579a: 508f addql #8,%sp
5579c: 4a00 tstb %d0
5579e: 6716 beqs 557b6 <rtems_rfs_block_map_shrink+0x3c><== ALWAYS TAKEN
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
557a0: 2f2a 0006 movel %a2@(6),%sp@- <== NOT EXECUTED
557a4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
557a6: 4879 0006 b360 pea 6b360 <CSWTCH.1+0xba> <== NOT EXECUTED
557ac: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
557b2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
557b6: 202a 0006 movel %a2@(6),%d0
557ba: 6700 0244 beqw 55a00 <rtems_rfs_block_map_shrink+0x286>
557be: b083 cmpl %d3,%d0 <== NOT EXECUTED
557c0: 6400 01c0 bccw 55982 <rtems_rfs_block_map_shrink+0x208><== NOT EXECUTED
557c4: 2600 movel %d0,%d3 <== NOT EXECUTED
557c6: 6000 01ba braw 55982 <rtems_rfs_block_map_shrink+0x208><== NOT EXECUTED
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
557ca: 202a 0006 movel %a2@(6),%d0 <== NOT EXECUTED
if (block < RTEMS_RFS_INODE_BLOCKS)
557ce: 7204 moveq #4,%d1 <== NOT EXECUTED
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
557d0: 5380 subql #1,%d0 <== NOT EXECUTED
if (block < RTEMS_RFS_INODE_BLOCKS)
557d2: b280 cmpl %d0,%d1 <== NOT EXECUTED
557d4: 650c bcss 557e2 <rtems_rfs_block_map_shrink+0x68><== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
557d6: 2432 0c22 movel %a2@(00000022,%d0:l:4),%d2 <== NOT EXECUTED
map->blocks[block] = 0;
557da: 42b2 0c22 clrl %a2@(00000022,%d0:l:4) <== NOT EXECUTED
557de: 6000 017c braw 5595c <rtems_rfs_block_map_shrink+0x1e2><== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
557e2: 222b 0030 movel %a3@(48),%d1 <== NOT EXECUTED
557e6: 2a00 movel %d0,%d5 <== NOT EXECUTED
557e8: 4c41 5004 remul %d1,%d4,%d5 <== NOT EXECUTED
557ec: 4c41 5005 remul %d1,%d5,%d5 <== NOT EXECUTED
singly = block / fs->blocks_per_block;
if (block < fs->block_map_singly_blocks)
557f0: b0ab 0034 cmpl %a3@(52),%d0 <== NOT EXECUTED
557f4: 647c bccs 55872 <rtems_rfs_block_map_shrink+0xf8><== NOT EXECUTED
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
557f6: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
557fa: 2f32 5c22 movel %a2@(00000022,%d5:l:4),%sp@- <== NOT EXECUTED
557fe: 2f2e ffea movel %fp@(-22),%sp@- <== NOT EXECUTED
55802: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55804: 4e94 jsr %a4@ <== NOT EXECUTED
map->blocks[singly], true);
if (rc > 0)
55806: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5580a: 4a80 tstl %d0 <== NOT EXECUTED
5580c: 6e00 01f4 bgtw 55a02 <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
55810: 206a 003c moveal %a2@(60),%a0 <== NOT EXECUTED
55814: 2004 movel %d4,%d0 <== NOT EXECUTED
55816: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
5581a: e588 lsll #2,%d0 <== NOT EXECUTED
5581c: 1430 0801 moveb %a0@(00000001,%d0:l),%d2 <== NOT EXECUTED
55820: 1c30 0800 moveb %a0@(00000000,%d0:l),%d6 <== NOT EXECUTED
55824: 1e30 0802 moveb %a0@(00000002,%d0:l),%d7 <== NOT EXECUTED
55828: 1d42 fffb moveb %d2,%fp@(-5) <== NOT EXECUTED
5582c: 1430 0803 moveb %a0@(00000003,%d0:l),%d2 <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
55830: 2f04 movel %d4,%sp@- <== NOT EXECUTED
55832: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55834: 2f2e ffee movel %fp@(-18),%sp@- <== NOT EXECUTED
55838: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5583a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5583c: 4eba f5e6 jsr %pc@(54e24 <rtems_rfs_block_map_indirect_shrink.isra.7>)<== NOT EXECUTED
singly, direct);
if (rc)
55840: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
55844: 4a80 tstl %d0 <== NOT EXECUTED
55846: 6600 01ba bnew 55a02 <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
5584a: 2006 movel %d6,%d0 <== NOT EXECUTED
5584c: 7218 moveq #24,%d1 <== NOT EXECUTED
5584e: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
55854: e3a8 lsll %d1,%d0 <== NOT EXECUTED
55856: 0287 0000 00ff andil #255,%d7 <== NOT EXECUTED
5585c: 8480 orl %d0,%d2 <== NOT EXECUTED
5585e: 4280 clrl %d0 <== NOT EXECUTED
55860: 102e fffb moveb %fp@(-5),%d0 <== NOT EXECUTED
55864: 4840 swap %d0 <== NOT EXECUTED
55866: 4240 clrw %d0 <== NOT EXECUTED
55868: e18f lsll #8,%d7 <== NOT EXECUTED
5586a: 8480 orl %d0,%d2 <== NOT EXECUTED
5586c: 8487 orl %d7,%d2 <== NOT EXECUTED
5586e: 6000 00ec braw 5595c <rtems_rfs_block_map_shrink+0x1e2><== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
55872: b0ab 0038 cmpl %a3@(56),%d0 <== NOT EXECUTED
55876: 6400 0140 bccw 559b8 <rtems_rfs_block_map_shrink+0x23e><== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
5587a: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
5587e: 4c41 5002 remul %d1,%d2,%d5 <== NOT EXECUTED
55882: 4c41 5005 remul %d1,%d5,%d5 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
55886: 2f32 5c22 movel %a2@(00000022,%d5:l:4),%sp@- <== NOT EXECUTED
5588a: 2f2e fff6 movel %fp@(-10),%sp@- <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
5588e: 2d42 fffc movel %d2,%fp@(-4) <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
55892: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55894: 4e94 jsr %a4@ <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
55896: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5589a: 4a80 tstl %d0 <== NOT EXECUTED
5589c: 6e00 0164 bgtw 55a02 <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
558a0: 206a 0046 moveal %a2@(70),%a0 <== NOT EXECUTED
558a4: 2002 movel %d2,%d0 <== NOT EXECUTED
558a6: 4281 clrl %d1 <== NOT EXECUTED
558a8: 4287 clrl %d7 <== NOT EXECUTED
558aa: 7c18 moveq #24,%d6 <== NOT EXECUTED
558ac: e588 lsll #2,%d0 <== NOT EXECUTED
558ae: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
558b2: 1230 0800 moveb %a0@(00000000,%d0:l),%d1 <== NOT EXECUTED
558b6: 1e30 0803 moveb %a0@(00000003,%d0:l),%d7 <== NOT EXECUTED
558ba: eda9 lsll %d6,%d1 <== NOT EXECUTED
558bc: 8e81 orl %d1,%d7 <== NOT EXECUTED
558be: 4281 clrl %d1 <== NOT EXECUTED
558c0: 1230 0801 moveb %a0@(00000001,%d0:l),%d1 <== NOT EXECUTED
558c4: 1030 0802 moveb %a0@(00000002,%d0:l),%d0 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
558c8: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
558cc: 4841 swap %d1 <== NOT EXECUTED
558ce: 4241 clrw %d1 <== NOT EXECUTED
558d0: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
558d6: 8e81 orl %d1,%d7 <== NOT EXECUTED
558d8: e188 lsll #8,%d0 <== NOT EXECUTED
558da: 8e80 orl %d0,%d7 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
558dc: 2f07 movel %d7,%sp@- <== NOT EXECUTED
558de: 2f2e ffea movel %fp@(-22),%sp@- <== NOT EXECUTED
558e2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
558e4: 4e94 jsr %a4@ <== NOT EXECUTED
singly, true);
if (rc > 0)
558e6: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
558ea: 4a80 tstl %d0 <== NOT EXECUTED
558ec: 6e00 0114 bgtw 55a02 <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
558f0: 206a 003c moveal %a2@(60),%a0 <== NOT EXECUTED
558f4: 2004 movel %d4,%d0 <== NOT EXECUTED
558f6: 4281 clrl %d1 <== NOT EXECUTED
558f8: 4282 clrl %d2 <== NOT EXECUTED
558fa: e588 lsll #2,%d0 <== NOT EXECUTED
558fc: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
55900: 1230 0800 moveb %a0@(00000000,%d0:l),%d1 <== NOT EXECUTED
55904: 1430 0803 moveb %a0@(00000003,%d0:l),%d2 <== NOT EXECUTED
55908: eda9 lsll %d6,%d1 <== NOT EXECUTED
5590a: 8481 orl %d1,%d2 <== NOT EXECUTED
5590c: 4281 clrl %d1 <== NOT EXECUTED
5590e: 1230 0801 moveb %a0@(00000001,%d0:l),%d1 <== NOT EXECUTED
55912: 1030 0802 moveb %a0@(00000002,%d0:l),%d0 <== NOT EXECUTED
55916: 4841 swap %d1 <== NOT EXECUTED
55918: 4241 clrw %d1 <== NOT EXECUTED
5591a: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
55920: 8481 orl %d1,%d2 <== NOT EXECUTED
55922: e188 lsll #8,%d0 <== NOT EXECUTED
55924: 8480 orl %d0,%d2 <== NOT EXECUTED
direct);
if (direct == 0)
55926: 4a84 tstl %d4 <== NOT EXECUTED
55928: 6632 bnes 5595c <rtems_rfs_block_map_shrink+0x1e2><== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
5592a: 2f07 movel %d7,%sp@- <== NOT EXECUTED
5592c: 42a7 clrl %sp@- <== NOT EXECUTED
5592e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55930: 4e95 jsr %a5@ <== NOT EXECUTED
if (rc > 0)
55932: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55936: 4a80 tstl %d0 <== NOT EXECUTED
55938: 6e00 00c8 bgtw 55a02 <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
map->last_map_block = singly;
5593c: 2547 001a movel %d7,%a2@(26) <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
55940: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
55944: 2f05 movel %d5,%sp@- <== NOT EXECUTED
55946: 2f2e fff2 movel %fp@(-14),%sp@- <== NOT EXECUTED
5594a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5594c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5594e: 4eba f4d4 jsr %pc@(54e24 <rtems_rfs_block_map_indirect_shrink.isra.7>)<== NOT EXECUTED
doubly, doubly_singly);
if (rc)
55952: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
55956: 4a80 tstl %d0 <== NOT EXECUTED
55958: 6600 00a8 bnew 55a02 <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
5595c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5595e: 42a7 clrl %sp@- <== NOT EXECUTED
55960: 2f0b movel %a3,%sp@- <== NOT EXECUTED
55962: 4e95 jsr %a5@ <== NOT EXECUTED
if (rc > 0)
55964: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55968: 4a80 tstl %d0 <== NOT EXECUTED
5596a: 6e00 0096 bgtw 55a02 <rtems_rfs_block_map_shrink+0x288><== NOT EXECUTED
return rc;
map->size.count--;
5596e: 53aa 0006 subql #1,%a2@(6) <== NOT EXECUTED
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
55972: 5383 subql #1,%d3 <== NOT EXECUTED
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
55974: 14bc 0001 moveb #1,%a2@ <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
55978: 42aa 000a clrl %a2@(10) <== NOT EXECUTED
map->last_data_block = block_to_free;
5597c: 2542 001e movel %d2,%a2@(30) <== NOT EXECUTED
55980: 6030 bras 559b2 <rtems_rfs_block_map_shrink+0x238><== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
55982: 41ea 0040 lea %a2@(64),%a0 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
55986: 2c0a movel %a2,%d6 <== NOT EXECUTED
55988: 0686 0000 0036 addil #54,%d6 <== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
5598e: 49f9 0005 5d00 lea 55d00 <rtems_rfs_buffer_handle_request>,%a4<== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
direct);
if (direct == 0)
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
55994: 4bf9 0004 d44a lea 4d44a <rtems_rfs_group_bitmap_free>,%a5 <== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
5599a: 2d48 fff6 movel %a0,%fp@(-10) <== NOT EXECUTED
int
rtems_rfs_block_map_free_all (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
return rtems_rfs_block_map_shrink (fs, map, map->size.count);
}
5599e: 41ea 0046 lea %a2@(70),%a0 <== NOT EXECUTED
559a2: 2d48 fff2 movel %a0,%fp@(-14) <== NOT EXECUTED
559a6: 41ea 003c lea %a2@(60),%a0 <== NOT EXECUTED
559aa: 2d46 ffea movel %d6,%fp@(-22) <== NOT EXECUTED
559ae: 2d48 ffee movel %a0,%fp@(-18) <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
559b2: 4a83 tstl %d3 <== NOT EXECUTED
559b4: 6600 fe14 bnew 557ca <rtems_rfs_block_map_shrink+0x50><== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
559b8: 202a 0006 movel %a2@(6),%d0 <== NOT EXECUTED
559bc: 6608 bnes 559c6 <rtems_rfs_block_map_shrink+0x24c><== NOT EXECUTED
{
map->last_map_block = 0;
559be: 42aa 001a clrl %a2@(26) <== NOT EXECUTED
map->last_data_block = 0;
559c2: 42aa 001e clrl %a2@(30) <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
559c6: 222a 000e movel %a2@(14),%d1 <== NOT EXECUTED
559ca: 6704 beqs 559d0 <rtems_rfs_block_map_shrink+0x256><== NOT EXECUTED
559cc: 4a80 tstl %d0 <== NOT EXECUTED
559ce: 6716 beqs 559e6 <rtems_rfs_block_map_shrink+0x26c><== NOT EXECUTED
559d0: b081 cmpl %d1,%d0 <== NOT EXECUTED
559d2: 6312 blss 559e6 <rtems_rfs_block_map_shrink+0x26c><== NOT EXECUTED
559d4: 2040 moveal %d0,%a0 <== NOT EXECUTED
559d6: 5388 subql #1,%a0 <== NOT EXECUTED
559d8: b1c1 cmpal %d1,%a0 <== NOT EXECUTED
559da: 6624 bnes 55a00 <rtems_rfs_block_map_shrink+0x286><== NOT EXECUTED
559dc: 222a 000a movel %a2@(10),%d1 <== NOT EXECUTED
559e0: b2aa 0012 cmpl %a2@(18),%d1 <== NOT EXECUTED
559e4: 641a bccs 55a00 <rtems_rfs_block_map_shrink+0x286><== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
559e6: 222a 000a movel %a2@(10),%d1 <== NOT EXECUTED
559ea: 2540 000e movel %d0,%a2@(14) <== NOT EXECUTED
559ee: 2541 0012 movel %d1,%a2@(18) <== NOT EXECUTED
559f2: 42aa 0016 clrl %a2@(22) <== NOT EXECUTED
559f6: 4a81 tstl %d1 <== NOT EXECUTED
559f8: 6706 beqs 55a00 <rtems_rfs_block_map_shrink+0x286><== NOT EXECUTED
559fa: 5380 subql #1,%d0 <== NOT EXECUTED
559fc: 2540 000e movel %d0,%a2@(14) <== NOT EXECUTED
return 0;
55a00: 4280 clrl %d0
}
55a02: 4cee 3cfc ffc0 moveml %fp@(-64),%d2-%d7/%a2-%a5
55a08: 4e5e unlk %fp <== NOT EXECUTED
0005a58a <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
5a58a: 4e56 0000 linkw %fp,#0
5a58e: 2f0a movel %a2,%sp@-
5a590: 246e 0008 moveal %fp@(8),%a2
5a594: 2f02 movel %d2,%sp@-
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
5a596: 4878 0040 pea 40 <DBL_MANT_DIG+0xb>
}
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
5a59a: 142e 000f moveb %fp@(15),%d2
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
5a59e: 42a7 clrl %sp@-
5a5a0: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
5a5a6: 508f addql #8,%sp
5a5a8: 4a00 tstb %d0
5a5aa: 672a beqs 5a5d6 <rtems_rfs_buffer_bdbuf_release+0x4c><== ALWAYS TAKEN
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
5a5ac: 203c 0006 a04c movel #434252,%d0 <== NOT EXECUTED
5a5b2: 4a02 tstb %d2 <== NOT EXECUTED
5a5b4: 6706 beqs 5a5bc <rtems_rfs_buffer_bdbuf_release+0x32><== NOT EXECUTED
5a5b6: 203c 0006 c882 movel #444546,%d0 <== NOT EXECUTED
5a5bc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5a5be: 2f2a 001a movel %a2@(26),%sp@- <== NOT EXECUTED
5a5c2: 2f2a 0036 movel %a2@(54),%sp@- <== NOT EXECUTED
5a5c6: 4879 0006 c88d pea 6c88d <status_code_to_errno+0x7f> <== NOT EXECUTED
5a5cc: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5a5d2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
5a5d6: 4a02 tstb %d2
5a5d8: 670a beqs 5a5e4 <rtems_rfs_buffer_bdbuf_release+0x5a>
sc = rtems_bdbuf_release_modified (buffer);
5a5da: 2f0a movel %a2,%sp@-
5a5dc: 4eb9 0005 137c jsr 5137c <rtems_bdbuf_release_modified>
5a5e2: 6008 bras 5a5ec <rtems_rfs_buffer_bdbuf_release+0x62>
else
sc = rtems_bdbuf_release (buffer);
5a5e4: 2f0a movel %a2,%sp@-
5a5e6: 4eb9 0005 12d2 jsr 512d2 <rtems_bdbuf_release>
5a5ec: 588f addql #4,%sp
if (sc != RTEMS_SUCCESSFUL)
5a5ee: 4a80 tstl %d0
5a5f0: 6702 beqs 5a5f4 <rtems_rfs_buffer_bdbuf_release+0x6a><== ALWAYS TAKEN
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-release: bdbuf-%s: %s(%d)\n",
modified ? "modified" : "not-modified",
rtems_status_text (sc), sc);
#endif
rc = EIO;
5a5f2: 7005 moveq #5,%d0 <== NOT EXECUTED
}
return rc;
}
5a5f4: 242e fff8 movel %fp@(-8),%d2
5a5f8: 246e fffc moveal %fp@(-4),%a2
5a5fc: 4e5e unlk %fp <== NOT EXECUTED
0005a540 <rtems_rfs_buffer_bdbuf_request>:
int
rtems_rfs_buffer_bdbuf_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block block,
bool read,
rtems_rfs_buffer** buffer)
{
5a540: 4e56 0000 linkw %fp,#0
5a544: 206e 0008 moveal %fp@(8),%a0
5a548: 202e 000c movel %fp@(12),%d0
5a54c: 222e 0014 movel %fp@(20),%d1
5a550: 2068 000c moveal %a0@(12),%a0
rtems_status_code sc;
int rc = 0;
if (read)
5a554: 4a2e 0013 tstb %fp@(19)
5a558: 6712 beqs 5a56c <rtems_rfs_buffer_bdbuf_request+0x2c>
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
5a55a: 2f01 movel %d1,%sp@-
5a55c: 2f00 movel %d0,%sp@-
5a55e: 2f28 0004 movel %a0@(4),%sp@-
5a562: 2f10 movel %a0@,%sp@-
5a564: 4eb9 0005 10b8 jsr 510b8 <rtems_bdbuf_read>
5a56a: 6010 bras 5a57c <rtems_rfs_buffer_bdbuf_request+0x3c>
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
5a56c: 2f01 movel %d1,%sp@-
5a56e: 2f00 movel %d0,%sp@-
5a570: 2f28 0004 movel %a0@(4),%sp@-
5a574: 2f10 movel %a0@,%sp@-
5a576: 4eb9 0005 0ff4 jsr 50ff4 <rtems_bdbuf_get>
5a57c: 4fef 0010 lea %sp@(16),%sp
if (sc != RTEMS_SUCCESSFUL)
5a580: 4a80 tstl %d0
5a582: 6702 beqs 5a586 <rtems_rfs_buffer_bdbuf_request+0x46><== ALWAYS TAKEN
{
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-bdbuf-request: block=%lu: bdbuf-%s: %d: %s\n",
block, read ? "read" : "get", sc, rtems_status_text (sc));
#endif
rc = EIO;
5a584: 7005 moveq #5,%d0 <== NOT EXECUTED
}
return rc;
}
5a586: 4e5e unlk %fp <== NOT EXECUTED
0005622e <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
5622e: 4e56 0000 linkw %fp,#0
56232: 2f0a movel %a2,%sp@-
56234: 246e 0008 moveal %fp@(8),%a2
56238: 2f02 movel %d2,%sp@-
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
5623a: 4878 0010 pea 10 <INVALID_OPERATION>
5623e: 42a7 clrl %sp@-
56240: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
56246: 508f addql #8,%sp
56248: 4a00 tstb %d0
5624a: 670e beqs 5625a <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-close: closing\n");
5624c: 4879 0006 b7bb pea 6b7bb <CSWTCH.1+0x515> <== NOT EXECUTED
56252: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
56258: 588f addql #4,%sp <== NOT EXECUTED
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
5625a: 206a 000c moveal %a2@(12),%a0
5625e: 2f28 0024 movel %a0@(36),%sp@-
56262: 2f0a movel %a2,%sp@-
56264: 4eb9 0005 6152 jsr 56152 <rtems_rfs_buffer_setblksize>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
5626a: 508f addql #8,%sp
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
5626c: 2400 movel %d0,%d2
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
5626e: 6f2e bles 5629e <rtems_rfs_buffer_close+0x70> <== ALWAYS TAKEN
56270: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
56274: 42a7 clrl %sp@- <== NOT EXECUTED
56276: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5627c: 508f addql #8,%sp <== NOT EXECUTED
5627e: 4a00 tstb %d0 <== NOT EXECUTED
56280: 671c beqs 5629e <rtems_rfs_buffer_close+0x70> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
56282: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56284: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
5628a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5628c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5628e: 4879 0006 b7dc pea 6b7dc <CSWTCH.1+0x536> <== NOT EXECUTED
56294: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5629a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rtems_disk_release (fs->disk);
5629e: 2f2a 000c movel %a2@(12),%sp@-
562a2: 4eb9 0004 4522 jsr 44522 <rtems_disk_release>
rc, strerror (rc));
}
#endif
return rc;
}
562a8: 246e fffc moveal %fp@(-4),%a2
562ac: 2002 movel %d2,%d0
562ae: 242e fff8 movel %fp@(-8),%d2
562b2: 4e5e unlk %fp
...
00055b88 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
55b88: 4e56 fff4 linkw %fp,#-12
55b8c: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
55b90: 246e 0008 moveal %fp@(8),%a2
55b94: 266e 000c moveal %fp@(12),%a3
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
55b98: 4aab 0006 tstl %a3@(6)
55b9c: 6700 0154 beqw 55cf2 <rtems_rfs_buffer_handle_release+0x16a>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
55ba0: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
55ba4: 42a7 clrl %sp@-
55ba6: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55bac: 508f addql #8,%sp
55bae: 4a00 tstb %d0
55bb0: 6740 beqs 55bf2 <rtems_rfs_buffer_handle_release+0x6a><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
55bb2: 206b 0006 moveal %a3@(6),%a0 <== NOT EXECUTED
55bb6: 2228 0032 movel %a0@(50),%d1 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
55bba: 41f9 0006 a04c lea 6a04c <rtems_filesystem_default_pathconf+0xb4>,%a0<== NOT EXECUTED
55bc0: 6606 bnes 55bc8 <rtems_rfs_buffer_handle_release+0x40><== NOT EXECUTED
55bc2: 41f9 0006 b412 lea 6b412 <CSWTCH.1+0x16c>,%a0 <== NOT EXECUTED
55bc8: 203c 0006 a04c movel #434252,%d0 <== NOT EXECUTED
55bce: 4a13 tstb %a3@ <== NOT EXECUTED
55bd0: 6706 beqs 55bd8 <rtems_rfs_buffer_handle_release+0x50><== NOT EXECUTED
55bd2: 203c 0006 b420 movel #439328,%d0 <== NOT EXECUTED
55bd8: 2f08 movel %a0,%sp@- <== NOT EXECUTED
55bda: 2f01 movel %d1,%sp@- <== NOT EXECUTED
55bdc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
55bde: 2f2b 0002 movel %a3@(2),%sp@- <== NOT EXECUTED
55be2: 4879 0006 b428 pea 6b428 <CSWTCH.1+0x182> <== NOT EXECUTED
55be8: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55bee: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
55bf2: 206b 0006 moveal %a3@(6),%a0
55bf6: 2028 0032 movel %a0@(50),%d0
55bfa: 6f06 bles 55c02 <rtems_rfs_buffer_handle_release+0x7a><== NEVER TAKEN
rtems_rfs_buffer_refs_down (handle);
55bfc: 5380 subql #1,%d0
55bfe: 2140 0032 movel %d0,%a0@(50)
if (rtems_rfs_buffer_refs (handle) == 0)
55c02: 4aa8 0032 tstl %a0@(50)
55c06: 6600 00e2 bnew 55cea <rtems_rfs_buffer_handle_release+0x162>
55c0a: 2f08 movel %a0,%sp@-
55c0c: 4eb9 0004 99e4 jsr 499e4 <_Chain_Extract>
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
55c12: 588f addql #4,%sp
55c14: 7002 moveq #2,%d0
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
55c16: 53aa 004c subql #1,%a2@(76)
if (rtems_rfs_fs_no_local_cache (fs))
55c1a: c092 andl %a2@,%d0
55c1c: 671c beqs 55c3a <rtems_rfs_buffer_handle_release+0xb2>
{
handle->buffer->user = (void*) 0;
55c1e: 206b 0006 moveal %a3@(6),%a0
rc = rtems_rfs_buffer_io_release (handle->buffer,
55c22: 4280 clrl %d0
55c24: 1013 moveb %a3@,%d0
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
55c26: 42a8 0036 clrl %a0@(54)
rc = rtems_rfs_buffer_io_release (handle->buffer,
55c2a: 2f00 movel %d0,%sp@-
55c2c: 2f08 movel %a0,%sp@-
55c2e: 4eb9 0005 a58a jsr 5a58a <rtems_rfs_buffer_bdbuf_release>
55c34: 2400 movel %d0,%d2
55c36: 6000 00ae braw 55ce6 <rtems_rfs_buffer_handle_release+0x15e>
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
55c3a: 202a 006c movel %a2@(108),%d0
55c3e: d0aa 005c addl %a2@(92),%d0
55c42: b0aa 003c cmpl %a2@(60),%d0
55c46: 6572 bcss 55cba <rtems_rfs_buffer_handle_release+0x132>
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
55c48: 4878 0200 pea 200 <DBL_MANT_DIG+0x1cb>
55c4c: 42a7 clrl %sp@-
55c4e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55c54: 508f addql #8,%sp
55c56: 4a00 tstb %d0
55c58: 6718 beqs 55c72 <rtems_rfs_buffer_handle_release+0xea><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-release: local cache overflow:"
55c5a: 202a 006c movel %a2@(108),%d0 <== NOT EXECUTED
55c5e: d0aa 005c addl %a2@(92),%d0 <== NOT EXECUTED
55c62: 2f00 movel %d0,%sp@- <== NOT EXECUTED
55c64: 4879 0006 b45c pea 6b45c <CSWTCH.1+0x1b6> <== NOT EXECUTED
55c6a: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55c70: 508f addql #8,%sp <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
55c72: 242a 006c movel %a2@(108),%d2
55c76: 41f9 0004 9a0c lea 49a0c <_Chain_Get>,%a0
55c7c: b4aa 005c cmpl %a2@(92),%d2
55c80: 6410 bccs 55c92 <rtems_rfs_buffer_handle_release+0x10a><== ALWAYS TAKEN
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
55c82: 486a 0050 pea %a2@(80) <== NOT EXECUTED
55c86: 4e90 jsr %a0@ <== NOT EXECUTED
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
55c88: 588f addql #4,%sp <== NOT EXECUTED
55c8a: 53aa 005c subql #1,%a2@(92) <== NOT EXECUTED
modified = false;
55c8e: 4201 clrb %d1 <== NOT EXECUTED
55c90: 600e bras 55ca0 <rtems_rfs_buffer_handle_release+0x118><== NOT EXECUTED
55c92: 486a 0060 pea %a2@(96)
55c96: 4e90 jsr %a0@
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
55c98: 588f addql #4,%sp
55c9a: 53aa 006c subql #1,%a2@(108)
modified = true;
55c9e: 7201 moveq #1,%d1
}
buffer->user = (void*) 0;
55ca0: 2040 moveal %d0,%a0
rc = rtems_rfs_buffer_io_release (buffer, modified);
55ca2: 7401 moveq #1,%d2
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
55ca4: 42a8 0036 clrl %a0@(54)
rc = rtems_rfs_buffer_io_release (buffer, modified);
55ca8: c481 andl %d1,%d2
55caa: 2f02 movel %d2,%sp@-
55cac: 2f00 movel %d0,%sp@-
55cae: 4eb9 0005 a58a jsr 5a58a <rtems_rfs_buffer_bdbuf_release>
55cb4: 508f addql #8,%sp
55cb6: 2400 movel %d0,%d2
55cb8: 6002 bras 55cbc <rtems_rfs_buffer_handle_release+0x134>
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
55cba: 4282 clrl %d2
}
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
}
if (rtems_rfs_buffer_dirty (handle))
55cbc: 4a13 tstb %a3@
55cbe: 6714 beqs 55cd4 <rtems_rfs_buffer_handle_release+0x14c>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
55cc0: 2f2b 0006 movel %a3@(6),%sp@-
55cc4: 486a 0060 pea %a2@(96)
55cc8: 4eb9 0004 99ac jsr 499ac <_Chain_Append>
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
55cce: 52aa 006c addql #1,%a2@(108)
55cd2: 6012 bras 55ce6 <rtems_rfs_buffer_handle_release+0x15e>
55cd4: 2f2b 0006 movel %a3@(6),%sp@-
55cd8: 486a 0050 pea %a2@(80)
55cdc: 4eb9 0004 99ac jsr 499ac <_Chain_Append>
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
55ce2: 52aa 005c addql #1,%a2@(92)
55ce6: 508f addql #8,%sp
55ce8: 6002 bras 55cec <rtems_rfs_buffer_handle_release+0x164>
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
55cea: 4282 clrl %d2
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
55cec: 42ab 0006 clrl %a3@(6)
55cf0: 6002 bras 55cf4 <rtems_rfs_buffer_handle_release+0x16c>
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
55cf2: 4282 clrl %d2
}
handle->buffer = NULL;
}
return rc;
}
55cf4: 2002 movel %d2,%d0
55cf6: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
55cfc: 4e5e unlk %fp <== NOT EXECUTED
00055d00 <rtems_rfs_buffer_handle_request>:
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
55d00: 4e56 ffec linkw %fp,#-20
55d04: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
55d08: 266e 0008 moveal %fp@(8),%a3
55d0c: 246e 000c moveal %fp@(12),%a2
55d10: 242e 0010 movel %fp@(16),%d2
55d14: 182e 0017 moveb %fp@(23),%d4
/*
* If the handle has a buffer release it. This allows a handle to be reused
* without needing to close then open it again.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
55d18: 4aaa 0006 tstl %a2@(6)
55d1c: 6748 beqs 55d66 <rtems_rfs_buffer_handle_request+0x66>
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
55d1e: 4a82 tstl %d2
55d20: 6708 beqs 55d2a <rtems_rfs_buffer_handle_request+0x2a><== NEVER TAKEN
55d22: b4aa 0002 cmpl %a2@(2),%d2
55d26: 6700 01dc beqw 55f04 <rtems_rfs_buffer_handle_request+0x204>
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
55d2a: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
55d2e: 42a7 clrl %sp@-
55d30: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55d36: 508f addql #8,%sp
55d38: 4a00 tstb %d0
55d3a: 6712 beqs 55d4e <rtems_rfs_buffer_handle_request+0x4e><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
55d3c: 2f2a 0002 movel %a2@(2),%sp@- <== NOT EXECUTED
55d40: 4879 0006 b496 pea 6b496 <CSWTCH.1+0x1f0> <== NOT EXECUTED
55d46: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55d4c: 508f addql #8,%sp <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
55d4e: 2f0a movel %a2,%sp@-
55d50: 2f0b movel %a3,%sp@-
55d52: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
if (rc > 0)
55d58: 508f addql #8,%sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
55d5a: 2600 movel %d0,%d3
if (rc > 0)
55d5c: 6e00 01a8 bgtw 55f06 <rtems_rfs_buffer_handle_request+0x206>
return rc;
handle->dirty = false;
handle->bnum = 0;
55d60: 42aa 0002 clrl %a2@(2)
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
if (rc > 0)
return rc;
handle->dirty = false;
55d64: 4212 clrb %a2@
handle->bnum = 0;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
55d66: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
55d6a: 42a7 clrl %sp@-
55d6c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55d72: 508f addql #8,%sp
55d74: 4a00 tstb %d0
55d76: 6710 beqs 55d88 <rtems_rfs_buffer_handle_request+0x88><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
55d78: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55d7a: 4879 0006 b4c9 pea 6b4c9 <CSWTCH.1+0x223> <== NOT EXECUTED
55d80: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55d86: 508f addql #8,%sp <== NOT EXECUTED
* currently attached to a handle. If it is share the access. A buffer could
* be shared where different parts of the block have separate functions. An
* example is an inode block and the file system needs to handle 2 inodes in
* the same block at the same time.
*/
if (fs->buffers_count)
55d88: 4aab 004c tstl %a3@(76)
55d8c: 6744 beqs 55dd2 <rtems_rfs_buffer_handle_request+0xd2>
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
55d8e: 2f02 movel %d2,%sp@-
55d90: 486b 004c pea %a3@(76)
55d94: 486b 0040 pea %a3@(64)
55d98: 4eba fd0e jsr %pc@(55aa8 <rtems_rfs_scan_chain>)
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
55d9c: 4fef 000c lea %sp@(12),%sp
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
55da0: 2540 0006 movel %d0,%a2@(6)
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
55da4: 672c beqs 55dd2 <rtems_rfs_buffer_handle_request+0xd2>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
55da6: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
55daa: 42a7 clrl %sp@-
55dac: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
55db2: 508f addql #8,%sp
55db4: 4a00 tstb %d0
55db6: 671a beqs 55dd2 <rtems_rfs_buffer_handle_request+0xd2><== ALWAYS TAKEN
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
rtems_rfs_buffer_refs (handle) + 1);
55db8: 206a 0006 moveal %a2@(6),%a0 <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
55dbc: 2068 0032 moveal %a0@(50),%a0 <== NOT EXECUTED
55dc0: 5288 addql #1,%a0 <== NOT EXECUTED
55dc2: 2f08 movel %a0,%sp@- <== NOT EXECUTED
55dc4: 4879 0006 b4ef pea 6b4ef <CSWTCH.1+0x249> <== NOT EXECUTED
55dca: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55dd0: 508f addql #8,%sp <== NOT EXECUTED
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
55dd2: 7002 moveq #2,%d0
55dd4: c093 andl %a3@,%d0
55dd6: 664a bnes 55e22 <rtems_rfs_buffer_handle_request+0x122>
55dd8: 4aaa 0006 tstl %a2@(6)
55ddc: 6644 bnes 55e22 <rtems_rfs_buffer_handle_request+0x122>
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
55dde: 4aab 005c tstl %a3@(92)
55de2: 6716 beqs 55dfa <rtems_rfs_buffer_handle_request+0xfa>
handle->buffer = rtems_rfs_scan_chain (&fs->release,
55de4: 2f02 movel %d2,%sp@-
55de6: 486b 005c pea %a3@(92)
55dea: 486b 0050 pea %a3@(80)
55dee: 4eba fcb8 jsr %pc@(55aa8 <rtems_rfs_scan_chain>)
55df2: 4fef 000c lea %sp@(12),%sp
55df6: 2540 0006 movel %d0,%a2@(6)
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
55dfa: 4aaa 0006 tstl %a2@(6)
55dfe: 6622 bnes 55e22 <rtems_rfs_buffer_handle_request+0x122>
55e00: 4aab 006c tstl %a3@(108)
55e04: 671c beqs 55e22 <rtems_rfs_buffer_handle_request+0x122>
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
55e06: 2f02 movel %d2,%sp@-
55e08: 486b 006c pea %a3@(108)
55e0c: 486b 0060 pea %a3@(96)
55e10: 4eba fc96 jsr %pc@(55aa8 <rtems_rfs_scan_chain>)
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
55e14: 4fef 000c lea %sp@(12),%sp
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
55e18: 2540 0006 movel %d0,%a2@(6)
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
55e1c: 6704 beqs 55e22 <rtems_rfs_buffer_handle_request+0x122>
rtems_rfs_buffer_mark_dirty (handle);
55e1e: 14bc 0001 moveb #1,%a2@
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
55e22: 4aaa 0006 tstl %a2@(6)
55e26: 6670 bnes 55e98 <rtems_rfs_buffer_handle_request+0x198>
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
55e28: 486a 0006 pea %a2@(6)
55e2c: 4280 clrl %d0
55e2e: 1004 moveb %d4,%d0
55e30: 2f00 movel %d0,%sp@-
55e32: 2f02 movel %d2,%sp@-
55e34: 2f0b movel %a3,%sp@-
55e36: 4eb9 0005 a540 jsr 5a540 <rtems_rfs_buffer_bdbuf_request>
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
55e3c: 206a 0006 moveal %a2@(6),%a0
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
55e40: 2600 movel %d0,%d3
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
if (rc > 0)
55e42: 4fef 0010 lea %sp@(16),%sp
55e46: 42a8 0004 clrl %a0@(4)
55e4a: 4290 clrl %a0@
55e4c: 4a80 tstl %d0
55e4e: 6f48 bles 55e98 <rtems_rfs_buffer_handle_request+0x198><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
55e50: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> <== NOT EXECUTED
55e54: 42a7 clrl %sp@- <== NOT EXECUTED
55e56: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
55e5c: 508f addql #8,%sp <== NOT EXECUTED
55e5e: 4a00 tstb %d0 <== NOT EXECUTED
55e60: 6700 00a4 beqw 55f06 <rtems_rfs_buffer_handle_request+0x206><== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
55e64: 2f03 movel %d3,%sp@- <== NOT EXECUTED
55e66: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
55e6c: 588f addql #4,%sp <== NOT EXECUTED
55e6e: 223c 0006 b492 movel #439442,%d1 <== NOT EXECUTED
55e74: 4a04 tstb %d4 <== NOT EXECUTED
55e76: 6706 beqs 55e7e <rtems_rfs_buffer_handle_request+0x17e><== NOT EXECUTED
55e78: 223c 0006 b094 movel #438420,%d1 <== NOT EXECUTED
55e7e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
55e80: 2f03 movel %d3,%sp@- <== NOT EXECUTED
55e82: 2f01 movel %d1,%sp@- <== NOT EXECUTED
55e84: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55e86: 4879 0006 b523 pea 6b523 <CSWTCH.1+0x27d> <== NOT EXECUTED
55e8c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55e92: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
55e96: 606e bras 55f06 <rtems_rfs_buffer_handle_request+0x206><== NOT EXECUTED
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
55e98: 206a 0006 moveal %a2@(6),%a0
55e9c: 52a8 0032 addql #1,%a0@(50)
55ea0: 2f08 movel %a0,%sp@-
55ea2: 486b 0040 pea %a3@(64)
55ea6: 4eb9 0004 99ac jsr 499ac <_Chain_Append>
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
handle->buffer->user = (void*) ((intptr_t) block);
55eac: 206a 0006 moveal %a2@(6),%a0
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
55eb0: 52ab 004c addql #1,%a3@(76)
handle->buffer->user = (void*) ((intptr_t) block);
55eb4: 2142 0036 movel %d2,%a0@(54)
handle->bnum = block;
55eb8: 2542 0002 movel %d2,%a2@(2)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
55ebc: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb>
55ec0: 42a7 clrl %sp@-
55ec2: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55ec8: 4fef 0010 lea %sp@(16),%sp
55ecc: 4a00 tstb %d0
55ece: 6734 beqs 55f04 <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
55ed0: 206a 0006 moveal %a2@(6),%a0 <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
55ed4: 2268 0032 moveal %a0@(50),%a1 <== NOT EXECUTED
55ed8: 203c 0006 b492 movel #439442,%d0 <== NOT EXECUTED
55ede: 2228 001a movel %a0@(26),%d1 <== NOT EXECUTED
55ee2: 4a04 tstb %d4 <== NOT EXECUTED
55ee4: 6706 beqs 55eec <rtems_rfs_buffer_handle_request+0x1ec><== NOT EXECUTED
55ee6: 203c 0006 b094 movel #438420,%d0 <== NOT EXECUTED
55eec: 2f09 movel %a1,%sp@- <== NOT EXECUTED
55eee: 2f01 movel %d1,%sp@- <== NOT EXECUTED
55ef0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
55ef2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55ef4: 4879 0006 b55b pea 6b55b <CSWTCH.1+0x2b5> <== NOT EXECUTED
55efa: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55f00: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
55f04: 4283 clrl %d3
}
55f06: 2003 movel %d3,%d0
55f08: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
55f0e: 4e5e unlk %fp <== NOT EXECUTED
00055f12 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
55f12: 4e56 ffb8 linkw %fp,#-72
55f16: 2f0a movel %a2,%sp@-
55f18: 246e 000c moveal %fp@(12),%a2
55f1c: 2f02 movel %d2,%sp@-
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
55f1e: 4878 0020 pea 20 <OPER2+0xc>
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
55f22: 242e 0008 movel %fp@(8),%d2
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
55f26: 42a7 clrl %sp@-
55f28: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55f2e: 508f addql #8,%sp
55f30: 4a00 tstb %d0
55f32: 6710 beqs 55f44 <rtems_rfs_buffer_open+0x32> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
55f34: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55f36: 4879 0006 b596 pea 6b596 <CSWTCH.1+0x2f0> <== NOT EXECUTED
55f3c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55f42: 508f addql #8,%sp <== NOT EXECUTED
if (stat (name, &st) < 0)
55f44: 486e ffba pea %fp@(-70)
55f48: 2f02 movel %d2,%sp@-
55f4a: 4eb9 0004 6960 jsr 46960 <stat>
55f50: 508f addql #8,%sp
55f52: 4a80 tstl %d0
55f54: 6c3c bges 55f92 <rtems_rfs_buffer_open+0x80> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
55f56: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
55f5a: 42a7 clrl %sp@- <== NOT EXECUTED
55f5c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
55f62: 508f addql #8,%sp <== NOT EXECUTED
55f64: 4a00 tstb %d0 <== NOT EXECUTED
55f66: 6700 00c6 beqw 5602e <rtems_rfs_buffer_open+0x11c> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
55f6a: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
if (stat (name, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
55f70: 2040 moveal %d0,%a0 <== NOT EXECUTED
55f72: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
55f74: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
55f7a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
55f7c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55f7e: 4879 0006 b5bb pea 6b5bb <CSWTCH.1+0x315> <== NOT EXECUTED
55f84: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55f8a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
55f8e: 6000 009e braw 5602e <rtems_rfs_buffer_open+0x11c> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
55f92: 202e ffc6 movel %fp@(-58),%d0
55f96: 0280 0000 f000 andil #61440,%d0
55f9c: 0c80 0000 6000 cmpil #24576,%d0
55fa2: 6724 beqs 55fc8 <rtems_rfs_buffer_open+0xb6> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
55fa4: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
55fa8: 42a7 clrl %sp@- <== NOT EXECUTED
55faa: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
55fb0: 508f addql #8,%sp <== NOT EXECUTED
55fb2: 4a00 tstb %d0 <== NOT EXECUTED
55fb4: 677c beqs 56032 <rtems_rfs_buffer_open+0x120> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
55fb6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55fb8: 4879 0006 b5e9 pea 6b5e9 <CSWTCH.1+0x343> <== NOT EXECUTED
55fbe: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55fc4: 508f addql #8,%sp <== NOT EXECUTED
55fc6: 606a bras 56032 <rtems_rfs_buffer_open+0x120> <== NOT EXECUTED
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
55fc8: 2f2e ffd4 movel %fp@(-44),%sp@-
55fcc: 2f2e ffd0 movel %fp@(-48),%sp@-
55fd0: 4eb9 0004 44ba jsr 444ba <rtems_disk_obtain>
if (!fs->disk)
55fd6: 508f addql #8,%sp
55fd8: 41f9 0004 f3d8 lea 4f3d8 <rtems_rfs_trace>,%a0
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
55fde: 2540 000c movel %d0,%a2@(12)
if (!fs->disk)
55fe2: 661e bnes 56002 <rtems_rfs_buffer_open+0xf0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
55fe4: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
55fe8: 42a7 clrl %sp@- <== NOT EXECUTED
55fea: 4e90 jsr %a0@ <== NOT EXECUTED
55fec: 508f addql #8,%sp <== NOT EXECUTED
55fee: 4a00 tstb %d0 <== NOT EXECUTED
55ff0: 6740 beqs 56032 <rtems_rfs_buffer_open+0x120> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
55ff2: 4879 0006 b61d pea 6b61d <CSWTCH.1+0x377> <== NOT EXECUTED
55ff8: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
55ffe: 588f addql #4,%sp <== NOT EXECUTED
56000: 6030 bras 56032 <rtems_rfs_buffer_open+0x120> <== NOT EXECUTED
}
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
56002: 4878 0020 pea 20 <OPER2+0xc>
56006: 42a7 clrl %sp@-
56008: 4e90 jsr %a0@
5600a: 508f addql #8,%sp
5600c: 4a00 tstb %d0
5600e: 6726 beqs 56036 <rtems_rfs_buffer_open+0x124> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
56010: 206a 000c moveal %a2@(12),%a0 <== NOT EXECUTED
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
56014: 2f28 0024 movel %a0@(36),%sp@- <== NOT EXECUTED
56018: 2f28 001c movel %a0@(28),%sp@- <== NOT EXECUTED
5601c: 4879 0006 b64c pea 6b64c <CSWTCH.1+0x3a6> <== NOT EXECUTED
56022: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56028: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5602c: 6008 bras 56036 <rtems_rfs_buffer_open+0x124> <== NOT EXECUTED
if (stat (name, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
return ENOENT;
5602e: 7002 moveq #2,%d0 <== NOT EXECUTED
56030: 6006 bras 56038 <rtems_rfs_buffer_open+0x126> <== NOT EXECUTED
fs->disk = rtems_disk_obtain (st.st_rdev);
if (!fs->disk)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
return EIO;
56032: 7005 moveq #5,%d0 <== NOT EXECUTED
56034: 6002 bras 56038 <rtems_rfs_buffer_open+0x126> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
56036: 4280 clrl %d0
}
56038: 242e ffb0 movel %fp@(-80),%d2
5603c: 246e ffb4 moveal %fp@(-76),%a2
56040: 4e5e unlk %fp <== NOT EXECUTED
00056152 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
56152: 4e56 0000 linkw %fp,#0
56156: 2f0a movel %a2,%sp@-
56158: 246e 0008 moveal %fp@(8),%a2
5615c: 2f02 movel %d2,%sp@-
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
5615e: 4878 0400 pea 400 <D_BIAS+0x2>
56162: 42a7 clrl %sp@-
56164: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
5616a: 508f addql #8,%sp
5616c: 4a00 tstb %d0
5616e: 6712 beqs 56182 <rtems_rfs_buffer_setblksize+0x30><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
56170: 2f2e 000c movel %fp@(12),%sp@- <== NOT EXECUTED
56174: 4879 0006 b715 pea 6b715 <CSWTCH.1+0x46f> <== NOT EXECUTED
5617a: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56180: 508f addql #8,%sp <== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
56182: 2f0a movel %a2,%sp@-
56184: 4eb9 0005 60d2 jsr 560d2 <rtems_rfs_buffers_release>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
5618a: 588f addql #4,%sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
5618c: 2400 movel %d0,%d2
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
5618e: 6f2e bles 561be <rtems_rfs_buffer_setblksize+0x6c><== ALWAYS TAKEN
56190: 4878 0400 pea 400 <D_BIAS+0x2> <== NOT EXECUTED
56194: 42a7 clrl %sp@- <== NOT EXECUTED
56196: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5619c: 508f addql #8,%sp <== NOT EXECUTED
5619e: 4a00 tstb %d0 <== NOT EXECUTED
561a0: 671c beqs 561be <rtems_rfs_buffer_setblksize+0x6c><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
561a2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
561a4: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
561aa: 2f00 movel %d0,%sp@- <== NOT EXECUTED
561ac: 2f02 movel %d2,%sp@- <== NOT EXECUTED
561ae: 4879 0006 b744 pea 6b744 <CSWTCH.1+0x49e> <== NOT EXECUTED
561b4: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
561ba: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
561be: 2f0a movel %a2,%sp@-
561c0: 4eb9 0005 6044 jsr 56044 <rtems_rfs_buffer_sync>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
561c6: 588f addql #4,%sp
rc = rtems_rfs_buffers_release (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
561c8: 2400 movel %d0,%d2
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
561ca: 6f2e bles 561fa <rtems_rfs_buffer_setblksize+0xa8><== ALWAYS TAKEN
561cc: 4878 0400 pea 400 <D_BIAS+0x2> <== NOT EXECUTED
561d0: 42a7 clrl %sp@- <== NOT EXECUTED
561d2: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
561d8: 508f addql #8,%sp <== NOT EXECUTED
561da: 4a00 tstb %d0 <== NOT EXECUTED
561dc: 671c beqs 561fa <rtems_rfs_buffer_setblksize+0xa8><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
561de: 2f02 movel %d2,%sp@- <== NOT EXECUTED
561e0: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
561e6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
561e8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
561ea: 4879 0006 b781 pea 6b781 <CSWTCH.1+0x4db> <== NOT EXECUTED
561f0: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
561f6: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
561fa: 206a 000c moveal %a2@(12),%a0
561fe: 486e 000c pea %fp@(12)
56202: 2f3c 8004 4204 movel #-2147204604,%sp@-
56208: 2f08 movel %a0,%sp@-
5620a: 2068 0028 moveal %a0@(40),%a0
5620e: 4e90 jsr %a0@
if (rc < 0)
56210: 4fef 000c lea %sp@(12),%sp
56214: 4a80 tstl %d0
56216: 6c0a bges 56222 <rtems_rfs_buffer_setblksize+0xd0><== ALWAYS TAKEN
rc = errno;
56218: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
5621e: 2040 moveal %d0,%a0 <== NOT EXECUTED
56220: 2010 movel %a0@,%d0 <== NOT EXECUTED
#endif
return rc;
}
56222: 242e fff8 movel %fp@(-8),%d2
56226: 246e fffc moveal %fp@(-4),%a2
5622a: 4e5e unlk %fp <== NOT EXECUTED
00056044 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
56044: 4e56 0000 linkw %fp,#0
56048: 2f0a movel %a2,%sp@-
5604a: 246e 0008 moveal %fp@(8),%a2
5604e: 2f02 movel %d2,%sp@-
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
56050: 4878 0020 pea 20 <OPER2+0xc>
56054: 42a7 clrl %sp@-
56056: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
5605c: 508f addql #8,%sp
5605e: 4a00 tstb %d0
56060: 670e beqs 56070 <rtems_rfs_buffer_sync+0x2c> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-sync: syncing\n");
56062: 4879 0006 b67c pea 6b67c <CSWTCH.1+0x3d6> <== NOT EXECUTED
56068: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
5606e: 588f addql #4,%sp <== NOT EXECUTED
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
56070: 206a 000c moveal %a2@(12),%a0
56074: 2f28 0004 movel %a0@(4),%sp@-
56078: 2f10 movel %a0@,%sp@-
5607a: 4eb9 0005 1512 jsr 51512 <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL)
56080: 508f addql #8,%sp
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
56082: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
56084: 672e beqs 560b4 <rtems_rfs_buffer_sync+0x70> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
56086: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
5608a: 42a7 clrl %sp@- <== NOT EXECUTED
5608c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56092: 508f addql #8,%sp <== NOT EXECUTED
56094: 4a00 tstb %d0 <== NOT EXECUTED
56096: 6720 beqs 560b8 <rtems_rfs_buffer_sync+0x74> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
56098: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5609a: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
560a0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
560a2: 4879 0006 b69c pea 6b69c <CSWTCH.1+0x3f6> <== NOT EXECUTED
560a8: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
560ae: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
560b2: 6004 bras 560b8 <rtems_rfs_buffer_sync+0x74> <== NOT EXECUTED
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
int result = 0;
560b4: 4282 clrl %d2
560b6: 6002 bras 560ba <rtems_rfs_buffer_sync+0x76>
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
560b8: 7405 moveq #5,%d2 <== NOT EXECUTED
}
rtems_disk_release (fs->disk);
560ba: 2f2a 000c movel %a2@(12),%sp@-
560be: 4eb9 0004 4522 jsr 44522 <rtems_disk_release>
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
560c4: 246e fffc moveal %fp@(-4),%a2
560c8: 2002 movel %d2,%d0
560ca: 242e fff8 movel %fp@(-8),%d2
560ce: 4e5e unlk %fp <== NOT EXECUTED
000560d2 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
560d2: 4e56 fff4 linkw %fp,#-12
560d6: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
560da: 4878 0040 pea 40 <DBL_MANT_DIG+0xb>
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
560de: 246e 0008 moveal %fp@(8),%a2
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
560e2: 42a7 clrl %sp@-
560e4: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
560ea: 508f addql #8,%sp
560ec: 4a00 tstb %d0
560ee: 671c beqs 5610c <rtems_rfs_buffers_release+0x3a> <== ALWAYS TAKEN
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
560f0: 2f2a 006c movel %a2@(108),%sp@- <== NOT EXECUTED
560f4: 2f2a 005c movel %a2@(92),%sp@- <== NOT EXECUTED
560f8: 2f2a 004c movel %a2@(76),%sp@- <== NOT EXECUTED
560fc: 4879 0006 b6cc pea 6b6cc <CSWTCH.1+0x426> <== NOT EXECUTED
56102: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56108: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
5610c: 42a7 clrl %sp@-
5610e: 486a 005c pea %a2@(92)
56112: 47fa f914 lea %pc@(55a28 <rtems_rfs_release_chain>),%a3
56116: 486a 0050 pea %a2@(80)
5611a: 4e93 jsr %a3@
5611c: 4fef 000c lea %sp@(12),%sp
56120: 2400 movel %d0,%d2
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
56122: 4878 0001 pea 1 <ADD>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
56126: 4680 notl %d0
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
56128: 486a 006c pea %a2@(108)
5612c: 486a 0060 pea %a2@(96)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
56130: d080 addl %d0,%d0
56132: 9180 subxl %d0,%d0
56134: c480 andl %d0,%d2
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
56136: 4e93 jsr %a3@
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
56138: 4fef 000c lea %sp@(12),%sp
5613c: 4a80 tstl %d0
5613e: 6f06 bles 56146 <rtems_rfs_buffers_release+0x74> <== ALWAYS TAKEN
56140: 4a82 tstl %d2 <== NOT EXECUTED
56142: 6602 bnes 56146 <rtems_rfs_buffers_release+0x74> <== NOT EXECUTED
56144: 2400 movel %d0,%d2 <== NOT EXECUTED
rrc = rc;
return rrc;
}
56146: 2002 movel %d2,%d0
56148: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
5614e: 4e5e unlk %fp <== NOT EXECUTED
00056758 <rtems_rfs_dir_add_entry>:
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
56758: 4e56 ff6c linkw %fp,#-148
5675c: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
56760: 2f3c 2000 0000 movel #536870912,%sp@-
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
56766: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
5676a: 42a7 clrl %sp@-
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
5676c: 286e 000c moveal %fp@(12),%a4
56770: 2e2e 0010 movel %fp@(16),%d7
56774: 282e 0014 movel %fp@(20),%d4
56778: 2c2e 0018 movel %fp@(24),%d6
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
5677c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
56782: 508f addql #8,%sp
56784: 4a00 tstb %d0
56786: 673e beqs 567c6 <rtems_rfs_dir_add_entry+0x6e> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
56788: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
5678c: 2447 moveal %d7,%a2 <== NOT EXECUTED
5678e: 4879 0006 bac2 pea 6bac2 <CSWTCH.1+0x81c> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
56794: 4282 clrl %d2 <== NOT EXECUTED
printf ("%c", name[c]);
56796: 4bf9 0005 b358 lea 5b358 <putchar>,%a5 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
5679c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
567a2: 508f addql #8,%sp <== NOT EXECUTED
567a4: 600c bras 567b2 <rtems_rfs_dir_add_entry+0x5a> <== NOT EXECUTED
567a6: 5282 addql #1,%d2 <== NOT EXECUTED
printf ("%c", name[c]);
567a8: 101a moveb %a2@+,%d0 <== NOT EXECUTED
567aa: 49c0 extbl %d0 <== NOT EXECUTED
567ac: 2f00 movel %d0,%sp@- <== NOT EXECUTED
567ae: 4e95 jsr %a5@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
567b0: 588f addql #4,%sp <== NOT EXECUTED
567b2: b882 cmpl %d2,%d4 <== NOT EXECUTED
567b4: 66f0 bnes 567a6 <rtems_rfs_dir_add_entry+0x4e> <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
567b6: 2f04 movel %d4,%sp@- <== NOT EXECUTED
567b8: 4879 0006 baeb pea 6baeb <CSWTCH.1+0x845> <== NOT EXECUTED
567be: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
567c4: 508f addql #8,%sp <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
567c6: 4bee ff9c lea %fp@(-100),%a5
567ca: 2f0d movel %a5,%sp@-
567cc: 2f0c movel %a4,%sp@-
567ce: 2f0b movel %a3,%sp@-
567d0: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open>
if (rc > 0)
567d6: 4fef 000c lea %sp@(12),%sp
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
567da: 2600 movel %d0,%d3
if (rc > 0)
567dc: 6e00 02d0 bgtw 56aae <rtems_rfs_dir_add_entry+0x356>
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
567e0: 2044 moveal %d4,%a0
567e2: 41e8 000a lea %a0@(10),%a0
567e6: 4201 clrb %d1
handle->bnum = 0;
567e8: 42ae fff4 clrl %fp@(-12)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
567ec: 1d41 fff2 moveb %d1,%fp@(-14)
handle->bnum = 0;
handle->buffer = NULL;
567f0: 42ae fff8 clrl %fp@(-8)
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
567f4: 42ae ffe6 clrl %fp@(-26)
bpos->boff = 0;
567f8: 42ae ffea clrl %fp@(-22)
bpos->block = 0;
567fc: 42ae ffee clrl %fp@(-18)
56800: 2d48 ff96 movel %a0,%fp@(-106)
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
56804: 486e fffc pea %fp@(-4)
56808: 486e ffe6 pea %fp@(-26)
5680c: 2f0d movel %a5,%sp@-
5680e: 2f0b movel %a3,%sp@-
56810: 4eb9 0005 5322 jsr 55322 <rtems_rfs_block_map_find>
if (rc > 0)
56816: 4fef 0010 lea %sp@(16),%sp
5681a: 4a80 tstl %d0
5681c: 6f00 008e blew 568ac <rtems_rfs_dir_add_entry+0x154>
{
if (rc != ENXIO)
56820: 7206 moveq #6,%d1
56822: b280 cmpl %d0,%d1
56824: 6730 beqs 56856 <rtems_rfs_dir_add_entry+0xfe> <== ALWAYS TAKEN
56826: 2600 movel %d0,%d3 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
56828: 2f3c 2000 0000 movel #536870912,%sp@- <== NOT EXECUTED
5682e: 42a7 clrl %sp@- <== NOT EXECUTED
56830: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56836: 508f addql #8,%sp <== NOT EXECUTED
56838: 4a00 tstb %d0 <== NOT EXECUTED
5683a: 6700 0258 beqw 56a94 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
5683e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56840: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
56846: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56848: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5684a: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
5684e: 4879 0006 baf6 pea 6baf6 <CSWTCH.1+0x850> <== NOT EXECUTED
56854: 6048 bras 5689e <rtems_rfs_dir_add_entry+0x146> <== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
56856: 486e fffc pea %fp@(-4)
5685a: 4878 0001 pea 1 <ADD>
5685e: 2f0d movel %a5,%sp@-
56860: 2f0b movel %a3,%sp@-
56862: 4eb9 0005 54be jsr 554be <rtems_rfs_block_map_grow>
if (rc > 0)
56868: 4fef 0010 lea %sp@(16),%sp
5686c: 4a80 tstl %d0
5686e: 6f40 bles 568b0 <rtems_rfs_dir_add_entry+0x158>
56870: 2600 movel %d0,%d3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
56872: 2f3c 2000 0000 movel #536870912,%sp@-
56878: 42a7 clrl %sp@-
5687a: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
56880: 508f addql #8,%sp
56882: 4a00 tstb %d0
56884: 6700 020e beqw 56a94 <rtems_rfs_dir_add_entry+0x33c>
printf ("rtems-rfs: dir-add-entry: "
56888: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5688a: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
56890: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56892: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56894: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56898: 4879 0006 bb3b pea 6bb3b <CSWTCH.1+0x895> <== NOT EXECUTED
5689e: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
568a4: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
568a8: 6000 01ea braw 56a94 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
568ac: 7401 moveq #1,%d2
568ae: 6002 bras 568b2 <rtems_rfs_dir_add_entry+0x15a>
"block map grow failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
read = false;
568b0: 4202 clrb %d2
}
bpos.bno++;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
568b2: 7001 moveq #1,%d0
}
read = false;
}
bpos.bno++;
568b4: 52ae ffe6 addql #1,%fp@(-26)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
568b8: c082 andl %d2,%d0
568ba: 2f00 movel %d0,%sp@-
568bc: 2f2e fffc movel %fp@(-4),%sp@-
568c0: 486e fff2 pea %fp@(-14)
568c4: 2f0b movel %a3,%sp@-
568c6: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
if (rc > 0)
568cc: 4fef 0010 lea %sp@(16),%sp
568d0: 4a80 tstl %d0
568d2: 6f30 bles 56904 <rtems_rfs_dir_add_entry+0x1ac> <== ALWAYS TAKEN
568d4: 2600 movel %d0,%d3 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
568d6: 2f3c 2000 0000 movel #536870912,%sp@- <== NOT EXECUTED
568dc: 42a7 clrl %sp@- <== NOT EXECUTED
568de: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
568e4: 508f addql #8,%sp <== NOT EXECUTED
568e6: 4a00 tstb %d0 <== NOT EXECUTED
568e8: 6700 01aa beqw 56a94 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
568ec: 2f03 movel %d3,%sp@- <== NOT EXECUTED
568ee: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
568f4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
568f6: 2f03 movel %d3,%sp@- <== NOT EXECUTED
568f8: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
568fc: 4879 0006 bb80 pea 6bb80 <CSWTCH.1+0x8da> <== NOT EXECUTED
56902: 609a bras 5689e <rtems_rfs_dir_add_entry+0x146> <== NOT EXECUTED
"block buffer req failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
entry = rtems_rfs_buffer_data (&buffer);
56904: 206e fff8 moveal %fp@(-8),%a0
56908: 2468 001e moveal %a0@(30),%a2
if (!read)
5690c: 4a02 tstb %d2
5690e: 6614 bnes 56924 <rtems_rfs_dir_add_entry+0x1cc>
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
56910: 2f2b 0008 movel %a3@(8),%sp@-
56914: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
56918: 2f0a movel %a2,%sp@-
5691a: 4eb9 0005 b28c jsr 5b28c <memset>
56920: 4fef 000c lea %sp@(12),%sp
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
56924: 222b 0008 movel %a3@(8),%d1
56928: 2041 moveal %d1,%a0
5692a: 41e8 fff6 lea %a0@(-10),%a0
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
5692e: 4285 clrl %d5
56930: 2241 moveal %d1,%a1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
56932: 6000 0156 braw 56a8a <rtems_rfs_dir_add_entry+0x332>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
56936: 4282 clrl %d2
56938: 142a 0008 moveb %a2@(8),%d2
5693c: 4280 clrl %d0
5693e: 102a 0009 moveb %a2@(9),%d0
eino = rtems_rfs_dir_entry_ino (entry);
56942: 122a 0002 moveb %a2@(2),%d1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
56946: e18a lsll #8,%d2
eino = rtems_rfs_dir_entry_ino (entry);
56948: 1612 moveb %a2@,%d3
5694a: 1d41 ff9b moveb %d1,%fp@(-101)
5694e: 122a 0003 moveb %a2@(3),%d1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
56952: 8480 orl %d0,%d2
eino = rtems_rfs_dir_entry_ino (entry);
56954: 1d41 ff95 moveb %d1,%fp@(-107)
56958: 102a 0001 moveb %a2@(1),%d0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
5695c: 0c82 0000 ffff cmpil #65535,%d2
56962: 6600 009e bnew 56a02 <rtems_rfs_dir_add_entry+0x2aa>
56966: 2209 movel %a1,%d1
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
56968: 9285 subl %d5,%d1
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
5696a: b2ae ff96 cmpl %fp@(-106),%d1
5696e: 6300 fe94 blsw 56804 <rtems_rfs_dir_add_entry+0xac>
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
56972: 2f04 movel %d4,%sp@-
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
56974: 4283 clrl %d3
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
56976: 2f07 movel %d7,%sp@-
rtems_rfs_dir_set_entry_hash (entry, hash);
56978: 343c 0018 movew #24,%d2
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
5697c: 4eb9 0005 a600 jsr 5a600 <rtems_rfs_dir_hash>
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
56982: 1546 0003 moveb %d6,%a2@(3)
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
56986: 2200 movel %d0,%d1
56988: e4a9 lsrl %d2,%d1
5698a: 1541 0004 moveb %d1,%a2@(4)
5698e: 2200 movel %d0,%d1
56990: 4241 clrw %d1
56992: 4841 swap %d1
56994: 1540 0007 moveb %d0,%a2@(7)
56998: 1541 0005 moveb %d1,%a2@(5)
5699c: 2200 movel %d0,%d1
rtems_rfs_dir_set_entry_ino (entry, ino);
5699e: 2006 movel %d6,%d0
569a0: e4a8 lsrl %d2,%d0
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
569a2: e089 lsrl #8,%d1
rtems_rfs_dir_set_entry_ino (entry, ino);
569a4: 1480 moveb %d0,%a2@
569a6: 2006 movel %d6,%d0
569a8: 4240 clrw %d0
569aa: 4840 swap %d0
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
569ac: 1541 0006 moveb %d1,%a2@(6)
rtems_rfs_dir_set_entry_ino (entry, ino);
569b0: 1540 0001 moveb %d0,%a2@(1)
569b4: 2006 movel %d6,%d0
569b6: e088 lsrl #8,%d0
569b8: 1540 0002 moveb %d0,%a2@(2)
rtems_rfs_dir_set_entry_length (entry,
569bc: 2004 movel %d4,%d0
569be: 0680 0000 000a addil #10,%d0
569c4: 2200 movel %d0,%d1
569c6: e089 lsrl #8,%d1
569c8: 1540 0009 moveb %d0,%a2@(9)
569cc: 1541 0008 moveb %d1,%a2@(8)
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
569d0: 2f04 movel %d4,%sp@-
569d2: 2f07 movel %d7,%sp@-
569d4: 486a 000a pea %a2@(10)
569d8: 4eb9 0005 b134 jsr 5b134 <memcpy>
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
569de: 486e fff2 pea %fp@(-14)
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
569e2: 7001 moveq #1,%d0
rtems_rfs_buffer_handle_close (fs, &buffer);
569e4: 2f0b movel %a3,%sp@-
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
569e6: 1d40 fff2 moveb %d0,%fp@(-14)
rtems_rfs_buffer_handle_close (fs, &buffer);
569ea: 4eba f8cc jsr %pc@(562b8 <rtems_rfs_buffer_handle_close>)
rtems_rfs_block_map_close (fs, &map);
569ee: 486e ff9c pea %fp@(-100)
569f2: 2f0b movel %a3,%sp@-
569f4: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close>
return 0;
569fa: 4fef 0024 lea %sp@(36),%sp
569fe: 6000 00ae braw 56aae <rtems_rfs_dir_add_entry+0x356>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
56a02: 7218 moveq #24,%d1
56a04: 0280 0000 00ff andil #255,%d0
56a0a: e3ab lsll %d1,%d3
56a0c: 4281 clrl %d1
56a0e: 122e ff95 moveb %fp@(-107),%d1
56a12: 4840 swap %d0
56a14: 4240 clrw %d0
56a16: 8680 orl %d0,%d3
56a18: 4280 clrl %d0
56a1a: 102e ff9b moveb %fp@(-101),%d0
56a1e: 8681 orl %d1,%d3
56a20: e188 lsll #8,%d0
56a22: 8680 orl %d0,%d3
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
56a24: 700a moveq #10,%d0
56a26: b082 cmpl %d2,%d0
56a28: 6c10 bges 56a3a <rtems_rfs_dir_add_entry+0x2e2> <== NEVER TAKEN
56a2a: b4ab 0018 cmpl %a3@(24),%d2
56a2e: 640a bccs 56a3a <rtems_rfs_dir_add_entry+0x2e2> <== NEVER TAKEN
56a30: 4a83 tstl %d3
56a32: 6706 beqs 56a3a <rtems_rfs_dir_add_entry+0x2e2> <== NEVER TAKEN
56a34: b6ab 0010 cmpl %a3@(16),%d3
56a38: 634c blss 56a86 <rtems_rfs_dir_add_entry+0x32e> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
56a3a: 2f3c 2000 0000 movel #536870912,%sp@- <== NOT EXECUTED
56a40: 42a7 clrl %sp@- <== NOT EXECUTED
56a42: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56a48: 508f addql #8,%sp <== NOT EXECUTED
56a4a: 4a00 tstb %d0 <== NOT EXECUTED
56a4c: 671a beqs 56a68 <rtems_rfs_dir_add_entry+0x310> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
56a4e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
56a50: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56a52: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56a54: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56a58: 4879 0006 bbc7 pea 6bbc7 <CSWTCH.1+0x921> <== NOT EXECUTED
56a5e: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56a64: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
56a68: 486e fff2 pea %fp@(-14) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return EIO;
56a6c: 7605 moveq #5,%d3 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
56a6e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56a70: 4eba f846 jsr %pc@(562b8 <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
56a74: 486e ff9c pea %fp@(-100) <== NOT EXECUTED
56a78: 2f0b movel %a3,%sp@- <== NOT EXECUTED
56a7a: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
return EIO;
56a80: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
56a84: 6028 bras 56aae <rtems_rfs_dir_add_entry+0x356> <== NOT EXECUTED
}
entry += elength;
56a86: d5c2 addal %d2,%a2
offset += elength;
56a88: da82 addl %d2,%d5
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
56a8a: b1c5 cmpal %d5,%a0
56a8c: 6200 fea8 bhiw 56936 <rtems_rfs_dir_add_entry+0x1de>
56a90: 6000 fd72 braw 56804 <rtems_rfs_dir_add_entry+0xac> <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
56a94: 486e fff2 pea %fp@(-14)
56a98: 2f0b movel %a3,%sp@-
56a9a: 4eba f81c jsr %pc@(562b8 <rtems_rfs_buffer_handle_close>)
rtems_rfs_block_map_close (fs, &map);
56a9e: 486e ff9c pea %fp@(-100)
56aa2: 2f0b movel %a3,%sp@-
56aa4: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close>
return rc;
56aaa: 4fef 0010 lea %sp@(16),%sp
}
56aae: 2003 movel %d3,%d0
56ab0: 4cee 3cfc ff6c moveml %fp@(-148),%d2-%d7/%a2-%a5
56ab6: 4e5e unlk %fp <== NOT EXECUTED
00056aba <rtems_rfs_dir_del_entry>:
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
56aba: 4e56 ff78 linkw %fp,#-136
56abe: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56ac2: 2f3c 4000 0000 movel #1073741824,%sp@-
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
56ac8: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56acc: 42a7 clrl %sp@-
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
56ace: 286e 000c moveal %fp@(12),%a4
56ad2: 2a6e 0010 moveal %fp@(16),%a5
56ad6: 2e2e 0014 movel %fp@(20),%d7
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56ada: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
56ae0: 508f addql #8,%sp
56ae2: 4a00 tstb %d0
56ae4: 6718 beqs 56afe <rtems_rfs_dir_del_entry+0x44> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
56ae6: 2f07 movel %d7,%sp@- <== NOT EXECUTED
56ae8: 2f0d movel %a5,%sp@- <== NOT EXECUTED
56aea: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56aee: 4879 0006 bc0f pea 6bc0f <CSWTCH.1+0x969> <== NOT EXECUTED
56af4: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56afa: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
56afe: 260e movel %fp,%d3
56b00: 0683 ffff ffa8 addil #-88,%d3
56b06: 2f03 movel %d3,%sp@-
56b08: 2f0c movel %a4,%sp@-
56b0a: 2f0a movel %a2,%sp@-
56b0c: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open>
if (rc > 0)
56b12: 4fef 000c lea %sp@(12),%sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
56b16: 2400 movel %d0,%d2
if (rc > 0)
56b18: 6e00 02fa bgtw 56e14 <rtems_rfs_dir_del_entry+0x35a>
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
56b1c: 280e movel %fp,%d4
56b1e: 5984 subql #4,%d4
56b20: 2f04 movel %d4,%sp@-
56b22: 2f07 movel %d7,%sp@-
56b24: 42a7 clrl %sp@-
56b26: 2f03 movel %d3,%sp@-
56b28: 2f0a movel %a2,%sp@-
56b2a: 4eb9 0005 540e jsr 5540e <rtems_rfs_block_map_seek>
if (rc > 0)
56b30: 4fef 0014 lea %sp@(20),%sp
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
56b34: 2400 movel %d0,%d2
if (rc > 0)
56b36: 6f1a bles 56b52 <rtems_rfs_dir_del_entry+0x98> <== ALWAYS TAKEN
{
if (rc == ENXIO)
56b38: 7006 moveq #6,%d0 <== NOT EXECUTED
56b3a: b082 cmpl %d2,%d0 <== NOT EXECUTED
56b3c: 6602 bnes 56b40 <rtems_rfs_dir_del_entry+0x86> <== NOT EXECUTED
rc = ENOENT;
56b3e: 7402 moveq #2,%d2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
56b40: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
56b44: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56b46: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
56b4c: 508f addql #8,%sp <== NOT EXECUTED
56b4e: 6000 02c4 braw 56e14 <rtems_rfs_dir_del_entry+0x35a> <== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
56b52: 4a87 tstl %d7
56b54: 57c0 seq %d0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
56b56: 4201 clrb %d1
handle->bnum = 0;
56b58: 42ae fff4 clrl %fp@(-12)
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
56b5c: 4282 clrl %d2
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
56b5e: 1d41 fff2 moveb %d1,%fp@(-14)
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
56b62: 2200 movel %d0,%d1
56b64: 4481 negl %d1
handle->bnum = 0;
handle->buffer = NULL;
56b66: 42ae fff8 clrl %fp@(-8)
56b6a: 1d41 ffa7 moveb %d1,%fp@(-89)
while (rc == 0)
56b6e: 6000 0280 braw 56df0 <rtems_rfs_dir_del_entry+0x336>
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
56b72: 4878 0001 pea 1 <ADD>
56b76: 2f2e fffc movel %fp@(-4),%sp@-
56b7a: 486e fff2 pea %fp@(-14)
56b7e: 2f0a movel %a2,%sp@-
56b80: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
if (rc > 0)
56b86: 4fef 0010 lea %sp@(16),%sp
56b8a: 4a80 tstl %d0
56b8c: 6f3c bles 56bca <rtems_rfs_dir_del_entry+0x110> <== ALWAYS TAKEN
56b8e: 2c00 movel %d0,%d6 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56b90: 2f3c 4000 0000 movel #1073741824,%sp@- <== NOT EXECUTED
56b96: 42a7 clrl %sp@- <== NOT EXECUTED
56b98: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56b9e: 508f addql #8,%sp <== NOT EXECUTED
56ba0: 4a00 tstb %d0 <== NOT EXECUTED
56ba2: 6700 0254 beqw 56df8 <rtems_rfs_dir_del_entry+0x33e> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
56ba6: 2f06 movel %d6,%sp@- <== NOT EXECUTED
56ba8: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
56bae: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56bb0: 2f06 movel %d6,%sp@- <== NOT EXECUTED
56bb2: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56bb6: 4879 0006 bc48 pea 6bc48 <CSWTCH.1+0x9a2> <== NOT EXECUTED
56bbc: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56bc2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
56bc6: 6000 0230 braw 56df8 <rtems_rfs_dir_del_entry+0x33e> <== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
56bca: 4a2e ffa7 tstb %fp@(-89)
56bce: 660a bnes 56bda <rtems_rfs_dir_del_entry+0x120> <== NEVER TAKEN
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
56bd0: 2207 movel %d7,%d1
56bd2: 4c6a 1005 0008 remul %a2@(8),%d5,%d1
56bd8: 6002 bras 56bdc <rtems_rfs_dir_del_entry+0x122>
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
eoffset = 0;
56bda: 4285 clrl %d5 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
56bdc: 206e fff8 moveal %fp@(-8),%a0
56be0: 2240 moveal %d0,%a1
56be2: 2668 001e moveal %a0@(30),%a3
56be6: d7c5 addal %d5,%a3
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
56be8: 222a 0008 movel %a2@(8),%d1
56bec: 2041 moveal %d1,%a0
56bee: 41e8 fff6 lea %a0@(-10),%a0
56bf2: 6000 01d0 braw 56dc4 <rtems_rfs_dir_del_entry+0x30a>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
56bf6: 4283 clrl %d3
56bf8: 162b 0008 moveb %a3@(8),%d3
56bfc: 4280 clrl %d0
56bfe: 102b 0009 moveb %a3@(9),%d0
56c02: e18b lsll #8,%d3
eino = rtems_rfs_dir_entry_ino (entry);
56c04: 1813 moveb %a3@,%d4
56c06: 1c2b 0001 moveb %a3@(1),%d6
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
56c0a: 8680 orl %d0,%d3
eino = rtems_rfs_dir_entry_ino (entry);
56c0c: 102b 0002 moveb %a3@(2),%d0
56c10: 1d40 ffa3 moveb %d0,%fp@(-93)
56c14: 102b 0003 moveb %a3@(3),%d0
56c18: 1d40 ffa2 moveb %d0,%fp@(-94)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
56c1c: 0c83 0000 ffff cmpil #65535,%d3
56c22: 6700 01a6 beqw 56dca <rtems_rfs_dir_del_entry+0x310>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
56c26: 7018 moveq #24,%d0
56c28: 0286 0000 00ff andil #255,%d6
56c2e: e1ac lsll %d0,%d4
56c30: 4280 clrl %d0
56c32: 102e ffa2 moveb %fp@(-94),%d0
56c36: 4846 swap %d6
56c38: 4246 clrw %d6
56c3a: 8886 orl %d6,%d4
56c3c: 8880 orl %d0,%d4
56c3e: 102e ffa3 moveb %fp@(-93),%d0
56c42: e188 lsll #8,%d0
56c44: 8880 orl %d0,%d4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
56c46: 700a moveq #10,%d0
56c48: b083 cmpl %d3,%d0
56c4a: 6c10 bges 56c5c <rtems_rfs_dir_del_entry+0x1a2> <== NEVER TAKEN
56c4c: b6aa 0018 cmpl %a2@(24),%d3
56c50: 640a bccs 56c5c <rtems_rfs_dir_del_entry+0x1a2> <== NEVER TAKEN
56c52: 4a84 tstl %d4
56c54: 6706 beqs 56c5c <rtems_rfs_dir_del_entry+0x1a2> <== NEVER TAKEN
56c56: b8aa 0010 cmpl %a2@(16),%d4
56c5a: 6338 blss 56c94 <rtems_rfs_dir_del_entry+0x1da> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56c5c: 2f3c 4000 0000 movel #1073741824,%sp@- <== NOT EXECUTED
56c62: 42a7 clrl %sp@- <== NOT EXECUTED
56c64: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56c6a: 508f addql #8,%sp <== NOT EXECUTED
56c6c: 4a00 tstb %d0 <== NOT EXECUTED
56c6e: 6700 01b0 beqw 56e20 <rtems_rfs_dir_del_entry+0x366> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
56c72: 2f05 movel %d5,%sp@- <== NOT EXECUTED
56c74: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56c78: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56c7a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56c7c: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56c80: 4879 0006 bc8f pea 6bc8f <CSWTCH.1+0x9e9> <== NOT EXECUTED
56c86: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56c8c: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
56c90: 6000 018e braw 56e20 <rtems_rfs_dir_del_entry+0x366> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
56c94: b88d cmpl %a5,%d4
56c96: 6600 0122 bnew 56dba <rtems_rfs_dir_del_entry+0x300>
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
56c9a: 2005 movel %d5,%d0
56c9c: 2801 movel %d1,%d4
56c9e: d083 addl %d3,%d0
56ca0: 9880 subl %d0,%d4
memmove (entry, entry + elength, remaining);
56ca2: 2f04 movel %d4,%sp@-
56ca4: 4873 3800 pea %a3@(00000000,%d3:l)
56ca8: 2f0b movel %a3,%sp@-
56caa: 4eb9 0005 b1a4 jsr 5b1a4 <memmove>
memset (entry + remaining, 0xff, elength);
56cb0: 2f03 movel %d3,%sp@-
56cb2: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
56cb6: 4873 4800 pea %a3@(00000000,%d4:l)
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
56cba: 4283 clrl %d3
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
memmove (entry, entry + elength, remaining);
memset (entry + remaining, 0xff, elength);
56cbc: 4eb9 0005 b28c jsr 5b28c <memset>
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
56cc2: 4280 clrl %d0
56cc4: 162b 0008 moveb %a3@(8),%d3
56cc8: 102b 0009 moveb %a3@(9),%d0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56ccc: 2f3c 4000 0000 movel #1073741824,%sp@-
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
56cd2: e18b lsll #8,%d3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56cd4: 42a7 clrl %sp@-
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
56cd6: 8680 orl %d0,%d3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56cd8: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
56cde: 4fef 0020 lea %sp@(32),%sp
56ce2: 4a00 tstb %d0
56ce4: 6744 beqs 56d2a <rtems_rfs_dir_del_entry+0x270> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-del-entry: "
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
56ce6: 222e ffb6 movel %fp@(-74),%d1 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
56cea: 660c bnes 56cf8 <rtems_rfs_dir_del_entry+0x23e> <== NOT EXECUTED
56cec: 203c 0006 ac35 movel #437301,%d0 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
56cf2: 4aae ffae tstl %fp@(-82) <== NOT EXECUTED
56cf6: 6716 beqs 56d0e <rtems_rfs_dir_del_entry+0x254> <== NOT EXECUTED
56cf8: 206e ffae moveal %fp@(-82),%a0 <== NOT EXECUTED
56cfc: 5388 subql #1,%a0 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
56cfe: 203c 0006 b028 movel #438312,%d0 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
56d04: b1c1 cmpal %d1,%a0 <== NOT EXECUTED
56d06: 6606 bnes 56d0e <rtems_rfs_dir_del_entry+0x254> <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
56d08: 203c 0006 ac35 movel #437301,%d0 <== NOT EXECUTED
56d0e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56d10: 2f05 movel %d5,%sp@- <== NOT EXECUTED
56d12: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56d16: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56d18: 2f0d movel %a5,%sp@- <== NOT EXECUTED
56d1a: 4879 0006 bcdb pea 6bcdb <CSWTCH.1+0xa35> <== NOT EXECUTED
56d20: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56d26: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
56d2a: 0c83 0000 ffff cmpil #65535,%d3
56d30: 6666 bnes 56d98 <rtems_rfs_dir_del_entry+0x2de>
56d32: 4a85 tstl %d5
56d34: 6662 bnes 56d98 <rtems_rfs_dir_del_entry+0x2de> <== ALWAYS TAKEN
(eoffset == 0) && rtems_rfs_block_map_last (&map))
56d36: 202e ffb6 movel %fp@(-74),%d0 <== NOT EXECUTED
56d3a: 6606 bnes 56d42 <rtems_rfs_dir_del_entry+0x288> <== NOT EXECUTED
56d3c: 4aae ffae tstl %fp@(-82) <== NOT EXECUTED
56d40: 670a beqs 56d4c <rtems_rfs_dir_del_entry+0x292> <== NOT EXECUTED
56d42: 222e ffae movel %fp@(-82),%d1 <== NOT EXECUTED
56d46: 5381 subql #1,%d1 <== NOT EXECUTED
56d48: b280 cmpl %d0,%d1 <== NOT EXECUTED
56d4a: 664c bnes 56d98 <rtems_rfs_dir_del_entry+0x2de> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
56d4c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
56d50: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
56d54: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56d56: 4eb9 0005 577a jsr 5577a <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
56d5c: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
(eoffset == 0) && rtems_rfs_block_map_last (&map))
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
56d60: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
56d62: 6f34 bles 56d98 <rtems_rfs_dir_del_entry+0x2de> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
56d64: 2f3c 4000 0000 movel #1073741824,%sp@- <== NOT EXECUTED
56d6a: 42a7 clrl %sp@- <== NOT EXECUTED
56d6c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56d72: 508f addql #8,%sp <== NOT EXECUTED
56d74: 4a00 tstb %d0 <== NOT EXECUTED
56d76: 6720 beqs 56d98 <rtems_rfs_dir_del_entry+0x2de> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
56d78: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56d7a: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
56d80: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56d82: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56d84: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56d88: 4879 0006 bd3a pea 6bd3a <CSWTCH.1+0xa94> <== NOT EXECUTED
56d8e: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56d94: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
56d98: 486e fff2 pea %fp@(-14)
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
56d9c: 7201 moveq #1,%d1
rtems_rfs_buffer_handle_close (fs, &buffer);
56d9e: 2f0a movel %a2,%sp@-
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
56da0: 1d41 fff2 moveb %d1,%fp@(-14)
rtems_rfs_buffer_handle_close (fs, &buffer);
56da4: 4eba f512 jsr %pc@(562b8 <rtems_rfs_buffer_handle_close>)
rtems_rfs_block_map_close (fs, &map);
56da8: 486e ffa8 pea %fp@(-88)
56dac: 2f0a movel %a2,%sp@-
56dae: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close>
return 0;
56db4: 4fef 0010 lea %sp@(16),%sp
56db8: 605a bras 56e14 <rtems_rfs_dir_del_entry+0x35a>
}
if (!search)
56dba: 4a2e ffa7 tstb %fp@(-89) <== NOT EXECUTED
56dbe: 6760 beqs 56e20 <rtems_rfs_dir_del_entry+0x366> <== NOT EXECUTED
{
rc = EIO;
break;
}
entry += elength;
56dc0: d7c3 addal %d3,%a3 <== NOT EXECUTED
eoffset += elength;
56dc2: da83 addl %d3,%d5 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
56dc4: b1c5 cmpal %d5,%a0
56dc6: 6200 fe2e bhiw 56bf6 <rtems_rfs_dir_del_entry+0x13c>
56dca: 2009 movel %a1,%d0 <== NOT EXECUTED
entry += elength;
eoffset += elength;
}
if (rc == 0)
56dcc: 6620 bnes 56dee <rtems_rfs_dir_del_entry+0x334> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
56dce: 486e fffc pea %fp@(-4) <== NOT EXECUTED
56dd2: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
56dd6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56dd8: 4eb9 0005 548c jsr 5548c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
56dde: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
eoffset += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
56de2: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc == ENXIO)
56de4: 7006 moveq #6,%d0 <== NOT EXECUTED
56de6: b082 cmpl %d2,%d0 <== NOT EXECUTED
56de8: 6606 bnes 56df0 <rtems_rfs_dir_del_entry+0x336> <== NOT EXECUTED
rc = ENOENT;
56dea: 7402 moveq #2,%d2 <== NOT EXECUTED
56dec: 6008 bras 56df6 <rtems_rfs_dir_del_entry+0x33c> <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
56dee: 2400 movel %d0,%d2 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
56df0: 4a82 tstl %d2
56df2: 6700 fd7e beqw 56b72 <rtems_rfs_dir_del_entry+0xb8>
56df6: 2c02 movel %d2,%d6 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
56df8: 486e fff2 pea %fp@(-14) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
56dfc: 2406 movel %d6,%d2 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
56dfe: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56e00: 4eba f4b6 jsr %pc@(562b8 <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
56e04: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
56e08: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56e0a: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
56e10: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
56e14: 2002 movel %d2,%d0
56e16: 4cee 3cfc ff78 moveml %fp@(-136),%d2-%d7/%a2-%a5
56e1c: 4e5e unlk %fp
56e1e: 4e75 rts
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
56e20: 7005 moveq #5,%d0 <== NOT EXECUTED
56e22: 60ca bras 56dee <rtems_rfs_dir_del_entry+0x334> <== NOT EXECUTED
00057162 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
57162: 4e56 ff7c linkw %fp,#-132 <== NOT EXECUTED
57166: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
5716a: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
57170: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
57174: 42a7 clrl %sp@- <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
57176: 266e 000c moveal %fp@(12),%a3 <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
5717a: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
57180: 508f addql #8,%sp <== NOT EXECUTED
57182: 4a00 tstb %d0 <== NOT EXECUTED
57184: 6712 beqs 57198 <rtems_rfs_dir_empty+0x36> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
57186: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
5718a: 4879 0006 be5a pea 6be5a <CSWTCH.1+0xbb4> <== NOT EXECUTED
57190: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57196: 508f addql #8,%sp <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
57198: 260e movel %fp,%d3 <== NOT EXECUTED
5719a: 0683 ffff ffa8 addil #-88,%d3 <== NOT EXECUTED
571a0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
571a2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
571a4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
571a6: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
571ac: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
571b0: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
571b2: 6e00 019a bgtw 5734e <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
571b6: 280e movel %fp,%d4 <== NOT EXECUTED
571b8: 5984 subql #4,%d4 <== NOT EXECUTED
571ba: 2f04 movel %d4,%sp@- <== NOT EXECUTED
571bc: 42a7 clrl %sp@- <== NOT EXECUTED
571be: 42a7 clrl %sp@- <== NOT EXECUTED
571c0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
571c2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
571c4: 4eb9 0005 540e jsr 5540e <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
571ca: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
571ce: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
571d0: 6f10 bles 571e2 <rtems_rfs_dir_empty+0x80> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
571d2: 2f03 movel %d3,%sp@- <== NOT EXECUTED
571d4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
571d6: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
571dc: 508f addql #8,%sp <== NOT EXECUTED
571de: 6000 016e braw 5734e <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
571e2: 2e0e movel %fp,%d7 <== NOT EXECUTED
571e4: 0687 ffff fff2 addil #-14,%d7 <== NOT EXECUTED
571ea: 2c3c 0005 5d00 movel #351488,%d6 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
571f0: 4bf9 0004 f3d8 lea 4f3d8 <rtems_rfs_trace>,%a5 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
571f6: 49f9 0005 b318 lea 5b318 <printf>,%a4 <== NOT EXECUTED
571fc: 4200 clrb %d0 <== NOT EXECUTED
handle->bnum = 0;
571fe: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
57202: 1d40 fff2 moveb %d0,%fp@(-14) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
57206: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
5720a: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5720e: 2046 moveal %d6,%a0 <== NOT EXECUTED
57210: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
57214: 2f07 movel %d7,%sp@- <== NOT EXECUTED
57216: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57218: 4e90 jsr %a0@ <== NOT EXECUTED
if (rc > 0)
5721a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5721e: 4a80 tstl %d0 <== NOT EXECUTED
57220: 6e00 0110 bgtw 57332 <rtems_rfs_dir_empty+0x1d0> <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
57224: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
offset = 0;
57228: 4285 clrl %d5 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
5722a: 226a 0008 moveal %a2@(8),%a1 <== NOT EXECUTED
5722e: 43e9 fff6 lea %a1@(-10),%a1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
57232: 2068 001e moveal %a0@(30),%a0 <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
57236: 6000 00c2 braw 572fa <rtems_rfs_dir_empty+0x198> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
5723a: 4283 clrl %d3 <== NOT EXECUTED
5723c: 1628 0008 moveb %a0@(8),%d3 <== NOT EXECUTED
57240: 4281 clrl %d1 <== NOT EXECUTED
57242: 1228 0009 moveb %a0@(9),%d1 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
57246: 1428 0002 moveb %a0@(2),%d2 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
5724a: e18b lsll #8,%d3 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
5724c: 1810 moveb %a0@,%d4 <== NOT EXECUTED
5724e: 1d42 ffa7 moveb %d2,%fp@(-89) <== NOT EXECUTED
57252: 1428 0003 moveb %a0@(3),%d2 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
57256: 8681 orl %d1,%d3 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
57258: 1d42 ffa6 moveb %d2,%fp@(-90) <== NOT EXECUTED
5725c: 1228 0001 moveb %a0@(1),%d1 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
57260: 0c83 0000 ffff cmpil #65535,%d3 <== NOT EXECUTED
57266: 6700 0098 beqw 57300 <rtems_rfs_dir_empty+0x19e> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
5726a: 7418 moveq #24,%d2 <== NOT EXECUTED
5726c: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
57272: e5ac lsll %d2,%d4 <== NOT EXECUTED
57274: 4282 clrl %d2 <== NOT EXECUTED
57276: 142e ffa6 moveb %fp@(-90),%d2 <== NOT EXECUTED
5727a: 4841 swap %d1 <== NOT EXECUTED
5727c: 4241 clrw %d1 <== NOT EXECUTED
5727e: 8881 orl %d1,%d4 <== NOT EXECUTED
57280: 4281 clrl %d1 <== NOT EXECUTED
57282: 122e ffa7 moveb %fp@(-89),%d1 <== NOT EXECUTED
57286: 8882 orl %d2,%d4 <== NOT EXECUTED
57288: e189 lsll #8,%d1 <== NOT EXECUTED
5728a: 8881 orl %d1,%d4 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
5728c: 720a moveq #10,%d1 <== NOT EXECUTED
5728e: b283 cmpl %d3,%d1 <== NOT EXECUTED
57290: 6c10 bges 572a2 <rtems_rfs_dir_empty+0x140> <== NOT EXECUTED
57292: b6aa 0018 cmpl %a2@(24),%d3 <== NOT EXECUTED
57296: 640a bccs 572a2 <rtems_rfs_dir_empty+0x140> <== NOT EXECUTED
57298: 4a84 tstl %d4 <== NOT EXECUTED
5729a: 6706 beqs 572a2 <rtems_rfs_dir_empty+0x140> <== NOT EXECUTED
5729c: b8aa 0010 cmpl %a2@(16),%d4 <== NOT EXECUTED
572a0: 6326 blss 572c8 <rtems_rfs_dir_empty+0x166> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
572a2: 42a7 clrl %sp@- <== NOT EXECUTED
572a4: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
572a8: 4e95 jsr %a5@ <== NOT EXECUTED
572aa: 508f addql #8,%sp <== NOT EXECUTED
572ac: 4a00 tstb %d0 <== NOT EXECUTED
572ae: 6750 beqs 57300 <rtems_rfs_dir_empty+0x19e> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
572b0: 2f05 movel %d5,%sp@- <== NOT EXECUTED
572b2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
572b4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
572b6: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
572ba: 4879 0006 be79 pea 6be79 <CSWTCH.1+0xbd3> <== NOT EXECUTED
572c0: 4e94 jsr %a4@ <== NOT EXECUTED
572c2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
572c6: 6038 bras 57300 <rtems_rfs_dir_empty+0x19e> <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
572c8: 740b moveq #11,%d2 <== NOT EXECUTED
572ca: b483 cmpl %d3,%d2 <== NOT EXECUTED
572cc: 660c bnes 572da <rtems_rfs_dir_empty+0x178> <== NOT EXECUTED
572ce: 4281 clrl %d1 <== NOT EXECUTED
572d0: 1228 000a moveb %a0@(10),%d1 <== NOT EXECUTED
572d4: 143c 002e moveb #46,%d2 <== NOT EXECUTED
572d8: 6018 bras 572f2 <rtems_rfs_dir_empty+0x190> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
572da: 720c moveq #12,%d1 <== NOT EXECUTED
572dc: b283 cmpl %d3,%d1 <== NOT EXECUTED
572de: 6648 bnes 57328 <rtems_rfs_dir_empty+0x1c6> <== NOT EXECUTED
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
572e0: 4281 clrl %d1 <== NOT EXECUTED
572e2: 1228 000a moveb %a0@(10),%d1 <== NOT EXECUTED
572e6: 742e moveq #46,%d2 <== NOT EXECUTED
572e8: b481 cmpl %d1,%d2 <== NOT EXECUTED
572ea: 663c bnes 57328 <rtems_rfs_dir_empty+0x1c6> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
572ec: 4281 clrl %d1 <== NOT EXECUTED
572ee: 1228 000b moveb %a0@(11),%d1 <== NOT EXECUTED
572f2: b481 cmpl %d1,%d2 <== NOT EXECUTED
572f4: 6632 bnes 57328 <rtems_rfs_dir_empty+0x1c6> <== NOT EXECUTED
{
empty = false;
break;
}
entry += elength;
572f6: d1c3 addal %d3,%a0 <== NOT EXECUTED
offset += elength;
572f8: da83 addl %d3,%d5 <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
572fa: b3c5 cmpal %d5,%a1 <== NOT EXECUTED
572fc: 6200 ff3c bhiw 5723a <rtems_rfs_dir_empty+0xd8> <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
57300: 486e fffc pea %fp@(-4) <== NOT EXECUTED
57304: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
57308: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5730a: 4eb9 0005 548c jsr 5548c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc > 0)
57310: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57314: 4a80 tstl %d0 <== NOT EXECUTED
57316: 6f00 fef2 blew 5720a <rtems_rfs_dir_empty+0xa8> <== NOT EXECUTED
5731a: 2400 movel %d0,%d2 <== NOT EXECUTED
{
if (rc == ENXIO)
5731c: 7006 moveq #6,%d0 <== NOT EXECUTED
5731e: b082 cmpl %d2,%d0 <== NOT EXECUTED
57320: 56c0 sne %d0 <== NOT EXECUTED
57322: 49c0 extbl %d0 <== NOT EXECUTED
57324: c480 andl %d0,%d2 <== NOT EXECUTED
57326: 600c bras 57334 <rtems_rfs_dir_empty+0x1d2> <== NOT EXECUTED
57328: 2400 movel %d0,%d2 <== NOT EXECUTED
break;
}
}
}
if ((rc == 0) && !empty)
5732a: 6608 bnes 57334 <rtems_rfs_dir_empty+0x1d2> <== NOT EXECUTED
rc = ENOTEMPTY;
5732c: 143c 005a moveb #90,%d2 <== NOT EXECUTED
57330: 6002 bras 57334 <rtems_rfs_dir_empty+0x1d2> <== NOT EXECUTED
57332: 2400 movel %d0,%d2 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
57334: 486e fff2 pea %fp@(-14) <== NOT EXECUTED
57338: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5733a: 4eba ef7c jsr %pc@(562b8 <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
5733e: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
57342: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57344: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
5734a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
5734e: 2002 movel %d2,%d0 <== NOT EXECUTED
57350: 4cee 3cfc ff7c moveml %fp@(-132),%d2-%d7/%a2-%a5 <== NOT EXECUTED
57356: 4e5e unlk %fp <== NOT EXECUTED
...
0005a600 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
5a600: 4e56 ffec linkw %fp,#-20
break;
case 0 : return c; /* zero length requires no mixing */
}
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
5a604: 206e 0008 moveal %fp@(8),%a0
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
5a608: 48d7 007c moveml %d2-%d6,%sp@
5a60c: 282e 000c movel %fp@(12),%d4
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
5a610: 2004 movel %d4,%d0
5a612: 0680 dfdf 169f addil #-539027809,%d0
5a618: 2200 movel %d0,%d1
5a61a: 2240 moveal %d0,%a1
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
5a61c: 6000 00f2 braw 5a710 <rtems_rfs_dir_hash+0x110>
{
a += k[0];
5a620: 4282 clrl %d2
5a622: 1410 moveb %a0@,%d2
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
5a624: 4283 clrl %d3
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
5a626: 43f1 2800 lea %a1@(00000000,%d2:l),%a1
a += ((uint32_t)k[1])<<8;
5a62a: 1428 0001 moveb %a0@(1),%d2
a += ((uint32_t)k[2])<<16;
5a62e: 1628 0002 moveb %a0@(2),%d3
a += ((uint32_t)k[3])<<24;
5a632: 7a18 moveq #24,%d5
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
5a634: 7c1c moveq #28,%d6
length -= 12;
5a636: 0684 ffff fff4 addil #-12,%d4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
5a63c: e18a lsll #8,%d2
a += ((uint32_t)k[2])<<16;
5a63e: 4843 swap %d3
5a640: 4243 clrw %d3
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
5a642: d489 addl %a1,%d2
a += ((uint32_t)k[2])<<16;
5a644: d483 addl %d3,%d2
a += ((uint32_t)k[3])<<24;
5a646: 4283 clrl %d3
5a648: 1628 0003 moveb %a0@(3),%d3
5a64c: ebab lsll %d5,%d3
5a64e: d483 addl %d3,%d2
b += k[4];
5a650: 4283 clrl %d3
5a652: 1628 0004 moveb %a0@(4),%d3
5a656: d283 addl %d3,%d1
b += ((uint32_t)k[5])<<8;
5a658: 1628 0005 moveb %a0@(5),%d3
5a65c: e18b lsll #8,%d3
5a65e: d283 addl %d3,%d1
b += ((uint32_t)k[6])<<16;
5a660: 4283 clrl %d3
5a662: 1628 0006 moveb %a0@(6),%d3
5a666: 4843 swap %d3
5a668: 4243 clrw %d3
5a66a: d283 addl %d3,%d1
b += ((uint32_t)k[7])<<24;
5a66c: 4283 clrl %d3
5a66e: 1628 0007 moveb %a0@(7),%d3
5a672: ebab lsll %d5,%d3
5a674: d283 addl %d3,%d1
c += k[8];
5a676: 4283 clrl %d3
5a678: 1628 0008 moveb %a0@(8),%d3
5a67c: d083 addl %d3,%d0
c += ((uint32_t)k[9])<<8;
5a67e: 1628 0009 moveb %a0@(9),%d3
5a682: e18b lsll #8,%d3
5a684: d083 addl %d3,%d0
c += ((uint32_t)k[10])<<16;
5a686: 4283 clrl %d3
5a688: 1628 000a moveb %a0@(10),%d3
5a68c: 4843 swap %d3
5a68e: 4243 clrw %d3
5a690: d083 addl %d3,%d0
c += ((uint32_t)k[11])<<24;
5a692: 4283 clrl %d3
5a694: 1628 000b moveb %a0@(11),%d3
mix(a,b,c);
length -= 12;
k += 12;
5a698: 41e8 000c lea %a0@(12),%a0
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
5a69c: ebab lsll %d5,%d3
5a69e: d083 addl %d3,%d0
mix(a,b,c);
5a6a0: 2600 movel %d0,%d3
5a6a2: 2a00 movel %d0,%d5
5a6a4: ecad lsrl %d6,%d5
5a6a6: 9480 subl %d0,%d2
5a6a8: 1c3c 001a moveb #26,%d6
5a6ac: e98b lsll #4,%d3
5a6ae: 8685 orl %d5,%d3
5a6b0: 2a00 movel %d0,%d5
5a6b2: da81 addl %d1,%d5
5a6b4: b782 eorl %d3,%d2
5a6b6: 2002 movel %d2,%d0
5a6b8: 2602 movel %d2,%d3
5a6ba: ecab lsrl %d6,%d3
5a6bc: 9282 subl %d2,%d1
5a6be: 1c3c 0018 moveb #24,%d6
5a6c2: d485 addl %d5,%d2
5a6c4: ed88 lsll #6,%d0
5a6c6: 8083 orl %d3,%d0
5a6c8: b380 eorl %d1,%d0
5a6ca: 2200 movel %d0,%d1
5a6cc: 2600 movel %d0,%d3
5a6ce: ecab lsrl %d6,%d3
5a6d0: 9a80 subl %d0,%d5
5a6d2: d082 addl %d2,%d0
5a6d4: 1c3c 000d moveb #13,%d6
5a6d8: e189 lsll #8,%d1
5a6da: 8283 orl %d3,%d1
5a6dc: bb81 eorl %d5,%d1
5a6de: 7a13 moveq #19,%d5
5a6e0: 2601 movel %d1,%d3
5a6e2: 9481 subl %d1,%d2
5a6e4: 4843 swap %d3
5a6e6: b583 eorl %d2,%d3
5a6e8: 2401 movel %d1,%d2
5a6ea: d480 addl %d0,%d2
5a6ec: 2203 movel %d3,%d1
5a6ee: 9083 subl %d3,%d0
5a6f0: 2243 moveal %d3,%a1
5a6f2: d3c2 addal %d2,%a1
5a6f4: eba9 lsll %d5,%d1
5a6f6: 2a03 movel %d3,%d5
5a6f8: ecad lsrl %d6,%d5
5a6fa: 8285 orl %d5,%d1
5a6fc: 7a1c moveq #28,%d5
5a6fe: b181 eorl %d0,%d1
5a700: 2001 movel %d1,%d0
5a702: 2601 movel %d1,%d3
5a704: eaab lsrl %d5,%d3
5a706: 9481 subl %d1,%d2
5a708: d289 addl %a1,%d1
5a70a: e988 lsll #4,%d0
5a70c: 8083 orl %d3,%d0
5a70e: b580 eorl %d2,%d0
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
5a710: 7c0c moveq #12,%d6
5a712: bc84 cmpl %d4,%d6
5a714: 6500 ff0a bcsw 5a620 <rtems_rfs_dir_hash+0x20>
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
5a718: 5384 subql #1,%d4
5a71a: 740b moveq #11,%d2
5a71c: b484 cmpl %d4,%d2
5a71e: 6500 0118 bcsw 5a838 <rtems_rfs_dir_hash+0x238>
5a722: 343b 4a08 movew %pc@(5a72c <rtems_rfs_dir_hash+0x12c>,%d4:l:2),%d2
5a726: 48c2 extl %d2
5a728: 4efb 2802 jmp %pc@(5a72c <rtems_rfs_dir_hash+0x12c>,%d2:l)
5a72c: 0090 0086 007a oril #8781946,%d0 <== NOT EXECUTED
5a732: 006c .short 0x006c <== NOT EXECUTED
5a734: 0064 .short 0x0064 <== NOT EXECUTED
5a736: 005a .short 0x005a <== NOT EXECUTED
5a738: 004e .short 0x004e <== NOT EXECUTED
5a73a: 0042 .short 0x0042 <== NOT EXECUTED
5a73c: 003a .short 0x003a <== NOT EXECUTED
5a73e: 0030 .short 0x0030 <== NOT EXECUTED
5a740: 0024 .short 0x0024 <== NOT EXECUTED
5a742: 0018 .short 0x0018 <== NOT EXECUTED
{
case 12: c+=((uint32_t)k[11])<<24;
5a744: 4282 clrl %d2
5a746: 1428 000b moveb %a0@(11),%d2
5a74a: 7618 moveq #24,%d3
5a74c: e7aa lsll %d3,%d2
5a74e: d082 addl %d2,%d0
case 11: c+=((uint32_t)k[10])<<16;
5a750: 4282 clrl %d2
5a752: 1428 000a moveb %a0@(10),%d2
5a756: 4842 swap %d2
5a758: 4242 clrw %d2
5a75a: d082 addl %d2,%d0
case 10: c+=((uint32_t)k[9])<<8;
5a75c: 4282 clrl %d2
5a75e: 1428 0009 moveb %a0@(9),%d2
5a762: e18a lsll #8,%d2
5a764: d082 addl %d2,%d0
case 9 : c+=k[8];
5a766: 4282 clrl %d2
5a768: 1428 0008 moveb %a0@(8),%d2
5a76c: d082 addl %d2,%d0
case 8 : b+=((uint32_t)k[7])<<24;
5a76e: 4282 clrl %d2
5a770: 1428 0007 moveb %a0@(7),%d2
5a774: 7818 moveq #24,%d4
5a776: e9aa lsll %d4,%d2
5a778: d282 addl %d2,%d1
case 7 : b+=((uint32_t)k[6])<<16;
5a77a: 4282 clrl %d2
5a77c: 1428 0006 moveb %a0@(6),%d2
5a780: 4842 swap %d2
5a782: 4242 clrw %d2
5a784: d282 addl %d2,%d1
case 6 : b+=((uint32_t)k[5])<<8;
5a786: 4282 clrl %d2
5a788: 1428 0005 moveb %a0@(5),%d2
5a78c: e18a lsll #8,%d2
5a78e: d282 addl %d2,%d1
case 5 : b+=k[4];
5a790: 4282 clrl %d2
5a792: 1428 0004 moveb %a0@(4),%d2
5a796: d282 addl %d2,%d1
case 4 : a+=((uint32_t)k[3])<<24;
5a798: 4282 clrl %d2
5a79a: 1428 0003 moveb %a0@(3),%d2
5a79e: 7a18 moveq #24,%d5
5a7a0: ebaa lsll %d5,%d2
5a7a2: 43f1 2800 lea %a1@(00000000,%d2:l),%a1
case 3 : a+=((uint32_t)k[2])<<16;
5a7a6: 4282 clrl %d2
5a7a8: 1428 0002 moveb %a0@(2),%d2
5a7ac: 4842 swap %d2
5a7ae: 4242 clrw %d2
5a7b0: d3c2 addal %d2,%a1
case 2 : a+=((uint32_t)k[1])<<8;
5a7b2: 4282 clrl %d2
5a7b4: 1428 0001 moveb %a0@(1),%d2
5a7b8: e18a lsll #8,%d2
5a7ba: d3c2 addal %d2,%a1
break;
case 0 : return c;
}
}
final(a,b,c);
5a7bc: 2801 movel %d1,%d4
5a7be: 7a0e moveq #14,%d5
5a7c0: 2601 movel %d1,%d3
5a7c2: 7c12 moveq #18,%d6
5a7c4: ecab lsrl %d6,%d3
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
5a7c6: 4282 clrl %d2
break;
case 0 : return c;
}
}
final(a,b,c);
5a7c8: 1c3c 000b moveb #11,%d6
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
5a7cc: 1410 moveb %a0@,%d2
5a7ce: d489 addl %a1,%d2
break;
case 0 : return c;
}
}
final(a,b,c);
5a7d0: ebac lsll %d5,%d4
5a7d2: b380 eorl %d1,%d0
5a7d4: 1a3c 0015 moveb #21,%d5
5a7d8: 8684 orl %d4,%d3
5a7da: 9083 subl %d3,%d0
5a7dc: 2600 movel %d0,%d3
5a7de: 2800 movel %d0,%d4
5a7e0: eaac lsrl %d5,%d4
5a7e2: 1a3c 001c moveb #28,%d5
5a7e6: edab lsll %d6,%d3
5a7e8: b182 eorl %d0,%d2
5a7ea: 1c3c 0019 moveb #25,%d6
5a7ee: 8684 orl %d4,%d3
5a7f0: 9483 subl %d3,%d2
5a7f2: 2602 movel %d2,%d3
5a7f4: 2802 movel %d2,%d4
5a7f6: ee8c lsrl #7,%d4
5a7f8: edab lsll %d6,%d3
5a7fa: b581 eorl %d2,%d1
5a7fc: 1c3c 000e moveb #14,%d6
5a800: 8684 orl %d4,%d3
5a802: 9283 subl %d3,%d1
5a804: 2601 movel %d1,%d3
5a806: 4843 swap %d3
5a808: b380 eorl %d1,%d0
5a80a: 9083 subl %d3,%d0
5a80c: 2600 movel %d0,%d3
5a80e: 2800 movel %d0,%d4
5a810: eaac lsrl %d5,%d4
5a812: 1a3c 0018 moveb #24,%d5
5a816: e98b lsll #4,%d3
5a818: b182 eorl %d0,%d2
5a81a: 8684 orl %d4,%d3
5a81c: 7812 moveq #18,%d4
5a81e: 9483 subl %d3,%d2
5a820: 2602 movel %d2,%d3
5a822: b581 eorl %d2,%d1
5a824: edab lsll %d6,%d3
5a826: e8aa lsrl %d4,%d2
5a828: 8682 orl %d2,%d3
5a82a: 9283 subl %d3,%d1
5a82c: 2401 movel %d1,%d2
5a82e: b380 eorl %d1,%d0
5a830: ebaa lsll %d5,%d2
5a832: e089 lsrl #8,%d1
5a834: 8481 orl %d1,%d2
5a836: 9082 subl %d2,%d0
return c;
}
5a838: 4cd7 007c moveml %sp@,%d2-%d6
5a83c: 4e5e unlk %fp <== NOT EXECUTED
000562e2 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
562e2: 4e56 ff70 linkw %fp,#-144
562e6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
562ea: 2f3c 0400 0000 movel #67108864,%sp@-
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
562f0: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
562f4: 42a7 clrl %sp@-
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
562f6: 266e 000c moveal %fp@(12),%a3
562fa: 2e2e 0014 movel %fp@(20),%d7
562fe: 286e 0018 moveal %fp@(24),%a4
56302: 2a6e 001c moveal %fp@(28),%a5
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56306: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
5630c: 508f addql #8,%sp
5630e: 4a00 tstb %d0
56310: 6746 beqs 56358 <rtems_rfs_dir_lookup_ino+0x76> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
56312: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
56316: 4282 clrl %d2 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
56318: 4879 0006 b81a pea 6b81a <CSWTCH.1+0x574> <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
5631e: 283c 0005 b358 movel #373592,%d4 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
56324: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5632a: 262e 0010 movel %fp@(16),%d3 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
5632e: 508f addql #8,%sp <== NOT EXECUTED
56330: 6012 bras 56344 <rtems_rfs_dir_lookup_ino+0x62> <== NOT EXECUTED
printf ("%c", name[c]);
56332: 2043 moveal %d3,%a0 <== NOT EXECUTED
56334: 5283 addql #1,%d3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
56336: 5282 addql #1,%d2 <== NOT EXECUTED
printf ("%c", name[c]);
56338: 1018 moveb %a0@+,%d0 <== NOT EXECUTED
5633a: 2044 moveal %d4,%a0 <== NOT EXECUTED
5633c: 49c0 extbl %d0 <== NOT EXECUTED
5633e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56340: 4e90 jsr %a0@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
56342: 588f addql #4,%sp <== NOT EXECUTED
56344: be82 cmpl %d2,%d7 <== NOT EXECUTED
56346: 6eea bgts 56332 <rtems_rfs_dir_lookup_ino+0x50> <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
56348: 2f07 movel %d7,%sp@- <== NOT EXECUTED
5634a: 4879 0006 b851 pea 6b851 <CSWTCH.1+0x5ab> <== NOT EXECUTED
56350: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56356: 508f addql #8,%sp <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
56358: 4294 clrl %a4@
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
5635a: 260e movel %fp,%d3
5635c: 0683 ffff ffa8 addil #-88,%d3
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
56362: 4295 clrl %a5@
rc = rtems_rfs_block_map_open (fs, inode, &map);
56364: 2f03 movel %d3,%sp@-
56366: 2f0b movel %a3,%sp@-
56368: 2f0a movel %a2,%sp@-
5636a: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open>
if (rc > 0)
56370: 4fef 000c lea %sp@(12),%sp
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
56374: 2400 movel %d0,%d2
if (rc > 0)
56376: 6f3a bles 563b2 <rtems_rfs_dir_lookup_ino+0xd0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56378: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
5637e: 42a7 clrl %sp@- <== NOT EXECUTED
56380: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56386: 508f addql #8,%sp <== NOT EXECUTED
56388: 4a00 tstb %d0 <== NOT EXECUTED
5638a: 6700 03a2 beqw 5672e <rtems_rfs_dir_lookup_ino+0x44c> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
5638e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56390: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
56396: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56398: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5639a: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
5639e: 4879 0006 b85b pea 6b85b <CSWTCH.1+0x5b5> <== NOT EXECUTED
563a4: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
563aa: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
563ae: 6000 037e braw 5672e <rtems_rfs_dir_lookup_ino+0x44c> <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
563b2: 2f07 movel %d7,%sp@-
563b4: 2f2e 0010 movel %fp@(16),%sp@-
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
563b8: 280e movel %fp,%d4
563ba: 5984 subql #4,%d4
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
563bc: 4200 clrb %d0
handle->bnum = 0;
563be: 42ae fff4 clrl %fp@(-12)
handle->buffer = NULL;
563c2: 42ae fff8 clrl %fp@(-8)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
563c6: 1d40 fff2 moveb %d0,%fp@(-14)
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
563ca: 4eb9 0005 a600 jsr 5a600 <rtems_rfs_dir_hash>
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
563d0: 2f04 movel %d4,%sp@-
563d2: 42a7 clrl %sp@-
563d4: 42a7 clrl %sp@-
563d6: 2f03 movel %d3,%sp@-
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
563d8: 2d40 ffa4 movel %d0,%fp@(-92)
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
563dc: 2f0a movel %a2,%sp@-
563de: 4eb9 0005 540e jsr 5540e <rtems_rfs_block_map_seek>
if (rc > 0)
563e4: 4fef 001c lea %sp@(28),%sp
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
563e8: 2400 movel %d0,%d2
if (rc > 0)
563ea: 6f00 02d6 blew 566c2 <rtems_rfs_dir_lookup_ino+0x3e0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
563ee: 2f3c 0400 0000 movel #67108864,%sp@-
563f4: 42a7 clrl %sp@-
563f6: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
563fc: 508f addql #8,%sp
563fe: 4a00 tstb %d0
56400: 671c beqs 5641e <rtems_rfs_dir_lookup_ino+0x13c> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
56402: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56404: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
5640a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5640c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5640e: 4879 0006 b89a pea 6b89a <CSWTCH.1+0x5f4> <== NOT EXECUTED
56414: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5641a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
5641e: 7206 moveq #6,%d1
56420: b282 cmpl %d2,%d1
56422: 6600 02f0 bnew 56714 <rtems_rfs_dir_lookup_ino+0x432>
rc = ENOENT;
56426: 7402 moveq #2,%d2
56428: 6000 02ea braw 56714 <rtems_rfs_dir_lookup_ino+0x432>
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
5642c: 2046 moveal %d6,%a0
5642e: 2f3c 0400 0000 movel #67108864,%sp@-
56434: 42a7 clrl %sp@-
56436: 4e90 jsr %a0@
56438: 508f addql #8,%sp
5643a: 4a00 tstb %d0
5643c: 6716 beqs 56454 <rtems_rfs_dir_lookup_ino+0x172> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
5643e: 2f2e ffb6 movel %fp@(-74),%sp@- <== NOT EXECUTED
56442: 2045 moveal %d5,%a0 <== NOT EXECUTED
56444: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56448: 4879 0006 b8d4 pea 6b8d4 <CSWTCH.1+0x62e> <== NOT EXECUTED
5644e: 4e90 jsr %a0@ <== NOT EXECUTED
56450: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
56454: 4878 0001 pea 1 <ADD>
56458: 2f2e fffc movel %fp@(-4),%sp@-
5645c: 486e fff2 pea %fp@(-14)
56460: 2f0b movel %a3,%sp@-
56462: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
if (rc > 0)
56468: 4fef 0010 lea %sp@(16),%sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
5646c: 2800 movel %d0,%d4
if (rc > 0)
5646e: 6f40 bles 564b0 <rtems_rfs_dir_lookup_ino+0x1ce> <== ALWAYS TAKEN
56470: 244b moveal %a3,%a2 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56472: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
56478: 42a7 clrl %sp@- <== NOT EXECUTED
5647a: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56480: 508f addql #8,%sp <== NOT EXECUTED
56482: 4a00 tstb %d0 <== NOT EXECUTED
56484: 6700 0264 beqw 566ea <rtems_rfs_dir_lookup_ino+0x408> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
56488: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5648a: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
56490: 2f00 movel %d0,%sp@- <== NOT EXECUTED
56492: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56494: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56498: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
5649c: 4879 0006 b90c pea 6b90c <CSWTCH.1+0x666> <== NOT EXECUTED
564a2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
564a8: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
564ac: 6000 023c braw 566ea <rtems_rfs_dir_lookup_ino+0x408> <== NOT EXECUTED
/*
* Search the block to see if the name matches. A hash of 0xffff or 0x0
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
564b0: 206e fff8 moveal %fp@(-8),%a0
map.bpos.boff = 0;
564b4: 42ae ffba clrl %fp@(-70)
/*
* Search the block to see if the name matches. A hash of 0xffff or 0x0
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
564b8: 2468 001e moveal %a0@(30),%a2
564bc: 2d42 ff9a movel %d2,%fp@(-102)
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
564c0: 6000 0190 braw 56652 <rtems_rfs_dir_lookup_ino+0x370>
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
564c4: 4283 clrl %d3
564c6: 162a 0008 moveb %a2@(8),%d3
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
564ca: 102a 0004 moveb %a2@(4),%d0
elength = rtems_rfs_dir_entry_length (entry);
564ce: e18b lsll #8,%d3
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
564d0: 122a 0005 moveb %a2@(5),%d1
564d4: 3240 moveaw %d0,%a1
564d6: 102a 0007 moveb %a2@(7),%d0
564da: 3041 moveaw %d1,%a0
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
564dc: 7218 moveq #24,%d1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
564de: 1d40 ffa2 moveb %d0,%fp@(-94)
elength = rtems_rfs_dir_entry_length (entry);
564e2: 4280 clrl %d0
564e4: 102a 0009 moveb %a2@(9),%d0
564e8: 8680 orl %d0,%d3
*ino = rtems_rfs_dir_entry_ino (entry);
564ea: 1012 moveb %a2@,%d0
564ec: e3a8 lsll %d1,%d0
564ee: 4281 clrl %d1
564f0: 122a 0001 moveb %a2@(1),%d1
564f4: 4841 swap %d1
564f6: 4241 clrw %d1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
564f8: 142a 0006 moveb %a2@(6),%d2
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
564fc: 8081 orl %d1,%d0
564fe: 4281 clrl %d1
56500: 122a 0003 moveb %a2@(3),%d1
56504: 8081 orl %d1,%d0
56506: 122a 0002 moveb %a2@(2),%d1
5650a: e189 lsll #8,%d1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
5650c: 1d42 ffa3 moveb %d2,%fp@(-93)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
56510: 8081 orl %d1,%d0
56512: 2a80 movel %d0,%a5@
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
56514: 0c83 0000 ffff cmpil #65535,%d3
5651a: 6700 0148 beqw 56664 <rtems_rfs_dir_lookup_ino+0x382>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
5651e: 740a moveq #10,%d2
56520: b483 cmpl %d3,%d2
56522: 6c10 bges 56534 <rtems_rfs_dir_lookup_ino+0x252> <== NEVER TAKEN
56524: b6ab 0018 cmpl %a3@(24),%d3
56528: 640a bccs 56534 <rtems_rfs_dir_lookup_ino+0x252> <== NEVER TAKEN
5652a: 4a80 tstl %d0
5652c: 6706 beqs 56534 <rtems_rfs_dir_lookup_ino+0x252> <== NEVER TAKEN
5652e: b0ab 0010 cmpl %a3@(16),%d0
56532: 6332 blss 56566 <rtems_rfs_dir_lookup_ino+0x284> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56534: 2046 moveal %d6,%a0 <== NOT EXECUTED
56536: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
5653c: 42a7 clrl %sp@- <== NOT EXECUTED
5653e: 4e90 jsr %a0@ <== NOT EXECUTED
56540: 508f addql #8,%sp <== NOT EXECUTED
56542: 4a00 tstb %d0 <== NOT EXECUTED
56544: 6700 01f4 beqw 5673a <rtems_rfs_dir_lookup_ino+0x458> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
56548: 2f2e ffba movel %fp@(-70),%sp@- <== NOT EXECUTED
5654c: 2045 moveal %d5,%a0 <== NOT EXECUTED
5654e: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
56550: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56552: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
56556: 4879 0006 b94e pea 6b94e <CSWTCH.1+0x6a8> <== NOT EXECUTED
5655c: 4e90 jsr %a0@ <== NOT EXECUTED
5655e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
56562: 6000 01d6 braw 5673a <rtems_rfs_dir_lookup_ino+0x458> <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
56566: 7218 moveq #24,%d1
56568: 2009 movel %a1,%d0
5656a: 3408 movew %a0,%d2
5656c: e3a8 lsll %d1,%d0
5656e: 4281 clrl %d1
56570: 1202 moveb %d2,%d1
56572: 4841 swap %d1
56574: 4241 clrw %d1
56576: 8081 orl %d1,%d0
56578: 4281 clrl %d1
5657a: 122e ffa2 moveb %fp@(-94),%d1
5657e: 8081 orl %d1,%d0
56580: 122e ffa3 moveb %fp@(-93),%d1
56584: e189 lsll #8,%d1
56586: 8081 orl %d1,%d0
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
56588: b0ae ffa4 cmpl %fp@(-92),%d0
5658c: 6600 00be bnew 5664c <rtems_rfs_dir_lookup_ino+0x36a>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
56590: 2046 moveal %d6,%a0
56592: 2f3c 0800 0000 movel #134217728,%sp@-
56598: 42a7 clrl %sp@-
5659a: 4e90 jsr %a0@
5659c: 508f addql #8,%sp
5659e: 4a00 tstb %d0
565a0: 6742 beqs 565e4 <rtems_rfs_dir_lookup_ino+0x302> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: "
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
565a2: 4280 clrl %d0 <== NOT EXECUTED
565a4: 1012 moveb %a2@,%d0 <== NOT EXECUTED
565a6: 7218 moveq #24,%d1 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
565a8: 2045 moveal %d5,%a0 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
565aa: e3a8 lsll %d1,%d0 <== NOT EXECUTED
565ac: 4281 clrl %d1 <== NOT EXECUTED
565ae: 122a 0001 moveb %a2@(1),%d1 <== NOT EXECUTED
565b2: 4841 swap %d1 <== NOT EXECUTED
565b4: 4241 clrw %d1 <== NOT EXECUTED
565b6: 8081 orl %d1,%d0 <== NOT EXECUTED
565b8: 4281 clrl %d1 <== NOT EXECUTED
565ba: 122a 0003 moveb %a2@(3),%d1 <== NOT EXECUTED
565be: 8081 orl %d1,%d0 <== NOT EXECUTED
565c0: 122a 0002 moveb %a2@(2),%d1 <== NOT EXECUTED
565c4: e189 lsll #8,%d1 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
565c6: 8081 orl %d1,%d0 <== NOT EXECUTED
565c8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
565ca: 2f03 movel %d3,%sp@- <== NOT EXECUTED
565cc: 2f2e ffba movel %fp@(-70),%sp@- <== NOT EXECUTED
565d0: 2f2e ffb6 movel %fp@(-74),%sp@- <== NOT EXECUTED
565d4: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
565d8: 4879 0006 b998 pea 6b998 <CSWTCH.1+0x6f2> <== NOT EXECUTED
565de: 4e90 jsr %a0@ <== NOT EXECUTED
565e0: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
565e4: 2f07 movel %d7,%sp@-
565e6: 2f2e 0010 movel %fp@(16),%sp@-
565ea: 486a 000a pea %a2@(10)
565ee: 4eb9 0005 b0ac jsr 5b0ac <memcmp>
565f4: 4fef 000c lea %sp@(12),%sp
565f8: 4a80 tstl %d0
565fa: 6650 bnes 5664c <rtems_rfs_dir_lookup_ino+0x36a> <== NEVER TAKEN
{
*offset = rtems_rfs_block_map_pos (fs, &map);
565fc: 486e ffb6 pea %fp@(-74)
56600: 244b moveal %a3,%a2
56602: 264c moveal %a4,%a3
56604: 284d moveal %a5,%a4
56606: 2f0a movel %a2,%sp@-
56608: 2a6e ff9e moveal %fp@(-98),%a5
5660c: 242e ff9a movel %fp@(-102),%d2
56610: 4eb9 0005 4f10 jsr 54f10 <rtems_rfs_block_get_pos>
56616: 2a81 movel %d1,%a5@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
56618: 2f3c 1000 0000 movel #268435456,%sp@-
5661e: 42a7 clrl %sp@-
56620: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
56626: 4fef 0010 lea %sp@(16),%sp
5662a: 4a00 tstb %d0
5662c: 6700 00e6 beqw 56714 <rtems_rfs_dir_lookup_ino+0x432>
printf ("rtems-rfs: dir-lookup-ino: "
56630: 2f15 movel %a5@,%sp@- <== NOT EXECUTED
56632: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
56634: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
56638: 4879 0006 b9f6 pea 6b9f6 <CSWTCH.1+0x750> <== NOT EXECUTED
5663e: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56644: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
56648: 6000 00ca braw 56714 <rtems_rfs_dir_lookup_ino+0x432> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
5664c: d7ae ffba addl %d3,%fp@(-70)
entry += elength;
56650: d5c3 addal %d3,%a2
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
56652: 202b 0008 movel %a3@(8),%d0
56656: 0680 ffff fff6 addil #-10,%d0
5665c: b0ae ffba cmpl %fp@(-70),%d0
56660: 6200 fe62 bhiw 564c4 <rtems_rfs_dir_lookup_ino+0x1e2>
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
56664: 4a84 tstl %d4
56666: 6656 bnes 566be <rtems_rfs_dir_lookup_ino+0x3dc> <== NEVER TAKEN
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
56668: 486e fffc pea %fp@(-4)
5666c: 486e ffa8 pea %fp@(-88)
56670: 2f0b movel %a3,%sp@-
56672: 4eb9 0005 548c jsr 5548c <rtems_rfs_block_map_next_block>
if ((rc > 0) && (rc != ENXIO))
56678: 4fef 000c lea %sp@(12),%sp
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
5667c: 2400 movel %d0,%d2
if ((rc > 0) && (rc != ENXIO))
5667e: 6f58 bles 566d8 <rtems_rfs_dir_lookup_ino+0x3f6> <== NEVER TAKEN
56680: 7006 moveq #6,%d0
56682: b082 cmpl %d2,%d0
56684: 6732 beqs 566b8 <rtems_rfs_dir_lookup_ino+0x3d6> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56686: 2046 moveal %d6,%a0 <== NOT EXECUTED
56688: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
5668e: 42a7 clrl %sp@- <== NOT EXECUTED
56690: 4e90 jsr %a0@ <== NOT EXECUTED
56692: 508f addql #8,%sp <== NOT EXECUTED
56694: 4a00 tstb %d0 <== NOT EXECUTED
56696: 6740 beqs 566d8 <rtems_rfs_dir_lookup_ino+0x3f6> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
56698: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5669a: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
566a0: 2045 moveal %d5,%a0 <== NOT EXECUTED
566a2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
566a4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
566a6: 2f2c 0008 movel %a4@(8),%sp@- <== NOT EXECUTED
566aa: 4879 0006 ba3d pea 6ba3d <CSWTCH.1+0x797> <== NOT EXECUTED
566b0: 4e90 jsr %a0@ <== NOT EXECUTED
566b2: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
566b6: 6020 bras 566d8 <rtems_rfs_dir_lookup_ino+0x3f6> <== NOT EXECUTED
566b8: 244b moveal %a3,%a2
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
566ba: 7402 moveq #2,%d2
566bc: 602a bras 566e8 <rtems_rfs_dir_lookup_ino+0x406>
566be: 2404 movel %d4,%d2 <== NOT EXECUTED
566c0: 6016 bras 566d8 <rtems_rfs_dir_lookup_ino+0x3f6> <== NOT EXECUTED
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
566c2: 2d4d ff9e movel %a5,%fp@(-98)
566c6: 2a4c moveal %a4,%a5
566c8: 284b moveal %a3,%a4
566ca: 264a moveal %a2,%a3
566cc: 2c3c 0004 f3d8 movel #324568,%d6
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
566d2: 2a3c 0005 b318 movel #373528,%d5
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
566d8: 4a82 tstl %d2
566da: 660a bnes 566e6 <rtems_rfs_dir_lookup_ino+0x404> <== NEVER TAKEN
566dc: 4aae fffc tstl %fp@(-4)
566e0: 6600 fd4a bnew 5642c <rtems_rfs_dir_lookup_ino+0x14a>
566e4: 6058 bras 5673e <rtems_rfs_dir_lookup_ino+0x45c> <== NOT EXECUTED
566e6: 244b moveal %a3,%a2 <== NOT EXECUTED
566e8: 2802 movel %d2,%d4
566ea: 2404 movel %d4,%d2
566ec: 6026 bras 56714 <rtems_rfs_dir_lookup_ino+0x432>
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
566ee: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
566f2: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
566f8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
566fa: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
566fe: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
56702: 4879 0006 ba88 pea 6ba88 <CSWTCH.1+0x7e2> <== NOT EXECUTED
56708: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5670e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
56712: 7405 moveq #5,%d2 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
56714: 486e fff2 pea %fp@(-14)
56718: 2f0a movel %a2,%sp@-
5671a: 4eba fb9c jsr %pc@(562b8 <rtems_rfs_buffer_handle_close>)
rtems_rfs_block_map_close (fs, &map);
5671e: 486e ffa8 pea %fp@(-88)
56722: 2f0a movel %a2,%sp@-
56724: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close>
return rc;
5672a: 4fef 0010 lea %sp@(16),%sp
}
5672e: 2002 movel %d2,%d0
56730: 4cee 3cfc ff70 moveml %fp@(-144),%d2-%d7/%a2-%a5
56736: 4e5e unlk %fp
56738: 4e75 rts
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
5673a: 7805 moveq #5,%d4 <== NOT EXECUTED
5673c: 6080 bras 566be <rtems_rfs_dir_lookup_ino+0x3dc> <== NOT EXECUTED
5673e: 244b moveal %a3,%a2 <== NOT EXECUTED
56740: 264c moveal %a4,%a3 <== NOT EXECUTED
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
56742: 2f3c 0400 0000 movel #67108864,%sp@- <== NOT EXECUTED
56748: 42a7 clrl %sp@- <== NOT EXECUTED
5674a: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56750: 508f addql #8,%sp <== NOT EXECUTED
56752: 4a00 tstb %d0 <== NOT EXECUTED
56754: 67bc beqs 56712 <rtems_rfs_dir_lookup_ino+0x430> <== NOT EXECUTED
56756: 6096 bras 566ee <rtems_rfs_dir_lookup_ino+0x40c> <== NOT EXECUTED
00056e24 <rtems_rfs_dir_read>:
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
56e24: 4e56 ff80 linkw %fp,#-128 <== NOT EXECUTED
56e28: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
56e2c: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
56e32: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
56e36: 42a7 clrl %sp@- <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
56e38: 266e 0018 moveal %fp@(24),%a3 <== NOT EXECUTED
56e3c: 286e 001c moveal %fp@(28),%a4 <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
56e40: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56e46: 508f addql #8,%sp <== NOT EXECUTED
56e48: 4a00 tstb %d0 <== NOT EXECUTED
56e4a: 6720 beqs 56e6c <rtems_rfs_dir_read+0x48> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
56e4c: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
56e50: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
56e54: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
56e58: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
56e5c: 4879 0006 bd81 pea 6bd81 <CSWTCH.1+0xadb> <== NOT EXECUTED
56e62: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
56e68: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
56e6c: 4294 clrl %a4@ <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
56e6e: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
56e72: 2f2e 000c movel %fp@(12),%sp@- <== NOT EXECUTED
56e76: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56e78: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
56e7e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
rc = rtems_rfs_block_map_open (fs, dir, &map);
56e82: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
56e84: 6e00 02d0 bgtw 57156 <rtems_rfs_dir_read+0x332> <== NOT EXECUTED
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
56e88: 2a2a 0008 movel %a2@(8),%d5 <== NOT EXECUTED
56e8c: 4284 clrl %d4 <== NOT EXECUTED
56e8e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
56e90: 2404 movel %d4,%d2 <== NOT EXECUTED
56e92: 2605 movel %d5,%d3 <== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
56e94: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56e96: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
56e9a: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
56e9e: 4eb9 0006 7634 jsr 67634 <__moddi3> <== NOT EXECUTED
56ea4: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
56ea8: 9681 subl %d1,%d3 <== NOT EXECUTED
56eaa: 9580 subxl %d0,%d2 <== NOT EXECUTED
56eac: 2002 movel %d2,%d0 <== NOT EXECUTED
56eae: 2203 movel %d3,%d1 <== NOT EXECUTED
56eb0: 4282 clrl %d2 <== NOT EXECUTED
56eb2: 760a moveq #10,%d3 <== NOT EXECUTED
56eb4: 9681 subl %d1,%d3 <== NOT EXECUTED
56eb6: 9580 subxl %d0,%d2 <== NOT EXECUTED
56eb8: 6d38 blts 56ef2 <rtems_rfs_dir_read+0xce> <== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
56eba: 2f05 movel %d5,%sp@- <== NOT EXECUTED
56ebc: 4282 clrl %d2 <== NOT EXECUTED
56ebe: 7601 moveq #1,%d3 <== NOT EXECUTED
56ec0: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56ec2: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
56ec6: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
56eca: 4eb9 0006 71ec jsr 671ec <__divdi3> <== NOT EXECUTED
56ed0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
56ed4: 2e85 movel %d5,%sp@ <== NOT EXECUTED
56ed6: d681 addl %d1,%d3 <== NOT EXECUTED
56ed8: d580 addxl %d0,%d2 <== NOT EXECUTED
56eda: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56edc: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56ede: 2f02 movel %d2,%sp@- <== NOT EXECUTED
56ee0: 4eb9 0006 713c jsr 6713c <__muldi3> <== NOT EXECUTED
56ee6: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
56eea: 2d40 0010 movel %d0,%fp@(16) <== NOT EXECUTED
56eee: 2d41 0014 movel %d1,%fp@(20) <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
56ef2: 280e movel %fp,%d4 <== NOT EXECUTED
56ef4: 5984 subql #4,%d4 <== NOT EXECUTED
56ef6: 260e movel %fp,%d3 <== NOT EXECUTED
56ef8: 0683 ffff ffa8 addil #-88,%d3 <== NOT EXECUTED
56efe: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56f00: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
56f04: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
56f08: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56f0a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56f0c: 4eb9 0005 540e jsr 5540e <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
56f12: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
56f16: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
56f18: 6f18 bles 56f32 <rtems_rfs_dir_read+0x10e> <== NOT EXECUTED
{
if (rc == ENXIO)
56f1a: 7006 moveq #6,%d0 <== NOT EXECUTED
56f1c: b082 cmpl %d2,%d0 <== NOT EXECUTED
56f1e: 6602 bnes 56f22 <rtems_rfs_dir_read+0xfe> <== NOT EXECUTED
rc = ENOENT;
56f20: 7402 moveq #2,%d2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
56f22: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56f24: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56f26: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
56f2c: 508f addql #8,%sp <== NOT EXECUTED
56f2e: 6000 0226 braw 57156 <rtems_rfs_dir_read+0x332> <== NOT EXECUTED
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
56f32: 2c0e movel %fp,%d6 <== NOT EXECUTED
56f34: 0686 ffff fff2 addil #-14,%d6 <== NOT EXECUTED
56f3a: 2e3c 0005 5d00 movel #351488,%d7 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
56f40: 4201 clrb %d1 <== NOT EXECUTED
handle->bnum = 0;
56f42: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
56f46: 243c 0005 b318 movel #373528,%d2 <== NOT EXECUTED
handle->buffer = NULL;
56f4c: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
56f50: 1d41 fff2 moveb %d1,%fp@(-14) <== NOT EXECUTED
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
56f54: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
56f58: 2047 moveal %d7,%a0 <== NOT EXECUTED
56f5a: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
56f5e: 2f06 movel %d6,%sp@- <== NOT EXECUTED
56f60: 2f0a movel %a2,%sp@- <== NOT EXECUTED
56f62: 4e90 jsr %a0@ <== NOT EXECUTED
if (rc > 0)
56f64: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
56f68: 4a80 tstl %d0 <== NOT EXECUTED
56f6a: 6f08 bles 56f74 <rtems_rfs_dir_read+0x150> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &buffer);
56f6c: 2f06 movel %d6,%sp@- <== NOT EXECUTED
56f6e: 2400 movel %d0,%d2 <== NOT EXECUTED
56f70: 6000 01ce braw 57140 <rtems_rfs_dir_read+0x31c> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
56f74: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
56f78: 4283 clrl %d3 <== NOT EXECUTED
56f7a: 4281 clrl %d1 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
56f7c: 4284 clrl %d4 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
56f7e: 2a2e ffba movel %fp@(-70),%d5 <== NOT EXECUTED
56f82: 2a68 001e moveal %a0@(30),%a5 <== NOT EXECUTED
56f86: dbc5 addal %d5,%a5 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
56f88: 162d 0008 moveb %a5@(8),%d3 <== NOT EXECUTED
56f8c: 122d 0009 moveb %a5@(9),%d1 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
56f90: 1815 moveb %a5@,%d4 <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
56f92: e18b lsll #8,%d3 <== NOT EXECUTED
56f94: 8681 orl %d1,%d3 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
56f96: 7218 moveq #24,%d1 <== NOT EXECUTED
56f98: e3ac lsll %d1,%d4 <== NOT EXECUTED
56f9a: 4281 clrl %d1 <== NOT EXECUTED
56f9c: 122d 0001 moveb %a5@(1),%d1 <== NOT EXECUTED
56fa0: 4841 swap %d1 <== NOT EXECUTED
56fa2: 4241 clrw %d1 <== NOT EXECUTED
56fa4: 8881 orl %d1,%d4 <== NOT EXECUTED
56fa6: 4281 clrl %d1 <== NOT EXECUTED
56fa8: 122d 0003 moveb %a5@(3),%d1 <== NOT EXECUTED
56fac: 8881 orl %d1,%d4 <== NOT EXECUTED
56fae: 122d 0002 moveb %a5@(2),%d1 <== NOT EXECUTED
56fb2: e189 lsll #8,%d1 <== NOT EXECUTED
56fb4: 8881 orl %d1,%d4 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
56fb6: 0c83 0000 ffff cmpil #65535,%d3 <== NOT EXECUTED
56fbc: 6700 0120 beqw 570de <rtems_rfs_dir_read+0x2ba> <== NOT EXECUTED
56fc0: 2400 movel %d0,%d2 <== NOT EXECUTED
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
56fc2: 700a moveq #10,%d0 <== NOT EXECUTED
56fc4: b083 cmpl %d3,%d0 <== NOT EXECUTED
56fc6: 6c10 bges 56fd8 <rtems_rfs_dir_read+0x1b4> <== NOT EXECUTED
56fc8: b6aa 0018 cmpl %a2@(24),%d3 <== NOT EXECUTED
56fcc: 640a bccs 56fd8 <rtems_rfs_dir_read+0x1b4> <== NOT EXECUTED
56fce: 4a84 tstl %d4 <== NOT EXECUTED
56fd0: 6706 beqs 56fd8 <rtems_rfs_dir_read+0x1b4> <== NOT EXECUTED
56fd2: b8aa 0010 cmpl %a2@(16),%d4 <== NOT EXECUTED
56fd6: 633a blss 57012 <rtems_rfs_dir_read+0x1ee> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
56fd8: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
56fde: 42a7 clrl %sp@- <== NOT EXECUTED
56fe0: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
56fe6: 508f addql #8,%sp <== NOT EXECUTED
56fe8: 4a00 tstb %d0 <== NOT EXECUTED
56fea: 6700 014a beqw 57136 <rtems_rfs_dir_read+0x312> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
56fee: 2f2e ffba movel %fp@(-70),%sp@- <== NOT EXECUTED
56ff2: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
56ff6: 2f04 movel %d4,%sp@- <== NOT EXECUTED
56ff8: 2f03 movel %d3,%sp@- <== NOT EXECUTED
56ffa: 2f28 0008 movel %a0@(8),%sp@- <== NOT EXECUTED
56ffe: 4879 0006 bdab pea 6bdab <CSWTCH.1+0xb05> <== NOT EXECUTED
57004: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5700a: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
5700e: 6000 0126 braw 57136 <rtems_rfs_dir_read+0x312> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
57012: 4878 0110 pea 110 <DBL_MANT_DIG+0xdb> <== NOT EXECUTED
57016: 42a7 clrl %sp@- <== NOT EXECUTED
57018: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5701a: 4eb9 0005 b28c jsr 5b28c <memset> <== NOT EXECUTED
*length += elength;
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
57020: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
57024: 202e 0010 movel %fp@(16),%d0 <== NOT EXECUTED
57028: 222e 0014 movel %fp@(20),%d1 <== NOT EXECUTED
5702c: 2740 0004 movel %d0,%a3@(4) <== NOT EXECUTED
57030: 2741 0008 movel %d1,%a3@(8) <== NOT EXECUTED
dirent->d_reclen = sizeof (struct dirent);
57034: 323c 0110 movew #272,%d1 <== NOT EXECUTED
*length += elength;
57038: 2003 movel %d3,%d0 <== NOT EXECUTED
5703a: d094 addl %a4@,%d0 <== NOT EXECUTED
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
5703c: 3741 000c movew %d1,%a3@(12) <== NOT EXECUTED
*length += elength;
57040: 2880 movel %d0,%a4@ <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
57042: 222a 0008 movel %a2@(8),%d1 <== NOT EXECUTED
57046: 9285 subl %d5,%d1 <== NOT EXECUTED
57048: 2a01 movel %d1,%d5 <== NOT EXECUTED
5704a: 9a83 subl %d3,%d5 <== NOT EXECUTED
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
5704c: 720a moveq #10,%d1 <== NOT EXECUTED
5704e: b285 cmpl %d5,%d1 <== NOT EXECUTED
57050: 6d04 blts 57056 <rtems_rfs_dir_read+0x232> <== NOT EXECUTED
*length += remaining;
57052: da80 addl %d0,%d5 <== NOT EXECUTED
57054: 2885 movel %d5,%a4@ <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
57056: 0683 ffff fff6 addil #-10,%d3 <== NOT EXECUTED
5705c: 0c83 0000 00ff cmpil #255,%d3 <== NOT EXECUTED
57062: 6f06 bles 5706a <rtems_rfs_dir_read+0x246> <== NOT EXECUTED
57064: 263c 0000 00ff movel #255,%d3 <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
5706a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
5706c: 486d 000a pea %a5@(10) <== NOT EXECUTED
57070: 280b movel %a3,%d4 <== NOT EXECUTED
57072: 0684 0000 0010 addil #16,%d4 <== NOT EXECUTED
57078: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5707a: 4eb9 0005 b134 jsr 5b134 <memcpy> <== NOT EXECUTED
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
57080: 4280 clrl %d0 <== NOT EXECUTED
57082: 1015 moveb %a5@,%d0 <== NOT EXECUTED
57084: 7218 moveq #24,%d1 <== NOT EXECUTED
57086: e3a8 lsll %d1,%d0 <== NOT EXECUTED
57088: 4281 clrl %d1 <== NOT EXECUTED
5708a: 122d 0001 moveb %a5@(1),%d1 <== NOT EXECUTED
5708e: 4841 swap %d1 <== NOT EXECUTED
57090: 4241 clrw %d1 <== NOT EXECUTED
57092: 8081 orl %d1,%d0 <== NOT EXECUTED
57094: 4281 clrl %d1 <== NOT EXECUTED
57096: 122d 0003 moveb %a5@(3),%d1 <== NOT EXECUTED
5709a: 8081 orl %d1,%d0 <== NOT EXECUTED
5709c: 122d 0002 moveb %a5@(2),%d1 <== NOT EXECUTED
570a0: e189 lsll #8,%d1 <== NOT EXECUTED
dirent->d_namlen = elength;
570a2: 3743 000e movew %d3,%a3@(14) <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
570a6: 8081 orl %d1,%d0 <== NOT EXECUTED
570a8: 2680 movel %d0,%a3@ <== NOT EXECUTED
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
570aa: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
570b0: 42a7 clrl %sp@- <== NOT EXECUTED
570b2: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
570b8: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
570bc: 4a00 tstb %d0 <== NOT EXECUTED
570be: 677c beqs 5713c <rtems_rfs_dir_read+0x318> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIdoff_t " ino:%ld name=%s\n",
570c0: 2f04 movel %d4,%sp@- <== NOT EXECUTED
570c2: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
570c4: 2f2b 0008 movel %a3@(8),%sp@- <== NOT EXECUTED
570c8: 2f2b 0004 movel %a3@(4),%sp@- <== NOT EXECUTED
570cc: 4879 0006 bdef pea 6bdef <CSWTCH.1+0xb49> <== NOT EXECUTED
570d2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
570d8: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
570dc: 605e bras 5713c <rtems_rfs_dir_read+0x318> <== NOT EXECUTED
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
570de: 262a 0008 movel %a2@(8),%d3 <== NOT EXECUTED
570e2: 9685 subl %d5,%d3 <== NOT EXECUTED
570e4: d794 addl %d3,%a4@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
570e6: 2f3c 8000 0000 movel #-2147483648,%sp@- <== NOT EXECUTED
570ec: 42a7 clrl %sp@- <== NOT EXECUTED
570ee: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
570f4: 508f addql #8,%sp <== NOT EXECUTED
570f6: 4a00 tstb %d0 <== NOT EXECUTED
570f8: 6718 beqs 57112 <rtems_rfs_dir_read+0x2ee> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
570fa: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
570fc: 2042 moveal %d2,%a0 <== NOT EXECUTED
570fe: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
57102: 2f2e 0010 movel %fp@(16),%sp@- <== NOT EXECUTED
57106: 4879 0006 be24 pea 6be24 <CSWTCH.1+0xb7e> <== NOT EXECUTED
5710c: 4e90 jsr %a0@ <== NOT EXECUTED
5710e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
57112: 486e fffc pea %fp@(-4) <== NOT EXECUTED
57116: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
5711a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5711c: 4eb9 0005 548c jsr 5548c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
57122: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57126: 7206 moveq #6,%d1 <== NOT EXECUTED
57128: b280 cmpl %d0,%d1 <== NOT EXECUTED
5712a: 670e beqs 5713a <rtems_rfs_dir_read+0x316> <== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
5712c: 4a80 tstl %d0 <== NOT EXECUTED
5712e: 6700 fe24 beqw 56f54 <rtems_rfs_dir_read+0x130> <== NOT EXECUTED
57132: 2400 movel %d0,%d2 <== NOT EXECUTED
57134: 6006 bras 5713c <rtems_rfs_dir_read+0x318> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04" PRIx32 "\n",
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
57136: 7405 moveq #5,%d2 <== NOT EXECUTED
57138: 6002 bras 5713c <rtems_rfs_dir_read+0x318> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
5713a: 7402 moveq #2,%d2 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
5713c: 486e fff2 pea %fp@(-14) <== NOT EXECUTED
57140: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57142: 4eba f174 jsr %pc@(562b8 <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
57146: 486e ffa8 pea %fp@(-88) <== NOT EXECUTED
5714a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5714c: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
57152: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
57156: 2002 movel %d2,%d0 <== NOT EXECUTED
57158: 4cee 3cfc ff80 moveml %fp@(-128),%d2-%d7/%a2-%a5 <== NOT EXECUTED
5715e: 4e5e unlk %fp <== NOT EXECUTED
0005735c <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
5735c: 4e56 fff0 linkw %fp,#-16
57360: 48d7 041c moveml %d2-%d4/%a2,%sp@
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57364: 42a7 clrl %sp@-
57366: 4878 0010 pea 10 <INVALID_OPERATION>
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
5736a: 262e 0008 movel %fp@(8),%d3
5736e: 246e 000c moveal %fp@(12),%a2
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57372: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
57378: 508f addql #8,%sp
5737a: 4a00 tstb %d0
5737c: 6716 beqs 57394 <rtems_rfs_file_close+0x38> <== ALWAYS TAKEN
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
5737e: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
57382: 2f28 0014 movel %a0@(20),%sp@- <== NOT EXECUTED
57386: 4879 0006 bebd pea 6bebd <CSWTCH.1+0xc17> <== NOT EXECUTED
5738c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57392: 508f addql #8,%sp <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
57394: 206a 001a moveal %a2@(26),%a0
57398: 2028 0008 movel %a0@(8),%d0
5739c: 6f06 bles 573a4 <rtems_rfs_file_close+0x48> <== NEVER TAKEN
handle->shared->references--;
5739e: 5380 subql #1,%d0
573a0: 2140 0008 movel %d0,%a0@(8)
if (handle->shared->references == 0)
573a4: 4aa8 0008 tstl %a0@(8)
573a8: 6600 01bc bnew 57566 <rtems_rfs_file_close+0x20a>
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
573ac: 4aa8 0018 tstl %a0@(24)
573b0: 6614 bnes 573c6 <rtems_rfs_file_close+0x6a> <== NEVER TAKEN
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
573b2: 4868 000c pea %a0@(12)
573b6: 2f03 movel %d3,%sp@-
573b8: 4eb9 0004 d64c jsr 4d64c <rtems_rfs_inode_load>
if (rrc == 0)
573be: 508f addql #8,%sp
handle->shared->references--;
if (handle->shared->references == 0)
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
573c0: 2400 movel %d0,%d2
if (rrc == 0)
573c2: 6600 00e2 bnew 574a6 <rtems_rfs_file_close+0x14a>
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
handle->shared->atime);
573c6: 206a 001a moveal %a2@(26),%a0
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
573ca: 7418 moveq #24,%d2
if (rrc == 0)
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
573cc: 2028 0084 movel %a0@(132),%d0
573d0: 2200 movel %d0,%d1
573d2: e4a9 lsrl %d2,%d1
573d4: 2268 0018 moveal %a0@(24),%a1
573d8: 1341 0010 moveb %d1,%a1@(16)
573dc: 2200 movel %d0,%d1
573de: 2268 0018 moveal %a0@(24),%a1
573e2: 4241 clrw %d1
573e4: 4841 swap %d1
573e6: 1341 0011 moveb %d1,%a1@(17)
573ea: 2200 movel %d0,%d1
573ec: e089 lsrl #8,%d1
573ee: 2268 0018 moveal %a0@(24),%a1
573f2: 1341 0012 moveb %d1,%a1@(18)
573f6: 2268 0018 moveal %a0@(24),%a1
573fa: 1340 0013 moveb %d0,%a1@(19)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
573fe: 7001 moveq #1,%d0
57400: 1140 001c moveb %d0,%a0@(28)
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
57404: 206a 001a moveal %a2@(26),%a0
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
57408: 2028 0088 movel %a0@(136),%d0
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
5740c: 2200 movel %d0,%d1
5740e: e4a9 lsrl %d2,%d1
57410: 2268 0018 moveal %a0@(24),%a1
57414: 1341 0014 moveb %d1,%a1@(20)
57418: 2200 movel %d0,%d1
5741a: 2268 0018 moveal %a0@(24),%a1
5741e: 4241 clrw %d1
57420: 4841 swap %d1
57422: 1341 0015 moveb %d1,%a1@(21)
57426: 2200 movel %d0,%d1
57428: e089 lsrl #8,%d1
5742a: 2268 0018 moveal %a0@(24),%a1
5742e: 1341 0016 moveb %d1,%a1@(22)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
57432: 7201 moveq #1,%d1
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
57434: 2268 0018 moveal %a0@(24),%a1
57438: 1340 0017 moveb %d0,%a1@(23)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
5743c: 1141 001c moveb %d1,%a0@(28)
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
handle->shared->ctime);
57440: 206a 001a moveal %a2@(26),%a0
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
57444: 2028 008c movel %a0@(140),%d0
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
57448: 2200 movel %d0,%d1
5744a: e4a9 lsrl %d2,%d1
5744c: 2268 0018 moveal %a0@(24),%a1
57450: 1341 0018 moveb %d1,%a1@(24)
57454: 2200 movel %d0,%d1
57456: 2268 0018 moveal %a0@(24),%a1
5745a: 4241 clrw %d1
5745c: 4841 swap %d1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
5745e: 7401 moveq #1,%d2
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
57460: 1341 0019 moveb %d1,%a1@(25)
57464: 2200 movel %d0,%d1
57466: e089 lsrl #8,%d1
57468: 2268 0018 moveal %a0@(24),%a1
5746c: 1341 001a moveb %d1,%a1@(26)
57470: 2268 0018 moveal %a0@(24),%a1
57474: 1340 001b moveb %d0,%a1@(27)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
57478: 1142 001c moveb %d2,%a0@(28)
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
5747c: 206a 001a moveal %a2@(26),%a0
57480: 2028 007c movel %a0@(124),%d0
57484: b0a8 0038 cmpl %a0@(56),%d0
57488: 660a bnes 57494 <rtems_rfs_file_close+0x138>
5748a: 2228 003c movel %a0@(60),%d1
5748e: b2a8 0080 cmpl %a0@(128),%d1
57492: 6710 beqs 574a4 <rtems_rfs_file_close+0x148> <== ALWAYS TAKEN
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
57494: 2140 0038 movel %d0,%a0@(56)
map->dirty = true;
57498: 7401 moveq #1,%d2
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
5749a: 2168 0080 003c movel %a0@(128),%a0@(60)
map->dirty = true;
574a0: 1142 0032 moveb %d2,%a0@(50)
574a4: 4282 clrl %d2
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
574a6: 206a 001a moveal %a2@(26),%a0
574aa: 41e8 0032 lea %a0@(50),%a0
574ae: 2f08 movel %a0,%sp@-
574b0: 2f03 movel %d3,%sp@-
574b2: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close>
if (rc > 0)
574b8: 508f addql #8,%sp
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
574ba: 2800 movel %d0,%d4
if (rc > 0)
574bc: 6f3c bles 574fa <rtems_rfs_file_close+0x19e> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
574be: 42a7 clrl %sp@- <== NOT EXECUTED
574c0: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
574c4: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
574ca: 508f addql #8,%sp <== NOT EXECUTED
574cc: 4a00 tstb %d0 <== NOT EXECUTED
574ce: 6724 beqs 574f4 <rtems_rfs_file_close+0x198> <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
574d0: 2f04 movel %d4,%sp@- <== NOT EXECUTED
574d2: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
574d8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
574da: 2f04 movel %d4,%sp@- <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
574dc: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
574e0: 2f28 0014 movel %a0@(20),%sp@- <== NOT EXECUTED
574e4: 4879 0006 bee4 pea 6bee4 <CSWTCH.1+0xc3e> <== NOT EXECUTED
574ea: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
574f0: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
574f4: 4a82 tstl %d2 <== NOT EXECUTED
574f6: 6602 bnes 574fa <rtems_rfs_file_close+0x19e> <== NOT EXECUTED
574f8: 2404 movel %d4,%d2 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
574fa: 206a 001a moveal %a2@(26),%a0
574fe: 41e8 000c lea %a0@(12),%a0
57502: 2f08 movel %a0,%sp@-
57504: 2f03 movel %d3,%sp@-
57506: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
if (rc > 0)
5750c: 508f addql #8,%sp
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
5750e: 2800 movel %d0,%d4
if (rc > 0)
57510: 6f3c bles 5754e <rtems_rfs_file_close+0x1f2> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57512: 42a7 clrl %sp@- <== NOT EXECUTED
57514: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
57518: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5751e: 508f addql #8,%sp <== NOT EXECUTED
57520: 4a00 tstb %d0 <== NOT EXECUTED
57522: 6724 beqs 57548 <rtems_rfs_file_close+0x1ec> <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
57524: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57526: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
5752c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5752e: 2f04 movel %d4,%sp@- <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
57530: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
57534: 2f28 0014 movel %a0@(20),%sp@- <== NOT EXECUTED
57538: 4879 0006 bf1d pea 6bf1d <CSWTCH.1+0xc77> <== NOT EXECUTED
5753e: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57544: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
57548: 4a82 tstl %d2 <== NOT EXECUTED
5754a: 6602 bnes 5754e <rtems_rfs_file_close+0x1f2> <== NOT EXECUTED
5754c: 2404 movel %d4,%d2 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
5754e: 2f2a 001a movel %a2@(26),%sp@-
57552: 4eb9 0004 99e4 jsr 499e4 <_Chain_Extract>
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
57558: 2f2a 001a movel %a2@(26),%sp@-
5755c: 4eb9 0004 54d0 jsr 454d0 <free>
57562: 508f addql #8,%sp
57564: 6002 bras 57568 <rtems_rfs_file_close+0x20c>
rtems_rfs_file_handle* handle)
{
int rrc;
int rc;
rrc = 0;
57566: 4282 clrl %d2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
57568: 486a 0004 pea %a2@(4)
5756c: 2f03 movel %d3,%sp@-
5756e: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
if ((rrc == 0) && (rc > 0))
rrc = rc;
if (rrc > 0)
57574: 508f addql #8,%sp
handle->dirty = false;
57576: 4200 clrb %d0
handle->bnum = 0;
57578: 42aa 0006 clrl %a2@(6)
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
5757c: 1540 0004 moveb %d0,%a2@(4)
handle->bnum = 0;
handle->buffer = NULL;
57580: 42aa 000a clrl %a2@(10)
57584: 4a82 tstl %d2
57586: 6f2e bles 575b6 <rtems_rfs_file_close+0x25a> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
57588: 42a7 clrl %sp@- <== NOT EXECUTED
5758a: 4878 0010 pea 10 <INVALID_OPERATION> <== NOT EXECUTED
5758e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
57594: 508f addql #8,%sp <== NOT EXECUTED
57596: 4a00 tstb %d0 <== NOT EXECUTED
57598: 671c beqs 575b6 <rtems_rfs_file_close+0x25a> <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
5759a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5759c: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
575a2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
575a4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
575a6: 4879 0006 bf58 pea 6bf58 <CSWTCH.1+0xcb2> <== NOT EXECUTED
575ac: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
575b2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
free (handle);
575b6: 2f0a movel %a2,%sp@-
575b8: 4eb9 0004 54d0 jsr 454d0 <free>
return rrc;
}
575be: 2002 movel %d2,%d0
575c0: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
575c6: 4e5e unlk %fp <== NOT EXECUTED
00057cde <rtems_rfs_file_get_shared>:
rtems_rfs_file_shared*
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
57cde: 4e56 0000 linkw %fp,#0
57ce2: 226e 0008 moveal %fp@(8),%a1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
57ce6: 2069 0070 moveal %a1@(112),%a0
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
57cea: 43e9 0074 lea %a1@(116),%a1
57cee: 202e 000c movel %fp@(12),%d0
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
57cf2: 6008 bras 57cfc <rtems_rfs_file_get_shared+0x1e>
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
57cf4: b0a8 0014 cmpl %a0@(20),%d0 <== NOT EXECUTED
57cf8: 670a beqs 57d04 <rtems_rfs_file_get_shared+0x26> <== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
57cfa: 2050 moveal %a0@,%a0 <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
57cfc: b3c8 cmpal %a0,%a1
57cfe: 66f4 bnes 57cf4 <rtems_rfs_file_get_shared+0x16> <== NEVER TAKEN
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
57d00: 4280 clrl %d0
57d02: 6002 bras 57d06 <rtems_rfs_file_get_shared+0x28>
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
57d04: 2008 movel %a0,%d0 <== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
57d06: 4e5e unlk %fp <== NOT EXECUTED
00057790 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
57790: 4e56 ffe8 linkw %fp,#-24
57794: 48d7 047c moveml %d2-%d6/%a2,%sp@
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
57798: 42a7 clrl %sp@-
5779a: 4878 0020 pea 20 <OPER2+0xc>
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
5779e: 246e 0008 moveal %fp@(8),%a2
577a2: 282e 000c movel %fp@(12),%d4
577a6: 162e 0013 moveb %fp@(19),%d3
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
577aa: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
577b0: 508f addql #8,%sp
577b2: 4a00 tstb %d0
577b4: 6724 beqs 577da <rtems_rfs_file_io_end+0x4a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
577b6: 203c 0006 8fbc movel #430012,%d0 <== NOT EXECUTED
577bc: 4a03 tstb %d3 <== NOT EXECUTED
577be: 6706 beqs 577c6 <rtems_rfs_file_io_end+0x36> <== NOT EXECUTED
577c0: 203c 0006 b094 movel #438420,%d0 <== NOT EXECUTED
577c6: 2f04 movel %d4,%sp@- <== NOT EXECUTED
577c8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
577ca: 4879 0006 c030 pea 6c030 <CSWTCH.1+0xd8a> <== NOT EXECUTED
577d0: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
577d6: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
577da: 4aaa 000a tstl %a2@(10)
577de: 6758 beqs 57838 <rtems_rfs_file_io_end+0xa8> <== NEVER TAKEN
{
if (!read)
577e0: 4a03 tstb %d3
577e2: 6606 bnes 577ea <rtems_rfs_file_io_end+0x5a>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
577e4: 7001 moveq #1,%d0
577e6: 1540 0004 moveb %d0,%a2@(4)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
577ea: 486a 0004 pea %a2@(4)
577ee: 206a 001a moveal %a2@(26),%a0
577f2: 2f28 0090 movel %a0@(144),%sp@-
577f6: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
577fc: 508f addql #8,%sp
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
{
if (!read)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
577fe: 2400 movel %d0,%d2
rtems_rfs_file_buffer (handle));
if (rc > 0)
57800: 6f38 bles 5783a <rtems_rfs_file_io_end+0xaa> <== ALWAYS TAKEN
{
printf (
57802: 2f00 movel %d0,%sp@- <== NOT EXECUTED
57804: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
5780a: 588f addql #4,%sp <== NOT EXECUTED
5780c: 223c 0006 8fbc movel #430012,%d1 <== NOT EXECUTED
57812: 4a03 tstb %d3 <== NOT EXECUTED
57814: 6706 beqs 5781c <rtems_rfs_file_io_end+0x8c> <== NOT EXECUTED
57816: 223c 0006 b094 movel #438420,%d1 <== NOT EXECUTED
5781c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5781e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57820: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57822: 2f01 movel %d1,%sp@- <== NOT EXECUTED
57824: 4879 0006 c058 pea 6c058 <CSWTCH.1+0xdb2> <== NOT EXECUTED
5782a: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
"rtems-rfs: file-io: end: error on release: %s size=%zu: %d: %s\n",
read ? "read" : "write", size, rc, strerror (rc));
return rc;
57830: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
57834: 6000 0118 braw 5794e <rtems_rfs_file_io_end+0x1be> <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
57838: 4282 clrl %d2 <== NOT EXECUTED
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
5783a: 206a 001a moveal %a2@(26),%a0
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
5783e: d8aa 0012 addl %a2@(18),%d4
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
57842: 2268 0090 moveal %a0@(144),%a1
57846: 2029 0008 movel %a1@(8),%d0
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
5784a: 2544 0012 movel %d4,%a2@(18)
if (handle->bpos.boff >=
5784e: b084 cmpl %d4,%d0
57850: 620a bhis 5785c <rtems_rfs_file_io_end+0xcc> <== ALWAYS TAKEN
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
57852: 9880 subl %d0,%d4 <== NOT EXECUTED
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
57854: 52aa 000e addql #1,%a2@(14) <== NOT EXECUTED
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
57858: 2544 0012 movel %d4,%a2@(18) <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
5785c: 4a03 tstb %d3
5785e: 6634 bnes 57894 <rtems_rfs_file_io_end+0x104>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
57860: 202a 000e movel %a2@(14),%d0
}
length = false;
mtime = false;
if (!read &&
57864: 6706 beqs 5786c <rtems_rfs_file_io_end+0xdc> <== ALWAYS TAKEN
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
57866: 4aa8 0038 tstl %a0@(56) <== NOT EXECUTED
5786a: 6718 beqs 57884 <rtems_rfs_file_io_end+0xf4> <== NOT EXECUTED
5786c: 2228 0038 movel %a0@(56),%d1
57870: b280 cmpl %d0,%d1
57872: 6310 blss 57884 <rtems_rfs_file_io_end+0xf4> <== NEVER TAKEN
57874: 5381 subql #1,%d1
57876: b280 cmpl %d0,%d1
57878: 661a bnes 57894 <rtems_rfs_file_io_end+0x104> <== NEVER TAKEN
5787a: 2228 003c movel %a0@(60),%d1
5787e: b2aa 0012 cmpl %a2@(18),%d1
57882: 6410 bccs 57894 <rtems_rfs_file_io_end+0x104>
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
57884: 216a 0012 003c movel %a2@(18),%a0@(60)
map->dirty = true;
5788a: 7001 moveq #1,%d0
rtems_rfs_file_bpos (handle)))
{
rtems_rfs_block_map_set_size_offset (rtems_rfs_file_map (handle),
handle->bpos.boff);
length = true;
mtime = true;
5788c: 7c01 moveq #1,%d6
5788e: 1140 0032 moveb %d0,%a0@(50)
57892: 6002 bras 57896 <rtems_rfs_file_io_end+0x106>
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
}
length = false;
mtime = false;
57894: 4206 clrb %d6
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
57896: 2012 movel %a2@,%d0
57898: 2a00 movel %d0,%d5
5789a: 4685 notl %d5
5789c: 7201 moveq #1,%d1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
5789e: 4284 clrl %d4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
578a0: ca81 andl %d1,%d5
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
578a2: 0800 0001 btst #1,%d0
578a6: 6602 bnes 578aa <rtems_rfs_file_io_end+0x11a> <== NEVER TAKEN
578a8: 1806 moveb %d6,%d4
length = rtems_rfs_file_update_length (handle) && length;
578aa: 44c0 movew %d0,%ccr
578ac: 6708 beqs 578b6 <rtems_rfs_file_io_end+0x126> <== NEVER TAKEN
578ae: 0286 0000 00ff andil #255,%d6
578b4: 6002 bras 578b8 <rtems_rfs_file_io_end+0x128>
578b6: 4286 clrl %d6 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
578b8: 42a7 clrl %sp@-
578ba: 4878 0020 pea 20 <OPER2+0xc>
578be: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
578c4: 508f addql #8,%sp
578c6: 4a00 tstb %d0
578c8: 6740 beqs 5790a <rtems_rfs_file_io_end+0x17a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
578ca: 4a06 tstb %d6 <== NOT EXECUTED
578cc: 6706 beqs 578d4 <rtems_rfs_file_io_end+0x144> <== NOT EXECUTED
578ce: 307c 004c moveaw #76,%a0 <== NOT EXECUTED
578d2: 6004 bras 578d8 <rtems_rfs_file_io_end+0x148> <== NOT EXECUTED
578d4: 307c 002d moveaw #45,%a0 <== NOT EXECUTED
578d8: 4a04 tstb %d4 <== NOT EXECUTED
578da: 6704 beqs 578e0 <rtems_rfs_file_io_end+0x150> <== NOT EXECUTED
578dc: 724d moveq #77,%d1 <== NOT EXECUTED
578de: 6002 bras 578e2 <rtems_rfs_file_io_end+0x152> <== NOT EXECUTED
578e0: 722d moveq #45,%d1 <== NOT EXECUTED
578e2: 4a05 tstb %d5 <== NOT EXECUTED
578e4: 6704 beqs 578ea <rtems_rfs_file_io_end+0x15a> <== NOT EXECUTED
578e6: 7041 moveq #65,%d0 <== NOT EXECUTED
578e8: 6002 bras 578ec <rtems_rfs_file_io_end+0x15c> <== NOT EXECUTED
578ea: 702d moveq #45,%d0 <== NOT EXECUTED
578ec: 2f08 movel %a0,%sp@- <== NOT EXECUTED
578ee: 2f01 movel %d1,%sp@- <== NOT EXECUTED
578f0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
578f2: 2f2a 0012 movel %a2@(18),%sp@- <== NOT EXECUTED
578f6: 2f2a 000e movel %a2@(14),%sp@- <== NOT EXECUTED
578fa: 4879 0006 c09a pea 6c09a <CSWTCH.1+0xdf4> <== NOT EXECUTED
57900: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57906: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
5790a: 4a05 tstb %d5
5790c: 6604 bnes 57912 <rtems_rfs_file_io_end+0x182> <== ALWAYS TAKEN
5790e: 4a04 tstb %d4 <== NOT EXECUTED
57910: 6728 beqs 5793a <rtems_rfs_file_io_end+0x1aa> <== NOT EXECUTED
{
time_t now = time (NULL);
57912: 42a7 clrl %sp@-
57914: 4eb9 0005 e53c jsr 5e53c <time>
if (read && atime)
5791a: 588f addql #4,%sp
5791c: 4a03 tstb %d3
5791e: 670e beqs 5792e <rtems_rfs_file_io_end+0x19e>
57920: 4a05 tstb %d5
57922: 6716 beqs 5793a <rtems_rfs_file_io_end+0x1aa> <== NEVER TAKEN
handle->shared->atime = now;
57924: 206a 001a moveal %a2@(26),%a0
57928: 2140 0084 movel %d0,%a0@(132)
5792c: 600c bras 5793a <rtems_rfs_file_io_end+0x1aa>
if (!read && mtime)
5792e: 4a04 tstb %d4
57930: 6708 beqs 5793a <rtems_rfs_file_io_end+0x1aa>
handle->shared->mtime = now;
57932: 206a 001a moveal %a2@(26),%a0
57936: 2140 0088 movel %d0,%a0@(136)
}
if (length)
5793a: 4a06 tstb %d6
5793c: 6710 beqs 5794e <rtems_rfs_file_io_end+0x1be>
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
5793e: 206a 001a moveal %a2@(26),%a0
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
57942: 2168 0038 007c movel %a0@(56),%a0@(124)
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
57948: 2168 003c 0080 movel %a0@(60),%a0@(128)
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
5794e: 2002 movel %d2,%d0
57950: 4cee 047c ffe8 moveml %fp@(-24),%d2-%d6/%a2
57956: 4e5e unlk %fp <== NOT EXECUTED
0005795a <rtems_rfs_file_io_release>:
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
5795a: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
5795e: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
57962: 4aa8 000a tstl %a0@(10) <== NOT EXECUTED
57966: 6716 beqs 5797e <rtems_rfs_file_io_release+0x24> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
57968: 4868 0004 pea %a0@(4) <== NOT EXECUTED
5796c: 2068 001a moveal %a0@(26),%a0 <== NOT EXECUTED
57970: 2f28 0090 movel %a0@(144),%sp@- <== NOT EXECUTED
57974: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
5797a: 508f addql #8,%sp <== NOT EXECUTED
5797c: 6002 bras 57980 <rtems_rfs_file_io_release+0x26> <== NOT EXECUTED
}
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
int rc = 0;
5797e: 4280 clrl %d0 <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
rtems_rfs_file_buffer (handle));
return rc;
}
57980: 4e5e unlk %fp <== NOT EXECUTED
000575ca <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
575ca: 4e56 ffec linkw %fp,#-20
575ce: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
575d2: 42a7 clrl %sp@-
575d4: 4878 0020 pea 20 <OPER2+0xc>
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
575d8: 246e 0008 moveal %fp@(8),%a2
575dc: 266e 000c moveal %fp@(12),%a3
575e0: 142e 0013 moveb %fp@(19),%d2
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
575e4: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
575ea: 508f addql #8,%sp
575ec: 4a00 tstb %d0
575ee: 672e beqs 5761e <rtems_rfs_file_io_start+0x54> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
575f0: 206a 0012 moveal %a2@(18),%a0 <== NOT EXECUTED
575f4: 222a 000e movel %a2@(14),%d1 <== NOT EXECUTED
575f8: 203c 0006 8fbc movel #430012,%d0 <== NOT EXECUTED
575fe: 4a02 tstb %d2 <== NOT EXECUTED
57600: 6706 beqs 57608 <rtems_rfs_file_io_start+0x3e> <== NOT EXECUTED
57602: 203c 0006 b094 movel #438420,%d0 <== NOT EXECUTED
57608: 2f08 movel %a0,%sp@- <== NOT EXECUTED
5760a: 2f01 movel %d1,%sp@- <== NOT EXECUTED
5760c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5760e: 4879 0006 bf7f pea 6bf7f <CSWTCH.1+0xcd9> <== NOT EXECUTED
57614: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5761a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
5761e: 4aaa 000a tstl %a2@(10)
57622: 6600 0106 bnew 5772a <rtems_rfs_file_io_start+0x160>
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
rtems_rfs_file_map (handle),
57626: 206a 001a moveal %a2@(26),%a0
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
5762a: 486e fffc pea %fp@(-4)
5762e: 486a 000e pea %a2@(14)
57632: 4868 0032 pea %a0@(50)
57636: 2f28 0090 movel %a0@(144),%sp@-
5763a: 4eb9 0005 5322 jsr 55322 <rtems_rfs_block_map_find>
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
57640: 4fef 0010 lea %sp@(16),%sp
57644: 4a80 tstl %d0
57646: 6f60 bles 576a8 <rtems_rfs_file_io_start+0xde> <== ALWAYS TAKEN
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
57648: 7206 moveq #6,%d1 <== NOT EXECUTED
5764a: 4a02 tstb %d2 <== NOT EXECUTED
5764c: 670c beqs 5765a <rtems_rfs_file_io_start+0x90> <== NOT EXECUTED
5764e: b280 cmpl %d0,%d1 <== NOT EXECUTED
57650: 6600 0134 bnew 57786 <rtems_rfs_file_io_start+0x1bc> <== NOT EXECUTED
{
*available = 0;
57654: 4293 clrl %a3@ <== NOT EXECUTED
57656: 6000 012c braw 57784 <rtems_rfs_file_io_start+0x1ba> <== NOT EXECUTED
return 0;
}
if (rc != ENXIO)
5765a: b280 cmpl %d0,%d1 <== NOT EXECUTED
5765c: 6600 0128 bnew 57786 <rtems_rfs_file_io_start+0x1bc> <== NOT EXECUTED
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
57660: 42a7 clrl %sp@- <== NOT EXECUTED
57662: 4878 0020 pea 20 <OPER2+0xc> <== NOT EXECUTED
57666: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5766c: 508f addql #8,%sp <== NOT EXECUTED
5766e: 4a00 tstb %d0 <== NOT EXECUTED
57670: 670e beqs 57680 <rtems_rfs_file_io_start+0xb6> <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: grow\n");
57672: 4879 0006 bfaa pea 6bfaa <CSWTCH.1+0xd04> <== NOT EXECUTED
57678: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
5767e: 588f addql #4,%sp <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
rtems_rfs_file_map (handle),
57680: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
57684: 486e fffc pea %fp@(-4) <== NOT EXECUTED
57688: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5768c: 4868 0032 pea %a0@(50) <== NOT EXECUTED
57690: 2f28 0090 movel %a0@(144),%sp@- <== NOT EXECUTED
57694: 4eb9 0005 54be jsr 554be <rtems_rfs_block_map_grow> <== NOT EXECUTED
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
5769a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
5769e: 4a80 tstl %d0 <== NOT EXECUTED
576a0: 6e00 00e4 bgtw 57786 <rtems_rfs_file_io_start+0x1bc> <== NOT EXECUTED
return rc;
request_read = false;
576a4: 4203 clrb %d3 <== NOT EXECUTED
576a6: 6024 bras 576cc <rtems_rfs_file_io_start+0x102> <== NOT EXECUTED
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
576a8: 4a02 tstb %d2
576aa: 661a bnes 576c6 <rtems_rfs_file_io_start+0xfc>
576ac: 4aaa 0012 tstl %a2@(18)
576b0: 6618 bnes 576ca <rtems_rfs_file_io_start+0x100> <== NEVER TAKEN
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
576b2: 206a 001a moveal %a2@(26),%a0
576b6: 2068 0090 moveal %a0@(144),%a0
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
576ba: 2068 0008 moveal %a0@(8),%a0
576be: b1d3 cmpal %a3@,%a0
576c0: 52c3 shi %d3
576c2: 4483 negl %d3
576c4: 6006 bras 576cc <rtems_rfs_file_io_start+0x102>
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
576c6: 1602 moveb %d2,%d3
576c8: 6002 bras 576cc <rtems_rfs_file_io_start+0x102>
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
576ca: 7601 moveq #1,%d3 <== NOT EXECUTED
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
576cc: 42a7 clrl %sp@-
576ce: 4878 0020 pea 20 <OPER2+0xc>
576d2: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
576d8: 508f addql #8,%sp
576da: 4a00 tstb %d0
576dc: 6726 beqs 57704 <rtems_rfs_file_io_start+0x13a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
576de: 203c 0006 b028 movel #438312,%d0 <== NOT EXECUTED
576e4: 4a03 tstb %d3 <== NOT EXECUTED
576e6: 6706 beqs 576ee <rtems_rfs_file_io_start+0x124> <== NOT EXECUTED
576e8: 203c 0006 ac35 movel #437301,%d0 <== NOT EXECUTED
576ee: 2f00 movel %d0,%sp@- <== NOT EXECUTED
576f0: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
576f4: 4879 0006 bfca pea 6bfca <CSWTCH.1+0xd24> <== NOT EXECUTED
576fa: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57700: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
57704: 0283 0000 00ff andil #255,%d3
5770a: 2f03 movel %d3,%sp@-
5770c: 2f2e fffc movel %fp@(-4),%sp@-
57710: 486a 0004 pea %a2@(4)
57714: 206a 001a moveal %a2@(26),%a0
57718: 2f28 0090 movel %a0@(144),%sp@-
5771c: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
57722: 4fef 0010 lea %sp@(16),%sp
57726: 4a80 tstl %d0
57728: 6e5c bgts 57786 <rtems_rfs_file_io_start+0x1bc> <== NEVER TAKEN
5772a: 206a 001a moveal %a2@(26),%a0
return rc;
}
if (read
5772e: 4a02 tstb %d2
57730: 671c beqs 5774e <rtems_rfs_file_io_start+0x184>
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
57732: 2028 0040 movel %a0@(64),%d0
57736: 6606 bnes 5773e <rtems_rfs_file_io_start+0x174> <== NEVER TAKEN
57738: 4aa8 0038 tstl %a0@(56)
5773c: 670a beqs 57748 <rtems_rfs_file_io_start+0x17e> <== NEVER TAKEN
5773e: 2228 0038 movel %a0@(56),%d1
57742: 5381 subql #1,%d1
57744: b280 cmpl %d0,%d1
57746: 6606 bnes 5774e <rtems_rfs_file_io_start+0x184> <== NEVER TAKEN
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
57748: 2428 003c movel %a0@(60),%d2
5774c: 6608 bnes 57756 <rtems_rfs_file_io_start+0x18c> <== ALWAYS TAKEN
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
5774e: 2068 0090 moveal %a0@(144),%a0
57752: 2428 0008 movel %a0@(8),%d2
*available = size - rtems_rfs_file_block_offset (handle);
57756: 2002 movel %d2,%d0
57758: 90aa 0012 subl %a2@(18),%d0
5775c: 2680 movel %d0,%a3@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
5775e: 42a7 clrl %sp@-
57760: 4878 0020 pea 20 <OPER2+0xc>
57764: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
5776a: 508f addql #8,%sp
5776c: 4a00 tstb %d0
5776e: 6714 beqs 57784 <rtems_rfs_file_io_start+0x1ba> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
57770: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57772: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
57774: 4879 0006 c000 pea 6c000 <CSWTCH.1+0xd5a> <== NOT EXECUTED
5777a: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57780: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
*available, size);
return 0;
57784: 4280 clrl %d0
}
57786: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
5778c: 4e5e unlk %fp <== NOT EXECUTED
00057d0a <rtems_rfs_file_open>:
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
57d0a: 4e56 ffe4 linkw %fp,#-28
57d0e: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
57d12: 42a7 clrl %sp@-
57d14: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
57d18: 286e 0008 moveal %fp@(8),%a4
57d1c: 262e 000c movel %fp@(12),%d3
57d20: 2a6e 0014 moveal %fp@(20),%a5
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
57d24: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
57d2a: 508f addql #8,%sp
57d2c: 4a00 tstb %d0
57d2e: 6710 beqs 57d40 <rtems_rfs_file_open+0x36> <== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
57d30: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57d32: 4879 0006 c110 pea 6c110 <CSWTCH.1+0xe6a> <== NOT EXECUTED
57d38: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57d3e: 508f addql #8,%sp <== NOT EXECUTED
*file = NULL;
57d40: 4295 clrl %a5@
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
57d42: 4878 001e pea 1e <OPER2+0xa>
57d46: 283c 0004 5af0 movel #285424,%d4
57d4c: 2044 moveal %d4,%a0
57d4e: 4e90 jsr %a0@
if (!handle)
57d50: 588f addql #4,%sp
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
57d52: 2440 moveal %d0,%a2
if (!handle)
57d54: 4a80 tstl %d0
57d56: 6700 02b0 beqw 58008 <rtems_rfs_file_open+0x2fe>
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
57d5a: 4878 001e pea 1e <OPER2+0xa>
57d5e: 243c 0005 b28c movel #373388,%d2
57d64: 2042 moveal %d2,%a0
57d66: 42a7 clrl %sp@-
57d68: 2f00 movel %d0,%sp@-
57d6a: 4e90 jsr %a0@
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
57d6c: 4200 clrb %d0
/*
* Scan the file system data list of open files for this ino. If found up
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
57d6e: 2f03 movel %d3,%sp@-
57d70: 1540 0004 moveb %d0,%a2@(4)
57d74: 2f0c movel %a4,%sp@-
handle->bnum = 0;
57d76: 42aa 0006 clrl %a2@(6)
handle->buffer = NULL;
57d7a: 42aa 000a clrl %a2@(10)
57d7e: 4eb9 0005 7cde jsr 57cde <rtems_rfs_file_get_shared>
if (shared)
57d84: 4fef 0014 lea %sp@(20),%sp
/*
* Scan the file system data list of open files for this ino. If found up
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
57d88: 2640 moveal %d0,%a3
if (shared)
57d8a: 4a80 tstl %d0
57d8c: 6724 beqs 57db2 <rtems_rfs_file_open+0xa8> <== ALWAYS TAKEN
{
shared->references++;
57d8e: 52ab 0008 addql #1,%a3@(8) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
57d92: 42a7 clrl %sp@- <== NOT EXECUTED
57d94: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
57d98: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
57d9e: 508f addql #8,%sp <== NOT EXECUTED
57da0: 4a00 tstb %d0 <== NOT EXECUTED
57da2: 6700 0256 beqw 57ffa <rtems_rfs_file_open+0x2f0> <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
57da6: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57da8: 4879 0006 c12f pea 6c12f <CSWTCH.1+0xe89> <== NOT EXECUTED
57dae: 6000 0242 braw 57ff2 <rtems_rfs_file_open+0x2e8> <== NOT EXECUTED
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
57db2: 4878 0094 pea 94 <DBL_MANT_DIG+0x5f>
57db6: 2044 moveal %d4,%a0
57db8: 4e90 jsr %a0@
if (!shared)
57dba: 588f addql #4,%sp
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
57dbc: 2640 moveal %d0,%a3
if (!shared)
57dbe: 4a80 tstl %d0
57dc0: 662a bnes 57dec <rtems_rfs_file_open+0xe2> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
57dc2: 486a 0004 pea %a2@(4) <== NOT EXECUTED
57dc6: 2f0c movel %a4,%sp@- <== NOT EXECUTED
57dc8: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
57dce: 4200 clrb %d0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
57dd0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57dd2: 1540 0004 moveb %d0,%a2@(4) <== NOT EXECUTED
handle->bnum = 0;
57dd6: 42aa 0006 clrl %a2@(6) <== NOT EXECUTED
handle->buffer = NULL;
57dda: 42aa 000a clrl %a2@(10) <== NOT EXECUTED
57dde: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return ENOMEM;
57de4: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57de8: 6000 021e braw 58008 <rtems_rfs_file_open+0x2fe> <== NOT EXECUTED
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
57dec: 4878 0094 pea 94 <DBL_MANT_DIG+0x5f>
57df0: 2042 moveal %d2,%a0
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
57df2: 280b movel %a3,%d4
57df4: 0684 0000 000c addil #12,%d4
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
57dfa: 42a7 clrl %sp@-
57dfc: 2f00 movel %d0,%sp@-
57dfe: 4e90 jsr %a0@
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
57e00: 4878 0001 pea 1 <ADD>
57e04: 2f04 movel %d4,%sp@-
57e06: 2f03 movel %d3,%sp@-
57e08: 2f0c movel %a4,%sp@-
57e0a: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
57e10: 4fef 001c lea %sp@(28),%sp
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
57e14: 2400 movel %d0,%d2
if (rc > 0)
57e16: 6f5e bles 57e76 <rtems_rfs_file_open+0x16c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
57e18: 42a7 clrl %sp@- <== NOT EXECUTED
57e1a: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
57e1e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
57e24: 508f addql #8,%sp <== NOT EXECUTED
57e26: 4a00 tstb %d0 <== NOT EXECUTED
57e28: 671c beqs 57e46 <rtems_rfs_file_open+0x13c> <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
57e2a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57e2c: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
57e32: 2f00 movel %d0,%sp@- <== NOT EXECUTED
57e34: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57e36: 4879 0006 c155 pea 6c155 <CSWTCH.1+0xeaf> <== NOT EXECUTED
57e3c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57e42: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
free (shared);
57e46: 2f0b movel %a3,%sp@- <== NOT EXECUTED
57e48: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
57e4e: 4e93 jsr %a3@ <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
57e50: 486a 0004 pea %a2@(4) <== NOT EXECUTED
57e54: 2f0c movel %a4,%sp@- <== NOT EXECUTED
57e56: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
57e5c: 4200 clrb %d0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
57e5e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57e60: 1540 0004 moveb %d0,%a2@(4) <== NOT EXECUTED
handle->bnum = 0;
57e64: 42aa 0006 clrl %a2@(6) <== NOT EXECUTED
handle->buffer = NULL;
57e68: 42aa 000a clrl %a2@(10) <== NOT EXECUTED
57e6c: 4e93 jsr %a3@ <== NOT EXECUTED
return rc;
57e6e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
57e72: 6000 0196 braw 5800a <rtems_rfs_file_open+0x300> <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
57e76: 486b 0032 pea %a3@(50)
57e7a: 2f04 movel %d4,%sp@-
57e7c: 2f0c movel %a4,%sp@-
57e7e: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open>
if (rc > 0)
57e84: 4fef 000c lea %sp@(12),%sp
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
57e88: 2400 movel %d0,%d2
if (rc > 0)
57e8a: 6f68 bles 57ef4 <rtems_rfs_file_open+0x1ea> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
57e8c: 42a7 clrl %sp@- <== NOT EXECUTED
57e8e: 4878 0008 pea 8 <DIVIDE_BY_ZERO> <== NOT EXECUTED
57e92: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
57e98: 508f addql #8,%sp <== NOT EXECUTED
57e9a: 4a00 tstb %d0 <== NOT EXECUTED
57e9c: 671c beqs 57eba <rtems_rfs_file_open+0x1b0> <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
57e9e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57ea0: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
57ea6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
57ea8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57eaa: 4879 0006 c186 pea 6c186 <CSWTCH.1+0xee0> <== NOT EXECUTED
57eb0: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57eb6: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
57eba: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57ebc: 2f0c movel %a4,%sp@- <== NOT EXECUTED
57ebe: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
free (shared);
57ec4: 2f0b movel %a3,%sp@- <== NOT EXECUTED
57ec6: 47f9 0004 54d0 lea 454d0 <free>,%a3 <== NOT EXECUTED
57ecc: 4e93 jsr %a3@ <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
57ece: 486a 0004 pea %a2@(4) <== NOT EXECUTED
57ed2: 2f0c movel %a4,%sp@- <== NOT EXECUTED
57ed4: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
57eda: 4201 clrb %d1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
57edc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
57ede: 1541 0004 moveb %d1,%a2@(4) <== NOT EXECUTED
handle->bnum = 0;
57ee2: 42aa 0006 clrl %a2@(6) <== NOT EXECUTED
handle->buffer = NULL;
57ee6: 42aa 000a clrl %a2@(10) <== NOT EXECUTED
57eea: 4e93 jsr %a3@ <== NOT EXECUTED
return rc;
57eec: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
57ef0: 6000 0118 braw 5800a <rtems_rfs_file_open+0x300> <== NOT EXECUTED
}
shared->references = 1;
57ef4: 7001 moveq #1,%d0
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
57ef6: 7218 moveq #24,%d1
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
57ef8: 206b 0018 moveal %a3@(24),%a0
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
57efc: 2740 0008 movel %d0,%a3@(8)
57f00: 4280 clrl %d0
57f02: 1028 000c moveb %a0@(12),%d0
57f06: e3a8 lsll %d1,%d0
57f08: 4281 clrl %d1
57f0a: 1228 000d moveb %a0@(13),%d1
57f0e: 4841 swap %d1
57f10: 4241 clrw %d1
57f12: 8081 orl %d1,%d0
57f14: 4281 clrl %d1
57f16: 1228 000f moveb %a0@(15),%d1
57f1a: 8081 orl %d1,%d0
57f1c: 1228 000e moveb %a0@(14),%d1
57f20: e189 lsll #8,%d1
57f22: 8081 orl %d1,%d0
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
57f24: 4281 clrl %d1
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
57f26: 2740 007c movel %d0,%a3@(124)
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
57f2a: 4280 clrl %d0
57f2c: 1028 000a moveb %a0@(10),%d0
57f30: 1228 000b moveb %a0@(11),%d1
57f34: e188 lsll #8,%d0
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
57f36: 8081 orl %d1,%d0
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
57f38: 7218 moveq #24,%d1
57f3a: 2740 0080 movel %d0,%a3@(128)
57f3e: 4280 clrl %d0
57f40: 1028 0010 moveb %a0@(16),%d0
57f44: e3a8 lsll %d1,%d0
57f46: 4281 clrl %d1
57f48: 1228 0011 moveb %a0@(17),%d1
57f4c: 4841 swap %d1
57f4e: 4241 clrw %d1
57f50: 8081 orl %d1,%d0
57f52: 4281 clrl %d1
57f54: 1228 0013 moveb %a0@(19),%d1
57f58: 8081 orl %d1,%d0
57f5a: 1228 0012 moveb %a0@(18),%d1
57f5e: e189 lsll #8,%d1
57f60: 8081 orl %d1,%d0
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
57f62: 7218 moveq #24,%d1
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
57f64: 2740 0084 movel %d0,%a3@(132)
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
57f68: 4280 clrl %d0
57f6a: 1028 0014 moveb %a0@(20),%d0
57f6e: e3a8 lsll %d1,%d0
57f70: 4281 clrl %d1
57f72: 1228 0015 moveb %a0@(21),%d1
57f76: 4841 swap %d1
57f78: 4241 clrw %d1
57f7a: 8081 orl %d1,%d0
57f7c: 4281 clrl %d1
57f7e: 1228 0017 moveb %a0@(23),%d1
57f82: 8081 orl %d1,%d0
57f84: 1228 0016 moveb %a0@(22),%d1
57f88: e189 lsll #8,%d1
57f8a: 8081 orl %d1,%d0
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
57f8c: 7218 moveq #24,%d1
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
57f8e: 2740 0088 movel %d0,%a3@(136)
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
57f92: 4280 clrl %d0
57f94: 1028 0018 moveb %a0@(24),%d0
57f98: e3a8 lsll %d1,%d0
57f9a: 4281 clrl %d1
57f9c: 1228 0019 moveb %a0@(25),%d1
57fa0: 4841 swap %d1
57fa2: 4241 clrw %d1
57fa4: 8081 orl %d1,%d0
57fa6: 4281 clrl %d1
57fa8: 1228 001b moveb %a0@(27),%d1
57fac: 8081 orl %d1,%d0
57fae: 1228 001a moveb %a0@(26),%d1
57fb2: e189 lsll #8,%d1
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
57fb4: 274c 0090 movel %a4,%a3@(144)
57fb8: 8081 orl %d1,%d0
57fba: 2740 008c movel %d0,%a3@(140)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
57fbe: 2f0b movel %a3,%sp@-
57fc0: 486c 0070 pea %a4@(112)
57fc4: 4eb9 0004 99ac jsr 499ac <_Chain_Append>
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
57fca: 42a7 clrl %sp@-
57fcc: 2f04 movel %d4,%sp@-
57fce: 2f0c movel %a4,%sp@-
57fd0: 4eb9 0004 d7a0 jsr 4d7a0 <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
57fd6: 42a7 clrl %sp@-
57fd8: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
57fdc: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
57fe2: 4fef 001c lea %sp@(28),%sp
57fe6: 4a00 tstb %d0
57fe8: 6710 beqs 57ffa <rtems_rfs_file_open+0x2f0> <== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
57fea: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57fec: 4879 0006 c1bb pea 6c1bb <CSWTCH.1+0xf15> <== NOT EXECUTED
57ff2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57ff8: 508f addql #8,%sp <== NOT EXECUTED
}
handle->flags = flags;
57ffa: 24ae 0010 movel %fp@(16),%a2@
handle->shared = shared;
*file = handle;
return 0;
57ffe: 4282 clrl %d2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = flags;
handle->shared = shared;
58000: 254b 001a movel %a3,%a2@(26)
*file = handle;
58004: 2a8a movel %a2,%a5@
return 0;
58006: 6002 bras 5800a <rtems_rfs_file_open+0x300>
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
if (!handle)
return ENOMEM;
58008: 740c moveq #12,%d2 <== NOT EXECUTED
handle->shared = shared;
*file = handle;
return 0;
}
5800a: 2002 movel %d2,%d0
5800c: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
58012: 4e5e unlk %fp
...
00057984 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
57984: 4e56 ffec linkw %fp,#-20
57988: 48d7 043c moveml %d2-%d5/%a2,%sp@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
5798c: 42a7 clrl %sp@-
5798e: 4878 0020 pea 20 <OPER2+0xc>
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
57992: 246e 0008 moveal %fp@(8),%a2
57996: 242e 000c movel %fp@(12),%d2
5799a: 262e 0010 movel %fp@(16),%d3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
5799e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
579a4: 508f addql #8,%sp
579a6: 4a00 tstb %d0
579a8: 6714 beqs 579be <rtems_rfs_file_seek+0x3a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
579aa: 2f03 movel %d3,%sp@- <== NOT EXECUTED
579ac: 2f02 movel %d2,%sp@- <== NOT EXECUTED
579ae: 4879 0006 c0cb pea 6c0cb <CSWTCH.1+0xe25> <== NOT EXECUTED
579b4: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
579ba: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
579be: 206a 001a moveal %a2@(26),%a0
579c2: 4868 007c pea %a0@(124)
579c6: 2f28 0090 movel %a0@(144),%sp@-
579ca: 2802 movel %d2,%d4
579cc: 2a03 movel %d3,%d5
579ce: 4eb9 0005 4f90 jsr 54f90 <rtems_rfs_block_get_size>
579d4: 508f addql #8,%sp
579d6: 9a81 subl %d1,%d5
579d8: 9980 subxl %d0,%d4
579da: 641a bccs 579f6 <rtems_rfs_file_seek+0x72>
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
579dc: 486a 000e pea %a2@(14) <== NOT EXECUTED
579e0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
579e2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
579e4: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
579e8: 2f28 0090 movel %a0@(144),%sp@- <== NOT EXECUTED
579ec: 4eb9 0005 4ebe jsr 54ebe <rtems_rfs_block_get_bpos> <== NOT EXECUTED
579f2: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
*new_pos = pos;
579f6: 206e 0014 moveal %fp@(20),%a0
return 0;
}
579fa: 4280 clrl %d0
*/
if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
*new_pos = pos;
579fc: 2082 movel %d2,%a0@
579fe: 2143 0004 movel %d3,%a0@(4)
return 0;
}
57a02: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
57a08: 4e5e unlk %fp <== NOT EXECUTED
00057a0c <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
57a0c: 4e56 ffac linkw %fp,#-84
57a10: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
57a14: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
57a18: 266a 001a moveal %a2@(26),%a3
57a1c: 41eb 0032 lea %a3@(50),%a0
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
57a20: 42a7 clrl %sp@-
57a22: 4878 0020 pea 20 <OPER2+0xc>
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
57a26: 242e 000c movel %fp@(12),%d2
57a2a: 262e 0010 movel %fp@(16),%d3
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
57a2e: 2d48 ffd4 movel %a0,%fp@(-44)
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
57a32: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
57a38: 508f addql #8,%sp
57a3a: 4a00 tstb %d0
57a3c: 6714 beqs 57a52 <rtems_rfs_file_set_size+0x46> <== ALWAYS TAKEN
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
57a3e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57a40: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57a42: 4879 0006 c0eb pea 6c0eb <CSWTCH.1+0xe45> <== NOT EXECUTED
57a48: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
57a4e: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57a52: 206a 001a moveal %a2@(26),%a0
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
57a56: 2002 movel %d2,%d0
57a58: 8083 orl %d3,%d0
57a5a: 661a bnes 57a76 <rtems_rfs_file_set_size+0x6a>
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
57a5c: 2f2e ffd4 movel %fp@(-44),%sp@-
57a60: 2f28 0090 movel %a0@(144),%sp@-
57a64: 4eb9 0005 5a0c jsr 55a0c <rtems_rfs_block_map_free_all>
if (rc > 0)
57a6a: 508f addql #8,%sp
57a6c: 4a80 tstl %d0
57a6e: 6e00 0264 bgtw 57cd4 <rtems_rfs_file_set_size+0x2c8>
57a72: 6000 0238 braw 57cac <rtems_rfs_file_set_size+0x2a0>
57a76: 4868 007c pea %a0@(124)
57a7a: 2f28 0090 movel %a0@(144),%sp@-
57a7e: 4eb9 0005 4f90 jsr 54f90 <rtems_rfs_block_get_size>
size = rtems_rfs_file_size (handle);
/*
* If the file is same size do nothing else grow or shrink it ?
*/
if (size != new_size)
57a84: 508f addql #8,%sp
57a86: 2800 movel %d0,%d4
57a88: 2a01 movel %d1,%d5
57a8a: 9a83 subl %d3,%d5
57a8c: 9982 subxl %d2,%d4
57a8e: 6700 021c beqw 57cac <rtems_rfs_file_set_size+0x2a0>
57a92: 286a 001a moveal %a2@(26),%a4
{
if (size < new_size)
57a96: 2800 movel %d0,%d4
57a98: 2a01 movel %d1,%d5
57a9a: 9a83 subl %d3,%d5
57a9c: 9982 subxl %d2,%d4
57a9e: 6400 0176 bccw 57c16 <rtems_rfs_file_set_size+0x20a>
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
57aa2: 206c 0090 moveal %a4@(144),%a0
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
57aa6: 4bf9 0005 5322 lea 55322 <rtems_rfs_block_map_find>,%a5
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
57aac: 2a02 movel %d2,%d5
57aae: 2c03 movel %d3,%d6
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
57ab0: 240a movel %a2,%d2
57ab2: 5882 addql #4,%d2
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
57ab4: 260e movel %fp,%d3
57ab6: 5983 subql #4,%d3
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
57ab8: 9c81 subl %d1,%d6
57aba: 9b80 subxl %d0,%d5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
57abc: 2868 0008 moveal %a0@(8),%a4
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
57ac0: 2d45 ffe8 movel %d5,%fp@(-24)
57ac4: 2d46 ffec movel %d6,%fp@(-20)
57ac8: 2a2e ffd4 movel %fp@(-44),%d5
57acc: 2d42 ffd4 movel %d2,%fp@(-44)
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
57ad0: 4204 clrb %d4
while (count)
57ad2: 6000 0132 braw 57c06 <rtems_rfs_file_set_size+0x1fa>
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
57ad6: 202b 0038 movel %a3@(56),%d0
57ada: 222b 003c movel %a3@(60),%d1
57ade: 2d40 fff0 movel %d0,%fp@(-16)
57ae2: 2d41 fff4 movel %d1,%fp@(-12)
57ae6: 42ae fff8 clrl %fp@(-8)
57aea: 4a81 tstl %d1
57aec: 6706 beqs 57af4 <rtems_rfs_file_set_size+0xe8>
57aee: 5380 subql #1,%d0
57af0: 2d40 fff0 movel %d0,%fp@(-16)
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
57af4: 2f03 movel %d3,%sp@-
57af6: 486e fff0 pea %fp@(-16)
57afa: 2f05 movel %d5,%sp@-
57afc: 206a 001a moveal %a2@(26),%a0
57b00: 2f28 0090 movel %a0@(144),%sp@-
57b04: 4e95 jsr %a5@
map, &bpos, &block);
if (rc > 0)
57b06: 4fef 0010 lea %sp@(16),%sp
57b0a: 4a80 tstl %d0
57b0c: 6f28 bles 57b36 <rtems_rfs_file_set_size+0x12a>
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
57b0e: 7c06 moveq #6,%d6
57b10: bc80 cmpl %d0,%d6
57b12: 6600 01c0 bnew 57cd4 <rtems_rfs_file_set_size+0x2c8>
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
57b16: 2f03 movel %d3,%sp@-
57b18: 4878 0001 pea 1 <ADD>
57b1c: 2f05 movel %d5,%sp@-
57b1e: 206a 001a moveal %a2@(26),%a0
57b22: 2f28 0090 movel %a0@(144),%sp@-
57b26: 4eb9 0005 54be jsr 554be <rtems_rfs_block_map_grow>
map, 1, &block);
if (rc > 0)
57b2c: 4fef 0010 lea %sp@(16),%sp
57b30: 4a80 tstl %d0
57b32: 6e00 01a0 bgtw 57cd4 <rtems_rfs_file_set_size+0x2c8>
return rc;
}
if (count < (length - bpos.boff))
57b36: 202e fff4 movel %fp@(-12),%d0
57b3a: 220c movel %a4,%d1
57b3c: 9280 subl %d0,%d1
57b3e: 91c8 subal %a0,%a0
57b40: 2d41 ffe4 movel %d1,%fp@(-28)
57b44: 222e ffe8 movel %fp@(-24),%d1
57b48: 242e ffec movel %fp@(-20),%d2
57b4c: 2d48 ffe0 movel %a0,%fp@(-32)
57b50: 2c2e ffe0 movel %fp@(-32),%d6
57b54: 2e2e ffe4 movel %fp@(-28),%d7
57b58: 9487 subl %d7,%d2
57b5a: 9386 subxl %d6,%d1
57b5c: 6414 bccs 57b72 <rtems_rfs_file_set_size+0x166>
{
length = count + bpos.boff;
57b5e: 286e ffec moveal %fp@(-20),%a4
57b62: d9c0 addal %d0,%a4
57b64: 7e01 moveq #1,%d7
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
57b66: 274c 003c movel %a4,%a3@(60)
map->dirty = true;
57b6a: 1747 0032 moveb %d7,%a3@(50)
read_block = true;
57b6e: 7801 moveq #1,%d4
57b70: 600a bras 57b7c <rtems_rfs_file_set_size+0x170>
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
57b72: 42ab 003c clrl %a3@(60)
map->dirty = true;
57b76: 7001 moveq #1,%d0
57b78: 1740 0032 moveb %d0,%a3@(50)
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
57b7c: 7201 moveq #1,%d1
57b7e: c284 andl %d4,%d1
57b80: 2f01 movel %d1,%sp@-
57b82: 2f2e fffc movel %fp@(-4),%sp@-
57b86: 2f2e ffd4 movel %fp@(-44),%sp@-
57b8a: 206a 001a moveal %a2@(26),%a0
57b8e: 2f28 0090 movel %a0@(144),%sp@-
57b92: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
57b98: 4fef 0010 lea %sp@(16),%sp
57b9c: 4a80 tstl %d0
57b9e: 6e00 0134 bgtw 57cd4 <rtems_rfs_file_set_size+0x2c8>
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
57ba2: 202e fff4 movel %fp@(-12),%d0
57ba6: 240c movel %a4,%d2
57ba8: 9480 subl %d0,%d2
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
57baa: 206a 000a moveal %a2@(10),%a0
memset (dst + bpos.boff, 0, length - bpos.boff);
57bae: 2f02 movel %d2,%sp@-
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
57bb0: 7c01 moveq #1,%d6
block, read_block);
if (rc > 0)
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
57bb2: 42a7 clrl %sp@-
57bb4: d0a8 001e addl %a0@(30),%d0
57bb8: 2f00 movel %d0,%sp@-
57bba: 4eb9 0005 b28c jsr 5b28c <memset>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
57bc0: 1546 0004 moveb %d6,%a2@(4)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
57bc4: 2f2e ffd4 movel %fp@(-44),%sp@-
57bc8: 206a 001a moveal %a2@(26),%a0
57bcc: 2f28 0090 movel %a0@(144),%sp@-
57bd0: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
57bd6: 4fef 0014 lea %sp@(20),%sp
57bda: 4a80 tstl %d0
57bdc: 6e00 00f6 bgtw 57cd4 <rtems_rfs_file_set_size+0x2c8>
return rc;
count -= length - bpos.boff;
57be0: 200c movel %a4,%d0
57be2: 90ae fff4 subl %fp@(-12),%d0
57be6: 91c8 subal %a0,%a0
57be8: 2d40 ffdc movel %d0,%fp@(-36)
57bec: 2d48 ffd8 movel %a0,%fp@(-40)
57bf0: 2c2e ffd8 movel %fp@(-40),%d6
57bf4: 2e2e ffdc movel %fp@(-36),%d7
57bf8: 9fae ffec subl %d7,%fp@(-20)
57bfc: 202e ffe8 movel %fp@(-24),%d0
57c00: 9186 subxl %d6,%d0
57c02: 2d40 ffe8 movel %d0,%fp@(-24)
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
57c06: 222e ffe8 movel %fp@(-24),%d1
57c0a: 82ae ffec orl %fp@(-20),%d1
57c0e: 6600 fec6 bnew 57ad6 <rtems_rfs_file_set_size+0xca>
57c12: 6000 0098 braw 57cac <rtems_rfs_file_set_size+0x2a0>
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
57c16: 2a6c 0090 moveal %a4@(144),%a5 <== NOT EXECUTED
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
57c1a: 4286 clrl %d6 <== NOT EXECUTED
57c1c: 2e2d 0008 movel %a5@(8),%d7 <== NOT EXECUTED
57c20: 78ff moveq #-1,%d4 <== NOT EXECUTED
57c22: 7aff moveq #-1,%d5 <== NOT EXECUTED
57c24: 2f07 movel %d7,%sp@- <== NOT EXECUTED
57c26: da83 addl %d3,%d5 <== NOT EXECUTED
57c28: d982 addxl %d2,%d4 <== NOT EXECUTED
57c2a: 2f06 movel %d6,%sp@- <== NOT EXECUTED
57c2c: 2f05 movel %d5,%sp@- <== NOT EXECUTED
57c2e: 2f04 movel %d4,%sp@- <== NOT EXECUTED
57c30: 4eb9 0006 7a1c jsr 67a1c <__udivdi3> <== NOT EXECUTED
57c36: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
57c3a: 4681 notl %d1 <== NOT EXECUTED
57c3c: d2ab 0038 addl %a3@(56),%d1 <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
57c40: 6716 beqs 57c58 <rtems_rfs_file_set_size+0x24c> <== NOT EXECUTED
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
57c42: 2f01 movel %d1,%sp@- <== NOT EXECUTED
57c44: 486c 0032 pea %a4@(50) <== NOT EXECUTED
57c48: 2f0d movel %a5,%sp@- <== NOT EXECUTED
57c4a: 4eb9 0005 577a jsr 5577a <rtems_rfs_block_map_shrink> <== NOT EXECUTED
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
57c50: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
57c54: 4a80 tstl %d0 <== NOT EXECUTED
57c56: 6e7c bgts 57cd4 <rtems_rfs_file_set_size+0x2c8> <== NOT EXECUTED
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
57c58: 2f07 movel %d7,%sp@- <== NOT EXECUTED
57c5a: 7a01 moveq #1,%d5 <== NOT EXECUTED
57c5c: 2f06 movel %d6,%sp@- <== NOT EXECUTED
57c5e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
57c60: 2f02 movel %d2,%sp@- <== NOT EXECUTED
57c62: 4eb9 0006 7e48 jsr 67e48 <__umoddi3> <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
57c68: 206a 000e moveal %a2@(14),%a0 <== NOT EXECUTED
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
57c6c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
57c70: 1745 0032 moveb %d5,%a3@(50) <== NOT EXECUTED
57c74: 202b 0038 movel %a3@(56),%d0 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
57c78: 2741 003c movel %d1,%a3@(60) <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
57c7c: 4a88 tstl %a0 <== NOT EXECUTED
57c7e: 6704 beqs 57c84 <rtems_rfs_file_set_size+0x278> <== NOT EXECUTED
57c80: 4a80 tstl %d0 <== NOT EXECUTED
57c82: 6712 beqs 57c96 <rtems_rfs_file_set_size+0x28a> <== NOT EXECUTED
57c84: b088 cmpl %a0,%d0 <== NOT EXECUTED
57c86: 630e blss 57c96 <rtems_rfs_file_set_size+0x28a> <== NOT EXECUTED
57c88: 2240 moveal %d0,%a1 <== NOT EXECUTED
57c8a: 5389 subql #1,%a1 <== NOT EXECUTED
57c8c: b3c8 cmpal %a0,%a1 <== NOT EXECUTED
57c8e: 661c bnes 57cac <rtems_rfs_file_set_size+0x2a0> <== NOT EXECUTED
57c90: b2aa 0012 cmpl %a2@(18),%d1 <== NOT EXECUTED
57c94: 6416 bccs 57cac <rtems_rfs_file_set_size+0x2a0> <== NOT EXECUTED
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
57c96: 2540 000e movel %d0,%a2@(14) <== NOT EXECUTED
57c9a: 2541 0012 movel %d1,%a2@(18) <== NOT EXECUTED
57c9e: 42aa 0016 clrl %a2@(22) <== NOT EXECUTED
57ca2: 4a81 tstl %d1 <== NOT EXECUTED
57ca4: 6706 beqs 57cac <rtems_rfs_file_set_size+0x2a0> <== NOT EXECUTED
57ca6: 5380 subql #1,%d0 <== NOT EXECUTED
57ca8: 2540 000e movel %d0,%a2@(14) <== NOT EXECUTED
rtems_rfs_file_bpos (handle));
}
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
57cac: 286a 001a moveal %a2@(26),%a4
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
57cb0: 7002 moveq #2,%d0
57cb2: c092 andl %a2@,%d0
rtems_rfs_file_bpos (handle));
}
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
57cb4: 296b 0038 007c movel %a3@(56),%a4@(124)
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
57cba: 296b 003c 0080 movel %a3@(60),%a4@(128)
if (rtems_rfs_file_update_mtime (handle))
57cc0: 4a80 tstl %d0
57cc2: 660e bnes 57cd2 <rtems_rfs_file_set_size+0x2c6> <== NEVER TAKEN
handle->shared->mtime = time (NULL);
57cc4: 42a7 clrl %sp@-
57cc6: 4eb9 0005 e53c jsr 5e53c <time>
57ccc: 588f addql #4,%sp
57cce: 2940 0088 movel %d0,%a4@(136)
return 0;
57cd2: 4280 clrl %d0
}
57cd4: 4cee 3cfc ffac moveml %fp@(-84),%d2-%d7/%a2-%a5
57cda: 4e5e unlk %fp <== NOT EXECUTED
0004c57c <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
4c57c: 4e56 fefc linkw %fp,#-260
4c580: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4c584: 246e 000c moveal %fp@(12),%a2
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
4c588: 4a2a 0015 tstb %a2@(21)
4c58c: 6712 beqs 4c5a0 <rtems_rfs_format+0x24> <== ALWAYS TAKEN
printf ("rtems-rfs: format: %s\n", name);
4c58e: 2f2e 0008 movel %fp@(8),%sp@- <== NOT EXECUTED
4c592: 4879 0006 a202 pea 6a202 <ramdisk_ops+0x18> <== NOT EXECUTED
4c598: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4c59e: 508f addql #8,%sp <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
4c5a0: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
4c5a4: 240e movel %fp,%d2
4c5a6: 0682 ffff ff30 addil #-208,%d2
4c5ac: 42a7 clrl %sp@-
4c5ae: 2f02 movel %d2,%sp@-
4c5b0: 4eb9 0005 b28c jsr 5b28c <memset>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4c5b6: 2042 moveal %d2,%a0
4c5b8: 41e8 0044 lea %a0@(68),%a0
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
4c5bc: 7005 moveq #5,%d0
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
4c5be: 7202 moveq #2,%d1
4c5c0: 2d48 ff70 movel %a0,%fp@(-144)
head->previous = NULL;
tail->previous = head;
4c5c4: 5988 subql #4,%a0
4c5c6: 2d48 ff78 movel %a0,%fp@(-136)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4c5ca: 41ee ff84 lea %fp@(-124),%a0
4c5ce: 2d48 ff80 movel %a0,%fp@(-128)
head->previous = NULL;
tail->previous = head;
4c5d2: 41ee ff80 lea %fp@(-128),%a0
4c5d6: 2d48 ff88 movel %a0,%fp@(-120)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4c5da: 41ee ff94 lea %fp@(-108),%a0
4c5de: 2d48 ff90 movel %a0,%fp@(-112)
head->previous = NULL;
tail->previous = head;
4c5e2: 41ee ff90 lea %fp@(-112),%a0
4c5e6: 2d48 ff98 movel %a0,%fp@(-104)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4c5ea: 41ee ffa4 lea %fp@(-92),%a0
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4c5ee: 2f02 movel %d2,%sp@-
4c5f0: 2f2e 0008 movel %fp@(8),%sp@-
4c5f4: 2d48 ffa0 movel %a0,%fp@(-96)
head->previous = NULL;
tail->previous = head;
4c5f8: 41ee ffa0 lea %fp@(-96),%a0
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
4c5fc: 2d40 ff6c movel %d0,%fp@(-148)
4c600: 2d48 ffa8 movel %a0,%fp@(-88)
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
4c604: 2d41 ff30 movel %d1,%fp@(-208)
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4c608: 4eb9 0005 5f12 jsr 55f12 <rtems_rfs_buffer_open>
if (rc > 0)
4c60e: 4fef 0014 lea %sp@(20),%sp
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
4c612: 2600 movel %d0,%d3
if (rc > 0)
4c614: 6f16 bles 4c62c <rtems_rfs_format+0xb0> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
4c616: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c618: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4c61e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c620: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4c622: 4879 0006 a219 pea 6a219 <ramdisk_ops+0x2f> <== NOT EXECUTED
4c628: 6000 09ea braw 4d014 <rtems_rfs_format+0xa98> <== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
4c62c: 206e ff3c moveal %fp@(-196),%a0
4c630: 4aa8 0024 tstl %a0@(36)
4c634: 660c bnes 4c642 <rtems_rfs_format+0xc6> <== ALWAYS TAKEN
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
4c636: 42a7 clrl %sp@- <== NOT EXECUTED
4c638: 4879 0006 a248 pea 6a248 <ramdisk_ops+0x5e> <== NOT EXECUTED
4c63e: 6000 0492 braw 4cad2 <rtems_rfs_format+0x556> <== NOT EXECUTED
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
4c642: 2012 movel %a2@,%d0
4c644: 2d40 ff38 movel %d0,%fp@(-200)
if (!fs->block_size)
4c648: 666e bnes 4c6b8 <rtems_rfs_format+0x13c> <== ALWAYS TAKEN
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
4c64a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
if (total_size >= GIGS (1))
4c64c: 4282 clrl %d2 <== NOT EXECUTED
4c64e: 263c 000f ffff movel #1048575,%d3 <== NOT EXECUTED
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
4c654: 4eb9 0005 8048 jsr 58048 <rtems_rfs_fs_media_size> <== NOT EXECUTED
if (total_size >= GIGS (1))
4c65a: 588f addql #4,%sp <== NOT EXECUTED
4c65c: 9681 subl %d1,%d3 <== NOT EXECUTED
4c65e: 9580 subxl %d0,%d2 <== NOT EXECUTED
4c660: 6432 bccs 4c694 <rtems_rfs_format+0x118> <== NOT EXECUTED
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
4c662: 7a0c moveq #12,%d5 <== NOT EXECUTED
4c664: 4283 clrl %d3 <== NOT EXECUTED
4c666: 0681 0010 0000 addil #1048576,%d1 <== NOT EXECUTED
4c66c: d183 addxl %d3,%d0 <== NOT EXECUTED
4c66e: 7614 moveq #20,%d3 <== NOT EXECUTED
4c670: 2400 movel %d0,%d2 <== NOT EXECUTED
4c672: 2001 movel %d1,%d0 <== NOT EXECUTED
4c674: e6a8 lsrl %d3,%d0 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
4c676: 163c 0001 moveb #1,%d3 <== NOT EXECUTED
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
4c67a: ebaa lsll %d5,%d2 <== NOT EXECUTED
4c67c: 8480 orl %d0,%d2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
4c67e: 701f moveq #31,%d0 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4c680: 2203 movel %d3,%d1 <== NOT EXECUTED
4c682: e1a9 lsll %d0,%d1 <== NOT EXECUTED
4c684: c282 andl %d2,%d1 <== NOT EXECUTED
4c686: 6604 bnes 4c68c <rtems_rfs_format+0x110> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
4c688: 5380 subql #1,%d0 <== NOT EXECUTED
4c68a: 66f4 bnes 4c680 <rtems_rfs_format+0x104> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
4c68c: 7201 moveq #1,%d1 <== NOT EXECUTED
4c68e: e1a9 lsll %d0,%d1 <== NOT EXECUTED
4c690: 2d41 ff38 movel %d1,%fp@(-200) <== NOT EXECUTED
}
if (fs->block_size < 512)
4c694: 2a3c 0000 01ff movel #511,%d5 <== NOT EXECUTED
4c69a: baae ff38 cmpl %fp@(-200),%d5 <== NOT EXECUTED
4c69e: 6508 bcss 4c6a8 <rtems_rfs_format+0x12c> <== NOT EXECUTED
fs->block_size = 512;
4c6a0: 307c 0200 moveaw #512,%a0 <== NOT EXECUTED
4c6a4: 2d48 ff38 movel %a0,%fp@(-200) <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
4c6a8: 203c 0000 1000 movel #4096,%d0 <== NOT EXECUTED
4c6ae: b0ae ff38 cmpl %fp@(-200),%d0 <== NOT EXECUTED
4c6b2: 6404 bccs 4c6b8 <rtems_rfs_format+0x13c> <== NOT EXECUTED
fs->block_size = (4 * 1024);
4c6b4: 2d40 ff38 movel %d0,%fp@(-200) <== NOT EXECUTED
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
4c6b8: 206e ff3c moveal %fp@(-196),%a0
4c6bc: 202e ff38 movel %fp@(-200),%d0
4c6c0: 2600 movel %d0,%d3
4c6c2: 2228 0024 movel %a0@(36),%d1
4c6c6: 4c41 3002 remul %d1,%d2,%d3
4c6ca: 4a82 tstl %d2
4c6cc: 6718 beqs 4c6e6 <rtems_rfs_format+0x16a> <== ALWAYS TAKEN
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
4c6ce: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4c6d0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c6d2: 4879 0006 a270 pea 6a270 <ramdisk_ops+0x86> <== NOT EXECUTED
4c6d8: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4c6de: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4c6e2: 6000 093a braw 4d01e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
4c6e6: 222a 0004 movel %a2@(4),%d1
4c6ea: e788 lsll #3,%d0
4c6ec: 2d41 ff54 movel %d1,%fp@(-172)
if (!fs->group_blocks)
4c6f0: 6604 bnes 4c6f6 <rtems_rfs_format+0x17a> <== NEVER TAKEN
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
4c6f2: 2d40 ff54 movel %d0,%fp@(-172)
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
4c6f6: b0ae ff54 cmpl %fp@(-172),%d0
4c6fa: 640a bccs 4c706 <rtems_rfs_format+0x18a> <== ALWAYS TAKEN
{
printf ("group block count is higher than bits in block\n");
4c6fc: 4879 0006 a2ae pea 6a2ae <ramdisk_ops+0xc4> <== NOT EXECUTED
4c702: 6000 0392 braw 4ca96 <rtems_rfs_format+0x51a> <== NOT EXECUTED
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4c706: 486e ff30 pea %fp@(-208)
4c70a: 4eb9 0005 8048 jsr 58048 <rtems_rfs_fs_media_size>
4c710: 242e ff38 movel %fp@(-200),%d2
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c714: 2602 movel %d2,%d3
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4c716: 2f02 movel %d2,%sp@-
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c718: e78b lsll #3,%d3
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4c71a: 42a7 clrl %sp@-
4c71c: 2f01 movel %d1,%sp@-
4c71e: 2f00 movel %d0,%sp@-
4c720: 4eb9 0006 7a1c jsr 67a1c <__udivdi3>
4c726: 4fef 0010 lea %sp@(16),%sp
4c72a: 2801 movel %d1,%d4
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4c72c: 2f03 movel %d3,%sp@-
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
4c72e: 2d41 ff34 movel %d1,%fp@(-204)
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4c732: 2f01 movel %d1,%sp@-
4c734: 4eb9 0004 c506 jsr 4c506 <rtems_rfs_rup_quotient>
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
4c73a: 222a 0008 movel %a2@(8),%d1
if (!fs->group_inodes)
4c73e: 4fef 000c lea %sp@(12),%sp
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4c742: 2d40 ff50 movel %d0,%fp@(-176)
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
4c746: 2d41 ff58 movel %d1,%fp@(-168)
if (!fs->group_inodes)
4c74a: 6632 bnes 4c77e <rtems_rfs_format+0x202> <== NEVER TAKEN
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
4c74c: 222a 000c movel %a2@(12),%d1
4c750: 6604 bnes 4c756 <rtems_rfs_format+0x1da> <== NEVER TAKEN
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
if (!fs->group_inodes)
{
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
4c752: 123c 0001 moveb #1,%d1
static int
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
4c756: 5384 subql #1,%d4
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
4c758: 4c01 4800 mulsl %d1,%d4
4c75c: 7264 moveq #100,%d1
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
4c75e: 7a38 moveq #56,%d5
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
4c760: 2f00 movel %d0,%sp@-
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
4c762: 4c41 4004 remul %d1,%d4,%d4
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
4c766: 2f04 movel %d4,%sp@-
4c768: 4eb9 0004 c506 jsr 4c506 <rtems_rfs_rup_quotient>
4c76e: 508f addql #8,%sp
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
4c770: 2202 movel %d2,%d1
4c772: 4c45 1001 remul %d5,%d1,%d1
4c776: 4c01 0800 mulsl %d1,%d0
4c77a: 2d40 ff58 movel %d0,%fp@(-168)
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
4c77e: 7238 moveq #56,%d1
4c780: 4c41 2002 remul %d1,%d2,%d2
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
4c784: 2f02 movel %d2,%sp@-
4c786: 2f2e ff58 movel %fp@(-168),%sp@-
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
4c78a: 2d42 ff5c movel %d2,%fp@(-164)
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
4c78e: 4eb9 0004 c506 jsr 4c506 <rtems_rfs_rup_quotient>
4c794: 508f addql #8,%sp
fs->inodes_per_block) * fs->inodes_per_block;
4c796: 4c00 2800 mulsl %d0,%d2
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
4c79a: 2d42 ff58 movel %d2,%fp@(-168)
rtems_rfs_rup_quotient (fs->group_inodes,
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
4c79e: b682 cmpl %d2,%d3
4c7a0: 6404 bccs 4c7a6 <rtems_rfs_format+0x22a> <== ALWAYS TAKEN
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
4c7a2: 2d43 ff58 movel %d3,%fp@(-168) <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
4c7a6: 202a 0010 movel %a2@(16),%d0
4c7aa: 2d40 ff48 movel %d0,%fp@(-184)
if (!fs->max_name_length)
4c7ae: 6600 087e bnew 4d02e <rtems_rfs_format+0xab2>
{
fs->max_name_length = 512;
4c7b2: 243c 0000 0200 movel #512,%d2
4c7b8: 2d42 ff48 movel %d2,%fp@(-184)
4c7bc: 6000 0870 braw 4d02e <rtems_rfs_format+0xab2>
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
4c7c0: 49ee ff30 lea %fp@(-208),%a4 <== NOT EXECUTED
4c7c4: 47f9 0005 b318 lea 5b318 <printf>,%a3 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4c7ca: 760a moveq #10,%d3 <== NOT EXECUTED
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
4c7cc: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4c7ce: 4eb9 0005 8048 jsr 58048 <rtems_rfs_fs_media_size> <== NOT EXECUTED
4c7d4: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4c7d6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c7d8: 4879 0006 a2dd pea 6a2dd <ramdisk_ops+0xf3> <== NOT EXECUTED
4c7de: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
4c7e0: 206e ff3c moveal %fp@(-196),%a0 <== NOT EXECUTED
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
4c7e4: 2f28 001c movel %a0@(28),%sp@- <== NOT EXECUTED
4c7e8: 4879 0006 a303 pea 6a303 <ramdisk_ops+0x119> <== NOT EXECUTED
4c7ee: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
rtems_rfs_fs_media_block_size (&fs));
4c7f0: 206e ff3c moveal %fp@(-196),%a0 <== NOT EXECUTED
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
4c7f4: 2f28 0024 movel %a0@(36),%sp@- <== NOT EXECUTED
4c7f8: 4879 0006 a32a pea 6a32a <ramdisk_ops+0x140> <== NOT EXECUTED
4c7fe: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
4c800: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4c804: 2e8c movel %a4,%sp@ <== NOT EXECUTED
4c806: 4eb9 0005 8018 jsr 58018 <rtems_rfs_fs_size> <== NOT EXECUTED
4c80c: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4c80e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c810: 4879 0006 a355 pea 6a355 <ramdisk_ops+0x16b> <== NOT EXECUTED
4c816: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
4c818: 2f2e ff34 movel %fp@(-204),%sp@- <== NOT EXECUTED
4c81c: 4879 0006 a375 pea 6a375 <ramdisk_ops+0x18b> <== NOT EXECUTED
4c822: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
4c824: 2f2e ff38 movel %fp@(-200),%sp@- <== NOT EXECUTED
4c828: 4879 0006 a396 pea 6a396 <ramdisk_ops+0x1ac> <== NOT EXECUTED
4c82e: 4e93 jsr %a3@ <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c830: 202c 0008 movel %a4@(8),%d0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
4c834: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c838: e788 lsll #3,%d0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
4c83a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c83c: 4879 0006 a3bb pea 6a3bb <ramdisk_ops+0x1d1> <== NOT EXECUTED
4c842: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
4c844: 4878 0038 pea 38 <DBL_MANT_DIG+0x3> <== NOT EXECUTED
4c848: 4879 0006 a3e3 pea 6a3e3 <ramdisk_ops+0x1f9> <== NOT EXECUTED
4c84e: 4e93 jsr %a3@ <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
rtems_rfs_inode_overhead (&fs) % 10);
4c850: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4c852: 4eba fcd6 jsr %pc@(4c52a <rtems_rfs_inode_overhead>) <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4c856: 2a2e ff50 movel %fp@(-176),%d5 <== NOT EXECUTED
4c85a: 41ee ff58 lea %fp@(-168),%a0 <== NOT EXECUTED
4c85e: 4c43 0801 remsl %d3,%d1,%d0 <== NOT EXECUTED
4c862: 4c43 0800 remsl %d3,%d0,%d0 <== NOT EXECUTED
4c866: 2e81 movel %d1,%sp@ <== NOT EXECUTED
4c868: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c86a: 4c10 5800 mulsl %a0@,%d5 <== NOT EXECUTED
4c86e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4c870: 4879 0006 a408 pea 6a408 <ramdisk_ops+0x21e> <== NOT EXECUTED
4c876: 4e93 jsr %a3@ <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
rtems_rfs_inode_overhead (&fs) % 10);
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
4c878: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4c87c: 2eae ff50 movel %fp@(-176),%sp@ <== NOT EXECUTED
4c880: 4879 0006 a433 pea 6a433 <ramdisk_ops+0x249> <== NOT EXECUTED
4c886: 4e93 jsr %a3@ <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
4c888: 2f2e ff54 movel %fp@(-172),%sp@- <== NOT EXECUTED
4c88c: 4879 0006 a453 pea 6a453 <ramdisk_ops+0x269> <== NOT EXECUTED
4c892: 4e93 jsr %a3@ <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
4c894: 2f2e ff58 movel %fp@(-168),%sp@- <== NOT EXECUTED
4c898: 4879 0006 a47a pea 6a47a <ramdisk_ops+0x290> <== NOT EXECUTED
4c89e: 4e93 jsr %a3@ <== NOT EXECUTED
4c8a0: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
4c8a4: 2f2e ff38 movel %fp@(-200),%sp@-
4c8a8: 280e movel %fp,%d4
4c8aa: 0684 ffff ff30 addil #-208,%d4
4c8b0: 2f04 movel %d4,%sp@-
4c8b2: 4eb9 0005 6152 jsr 56152 <rtems_rfs_buffer_setblksize>
if (rc > 0)
4c8b8: 508f addql #8,%sp
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
4c8ba: 2400 movel %d0,%d2
if (rc > 0)
4c8bc: 6f16 bles 4c8d4 <rtems_rfs_format+0x358> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
4c8be: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c8c0: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4c8c6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c8c8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4c8ca: 4879 0006 a4a1 pea 6a4a1 <ramdisk_ops+0x2b7> <== NOT EXECUTED
4c8d0: 6000 0742 braw 4d014 <rtems_rfs_format+0xa98> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
4c8d4: 42a7 clrl %sp@-
4c8d6: 2a0e movel %fp,%d5
4c8d8: 0685 ffff ffee addil #-18,%d5
4c8de: 42a7 clrl %sp@-
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4c8e0: 4200 clrb %d0
4c8e2: 2f05 movel %d5,%sp@-
4c8e4: 1d40 ffee moveb %d0,%fp@(-18)
4c8e8: 2f04 movel %d4,%sp@-
handle->bnum = 0;
4c8ea: 42ae fff0 clrl %fp@(-16)
handle->buffer = NULL;
4c8ee: 42ae fff4 clrl %fp@(-12)
4c8f2: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
if (rc > 0)
4c8f8: 4fef 0010 lea %sp@(16),%sp
printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
4c8fc: 2400 movel %d0,%d2
if (rc > 0)
4c8fe: 6f1e bles 4c91e <rtems_rfs_format+0x3a2> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4c900: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4c902: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4c904: 4eba fbd6 jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
4c908: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4c90a: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4c910: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c912: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4c914: 4879 0006 a4d7 pea 6a4d7 <ramdisk_ops+0x2ed> <== NOT EXECUTED
4c91a: 6000 013e braw 4ca5a <rtems_rfs_format+0x4de> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
4c91e: 206e fff4 moveal %fp@(-12),%a0
4c922: 2668 001e moveal %a0@(30),%a3
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
4c926: 2f2e ff38 movel %fp@(-200),%sp@-
4c92a: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
4c92e: 7420 moveq #32,%d2
sb = rtems_rfs_buffer_data (&handle);
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
4c930: 2f0b movel %a3,%sp@-
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
4c932: 7601 moveq #1,%d3
sb = rtems_rfs_buffer_data (&handle);
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
4c934: 4eb9 0005 b28c jsr 5b28c <memset>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
4c93a: 4200 clrb %d0
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
4c93c: 7209 moveq #9,%d1
4c93e: 1742 0002 moveb %d2,%a3@(2)
4c942: 1743 0003 moveb %d3,%a3@(3)
4c946: 1741 0001 moveb %d1,%a3@(1)
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4c94a: 7418 moveq #24,%d2
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
4c94c: 16bc 0028 moveb #40,%a3@
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
4c950: 1740 0004 moveb %d0,%a3@(4)
4c954: 1740 0005 moveb %d0,%a3@(5)
4c958: 1740 0006 moveb %d0,%a3@(6)
4c95c: 1740 0007 moveb %d0,%a3@(7)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
4c960: 4203 clrb %d3
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4c962: 202e ff34 movel %fp@(-204),%d0
4c966: 2200 movel %d0,%d1
4c968: e4a9 lsrl %d2,%d1
4c96a: 1741 000c moveb %d1,%a3@(12)
4c96e: 2200 movel %d0,%d1
4c970: 4241 clrw %d1
4c972: 4841 swap %d1
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4c974: 176e ff38 0008 moveb %fp@(-200),%a3@(8)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4c97a: 1740 000f moveb %d0,%a3@(15)
4c97e: 1741 000d moveb %d1,%a3@(13)
4c982: 2200 movel %d0,%d1
4c984: e089 lsrl #8,%d1
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4c986: 176e ff39 0009 moveb %fp@(-199),%a3@(9)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4c98c: 1741 000e moveb %d1,%a3@(14)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
4c990: 7038 moveq #56,%d0
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4c992: 176e ff3a 000a moveb %fp@(-198),%a3@(10)
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
4c998: 7201 moveq #1,%d1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
4c99a: 176e ff3b 000b moveb %fp@(-197),%a3@(11)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
4c9a0: 176e ff44 0010 moveb %fp@(-188),%a3@(16)
4c9a6: 176e ff45 0011 moveb %fp@(-187),%a3@(17)
4c9ac: 176e ff46 0012 moveb %fp@(-186),%a3@(18)
4c9b2: 176e ff47 0013 moveb %fp@(-185),%a3@(19)
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
4c9b8: 176e ff48 0014 moveb %fp@(-184),%a3@(20)
4c9be: 176e ff49 0015 moveb %fp@(-183),%a3@(21)
4c9c4: 176e ff4a 0016 moveb %fp@(-182),%a3@(22)
4c9ca: 176e ff4b 0017 moveb %fp@(-181),%a3@(23)
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
4c9d0: 176e ff50 0018 moveb %fp@(-176),%a3@(24)
4c9d6: 176e ff51 0019 moveb %fp@(-175),%a3@(25)
4c9dc: 176e ff52 001a moveb %fp@(-174),%a3@(26)
4c9e2: 176e ff53 001b moveb %fp@(-173),%a3@(27)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
4c9e8: 176e ff54 001c moveb %fp@(-172),%a3@(28)
4c9ee: 176e ff55 001d moveb %fp@(-171),%a3@(29)
4c9f4: 176e ff56 001e moveb %fp@(-170),%a3@(30)
4c9fa: 176e ff57 001f moveb %fp@(-169),%a3@(31)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
4ca00: 176e ff58 0020 moveb %fp@(-168),%a3@(32)
4ca06: 176e ff59 0021 moveb %fp@(-167),%a3@(33)
4ca0c: 176e ff5a 0022 moveb %fp@(-166),%a3@(34)
4ca12: 176e ff5b 0023 moveb %fp@(-165),%a3@(35)
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
4ca18: 1740 0027 moveb %d0,%a3@(39)
4ca1c: 1743 0024 moveb %d3,%a3@(36)
4ca20: 1743 0025 moveb %d3,%a3@(37)
4ca24: 1743 0026 moveb %d3,%a3@(38)
rtems_rfs_buffer_mark_dirty (&handle);
4ca28: 1d41 ffee moveb %d1,%fp@(-18)
rc = rtems_rfs_buffer_handle_release (fs, &handle);
4ca2c: 2f05 movel %d5,%sp@-
4ca2e: 2f04 movel %d4,%sp@-
4ca30: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
if (rc > 0)
4ca36: 4fef 0014 lea %sp@(20),%sp
4ca3a: 41fa faa0 lea %pc@(4c4dc <rtems_rfs_buffer_handle_close>),%a0
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
4ca3e: 2400 movel %d0,%d2
if (rc > 0)
4ca40: 6f24 bles 4ca66 <rtems_rfs_format+0x4ea> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4ca42: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4ca44: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4ca46: 4e90 jsr %a0@ <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
4ca48: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ca4a: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4ca50: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ca52: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ca54: 4879 0006 a50c pea 6a50c <ramdisk_ops+0x322> <== NOT EXECUTED
4ca5a: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4ca60: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4ca64: 602a bras 4ca90 <rtems_rfs_format+0x514> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
4ca66: 2f05 movel %d5,%sp@-
4ca68: 2f04 movel %d4,%sp@-
4ca6a: 4e90 jsr %a0@
if (rc > 0)
4ca6c: 508f addql #8,%sp
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
4ca6e: 2400 movel %d0,%d2
if (rc > 0)
4ca70: 6f00 033a blew 4cdac <rtems_rfs_format+0x830>
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
4ca74: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ca76: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4ca7c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ca7e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ca80: 4879 0006 a548 pea 6a548 <ramdisk_ops+0x35e> <== NOT EXECUTED
4ca86: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4ca8c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
4ca90: 4879 0006 a589 pea 6a589 <ramdisk_ops+0x39f> <== NOT EXECUTED
4ca96: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
return -1;
4ca9c: 588f addql #4,%sp <== NOT EXECUTED
4ca9e: 6000 057e braw 4d01e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
4caa2: 206e ff2c moveal %fp@(-212),%a0
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
4caa6: 2e02 movel %d2,%d7
4caa8: 2c2e ff54 movel %fp@(-172),%d6
4caac: 4c06 7800 mulsl %d6,%d7
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
4cab0: 1028 0015 moveb %a0@(21),%d0
4cab4: 1228 0014 moveb %a0@(20),%d1
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
4cab8: 2647 moveal %d7,%a3
4caba: 528b addql #1,%a3
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
4cabc: 3440 moveaw %d0,%a2
4cabe: 1d41 ff28 moveb %d1,%fp@(-216)
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
4cac2: 202e ff34 movel %fp@(-204),%d0
4cac6: b08b cmpl %a3,%d0
4cac8: 6414 bccs 4cade <rtems_rfs_format+0x562> <== ALWAYS TAKEN
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
4caca: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cacc: 4879 0006 a5b4 pea 6a5b4 <ramdisk_ops+0x3ca> <== NOT EXECUTED
4cad2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4cad8: 508f addql #8,%sp <== NOT EXECUTED
4cada: 6000 0542 braw 4d01e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
/*
* Be nice to strange sizes of disks. These are embedded systems after all
* and nice numbers do not always work out. Let the last block pick up the
* remainder of the blocks.
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
4cade: 220b movel %a3,%d1
4cae0: d286 addl %d6,%d1
4cae2: b081 cmpl %d1,%d0
4cae4: 6404 bccs 4caea <rtems_rfs_format+0x56e> <== NEVER TAKEN
group_size = rtems_rfs_fs_blocks (fs) - group_base;
4cae6: 2c00 movel %d0,%d6
4cae8: 9c8b subl %a3,%d6
if (verbose)
4caea: 300a movew %a2,%d0
4caec: 4a00 tstb %d0
4caee: 6712 beqs 4cb02 <rtems_rfs_format+0x586> <== ALWAYS TAKEN
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
4caf0: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4caf2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4caf4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4caf6: 4879 0006 a5ed pea 6a5ed <ramdisk_ops+0x403> <== NOT EXECUTED
4cafc: 4e94 jsr %a4@ <== NOT EXECUTED
4cafe: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
4cb02: 42ae fff0 clrl %fp@(-16)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4cb06: 4201 clrb %d1
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
4cb08: 300a movew %a2,%d0
handle->bnum = 0;
handle->buffer = NULL;
4cb0a: 42ae fff4 clrl %fp@(-12)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4cb0e: 1d41 ffee moveb %d1,%fp@(-18)
4cb12: 4a00 tstb %d0
4cb14: 670a beqs 4cb20 <rtems_rfs_format+0x5a4> <== ALWAYS TAKEN
printf (", blocks");
4cb16: 4879 0006 a623 pea 6a623 <ramdisk_ops+0x439> <== NOT EXECUTED
4cb1c: 4e94 jsr %a4@ <== NOT EXECUTED
4cb1e: 588f addql #4,%sp <== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4cb20: 2f0b movel %a3,%sp@-
4cb22: 2f06 movel %d6,%sp@-
4cb24: 2f05 movel %d5,%sp@-
4cb26: 2f04 movel %d4,%sp@-
4cb28: 2f03 movel %d3,%sp@-
4cb2a: 4e95 jsr %a5@
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
4cb2c: 4fef 0014 lea %sp@(20),%sp
4cb30: 4a80 tstl %d0
4cb32: 6f22 bles 4cb56 <rtems_rfs_format+0x5da> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4cb34: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cb36: 2640 moveal %d0,%a3 <== NOT EXECUTED
4cb38: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cb3a: 4eba f9a0 jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
4cb3e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cb40: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cb46: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cb48: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cb4a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cb4c: 4879 0006 a62c pea 6a62c <ramdisk_ops+0x442> <== NOT EXECUTED
4cb52: 6000 00c8 braw 4cc1c <rtems_rfs_format+0x6a0> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
4cb56: 2f2e ff38 movel %fp@(-200),%sp@-
4cb5a: 206e fff4 moveal %fp@(-12),%a0
4cb5e: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
4cb62: 2f28 001e movel %a0@(30),%sp@-
4cb66: 4eb9 0005 b28c jsr 5b28c <memset>
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
4cb6c: 2f03 movel %d3,%sp@-
4cb6e: 4eb9 0005 4a2c jsr 54a2c <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
4cb74: 4fef 0010 lea %sp@(16),%sp
4cb78: 4a80 tstl %d0
4cb7a: 6f2a bles 4cba6 <rtems_rfs_format+0x62a> <== ALWAYS TAKEN
{
rtems_rfs_bitmap_close (&bitmap);
4cb7c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4cb7e: 2640 moveal %d0,%a3 <== NOT EXECUTED
4cb80: 4eb9 0005 4c2e jsr 54c2e <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
4cb86: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cb88: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cb8a: 4eba f950 jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
4cb8e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cb90: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cb96: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cb98: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cb9a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cb9c: 4879 0006 a672 pea 6a672 <ramdisk_ops+0x488> <== NOT EXECUTED
4cba2: 6000 0122 braw 4ccc6 <rtems_rfs_format+0x74a> <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
4cba6: 42a7 clrl %sp@-
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
4cba8: 97cb subal %a3,%a3
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
4cbaa: 2f03 movel %d3,%sp@-
4cbac: 4eb9 0005 4890 jsr 54890 <rtems_rfs_bitmap_map_set>
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
4cbb2: 4878 0001 pea 1 <ADD>
4cbb6: 2f03 movel %d3,%sp@-
4cbb8: 4eb9 0005 4890 jsr 54890 <rtems_rfs_bitmap_map_set>
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
4cbbe: 2f2e ff5c movel %fp@(-164),%sp@-
4cbc2: 2f2e ff58 movel %fp@(-168),%sp@-
4cbc6: 4eb9 0004 c506 jsr 4c506 <rtems_rfs_rup_quotient>
4cbcc: 4fef 0018 lea %sp@(24),%sp
4cbd0: 2d40 ff24 movel %d0,%fp@(-220)
4cbd4: 6010 bras 4cbe6 <rtems_rfs_format+0x66a>
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
4cbd6: 486b 0002 pea %a3@(2)
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
4cbda: 528b addql #1,%a3
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
4cbdc: 2f03 movel %d3,%sp@-
4cbde: 4eb9 0005 4890 jsr 54890 <rtems_rfs_bitmap_map_set>
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
4cbe4: 508f addql #8,%sp
4cbe6: b7ee ff24 cmpal %fp@(-220),%a3
4cbea: 6dea blts 4cbd6 <rtems_rfs_format+0x65a>
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
4cbec: 2f03 movel %d3,%sp@-
4cbee: 4eb9 0005 4c2e jsr 54c2e <rtems_rfs_bitmap_close>
if (rc > 0)
4cbf4: 588f addql #4,%sp
4cbf6: 4a80 tstl %d0
4cbf8: 6f30 bles 4cc2a <rtems_rfs_format+0x6ae> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4cbfa: 486e ffee pea %fp@(-18) <== NOT EXECUTED
4cbfe: 2640 moveal %d0,%a3 <== NOT EXECUTED
4cc00: 486e ff30 pea %fp@(-208) <== NOT EXECUTED
4cc04: 4eba f8d6 jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
4cc08: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cc0a: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cc10: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cc12: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cc14: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cc16: 4879 0006 a6bd pea 6a6bd <ramdisk_ops+0x4d3> <== NOT EXECUTED
4cc1c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4cc22: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4cc26: 6000 03f6 braw 4d01e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
4cc2a: 7201 moveq #1,%d1
if (verbose)
4cc2c: 300a movew %a2,%d0
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
4cc2e: 1d41 ffee moveb %d1,%fp@(-18)
if (verbose)
4cc32: 4a00 tstb %d0
4cc34: 670a beqs 4cc40 <rtems_rfs_format+0x6c4> <== ALWAYS TAKEN
printf (", inodes");
4cc36: 4879 0006 a704 pea 6a704 <ramdisk_ops+0x51a> <== NOT EXECUTED
4cc3c: 4e94 jsr %a4@ <== NOT EXECUTED
4cc3e: 588f addql #4,%sp <== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4cc40: 2047 moveal %d7,%a0
4cc42: 4868 0002 pea %a0@(2)
4cc46: 2f06 movel %d6,%sp@-
4cc48: 2f05 movel %d5,%sp@-
4cc4a: 2f04 movel %d4,%sp@-
4cc4c: 2f03 movel %d3,%sp@-
4cc4e: 4e95 jsr %a5@
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
4cc50: 4fef 0014 lea %sp@(20),%sp
4cc54: 4a80 tstl %d0
4cc56: 6f20 bles 4cc78 <rtems_rfs_format+0x6fc> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4cc58: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cc5a: 2c00 movel %d0,%d6 <== NOT EXECUTED
4cc5c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cc5e: 4eba f87c jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
4cc62: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cc64: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cc6a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cc6c: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cc6e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cc70: 4879 0006 a70d pea 6a70d <ramdisk_ops+0x523> <== NOT EXECUTED
4cc76: 60a4 bras 4cc1c <rtems_rfs_format+0x6a0> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
4cc78: 2f2e ff38 movel %fp@(-200),%sp@-
4cc7c: 45f9 0005 b28c lea 5b28c <memset>,%a2
4cc82: 206e fff4 moveal %fp@(-12),%a0
4cc86: 42a7 clrl %sp@-
4cc88: 2f28 001e movel %a0@(30),%sp@-
4cc8c: 4e92 jsr %a2@
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
4cc8e: 2f03 movel %d3,%sp@-
4cc90: 4eb9 0005 4a2c jsr 54a2c <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
4cc96: 4fef 0010 lea %sp@(16),%sp
4cc9a: 41f9 0005 4c2e lea 54c2e <rtems_rfs_bitmap_close>,%a0
4cca0: 4a80 tstl %d0
4cca2: 6f30 bles 4ccd4 <rtems_rfs_format+0x758> <== ALWAYS TAKEN
{
rtems_rfs_bitmap_close (&bitmap);
4cca4: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4cca6: 2c00 movel %d0,%d6 <== NOT EXECUTED
4cca8: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
4ccaa: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4ccac: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4ccae: 4eba f82c jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
4ccb2: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4ccb4: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4ccba: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ccbc: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4ccbe: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ccc0: 4879 0006 a753 pea 6a753 <ramdisk_ops+0x569> <== NOT EXECUTED
4ccc6: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4cccc: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
4ccd0: 6000 034c braw 4d01e <rtems_rfs_format+0xaa2> <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
4ccd4: 2f03 movel %d3,%sp@-
4ccd6: 4e90 jsr %a0@
if (rc > 0)
4ccd8: 588f addql #4,%sp
4ccda: 4a80 tstl %d0
4ccdc: 6f22 bles 4cd00 <rtems_rfs_format+0x784> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
4ccde: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cce0: 2c00 movel %d0,%d6 <== NOT EXECUTED
4cce2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cce4: 4eba f7f6 jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
4cce8: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4ccea: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4ccf0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ccf2: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4ccf4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ccf6: 4879 0006 a79e pea 6a79e <ramdisk_ops+0x5b4> <== NOT EXECUTED
4ccfc: 6000 ff1e braw 4cc1c <rtems_rfs_format+0x6a0> <== NOT EXECUTED
" bitmap failed: %d: %s\n", group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
4cd00: 7001 moveq #1,%d0
4cd02: 1d40 ffee moveb %d0,%fp@(-18)
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
4cd06: 4a2e ff28 tstb %fp@(-216)
4cd0a: 6664 bnes 4cd70 <rtems_rfs_format+0x7f4> <== NEVER TAKEN
4cd0c: 6076 bras 4cd84 <rtems_rfs_format+0x808>
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
4cd0e: 2e2e ff28 movel %fp@(-216),%d7 <== NOT EXECUTED
4cd12: de86 addl %d6,%d7 <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
4cd14: 42a7 clrl %sp@- <== NOT EXECUTED
4cd16: 2f07 movel %d7,%sp@- <== NOT EXECUTED
4cd18: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cd1a: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cd1c: 4e93 jsr %a3@ <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
4cd1e: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4cd22: 4a80 tstl %d0 <== NOT EXECUTED
4cd24: 6f2a bles 4cd50 <rtems_rfs_format+0x7d4> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
4cd26: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4cd28: 2640 moveal %d0,%a3 <== NOT EXECUTED
4cd2a: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4cd2c: 4eba f7ae jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)<== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
4cd30: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cd32: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cd38: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cd3a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4cd3c: 2f07 movel %d7,%sp@- <== NOT EXECUTED
4cd3e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cd40: 4879 0006 a7e5 pea 6a7e5 <ramdisk_ops+0x5fb> <== NOT EXECUTED
4cd46: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4cd4c: 6000 ff7e braw 4cccc <rtems_rfs_format+0x750> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
4cd50: 2f2e ff38 movel %fp@(-200),%sp@- <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
4cd54: 5286 addql #1,%d6 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
4cd56: 4878 00ff pea ff <DBL_MANT_DIG+0xca> <== NOT EXECUTED
4cd5a: 206e fff4 moveal %fp@(-12),%a0 <== NOT EXECUTED
4cd5e: 2f28 001e movel %a0@(30),%sp@- <== NOT EXECUTED
4cd62: 4e92 jsr %a2@ <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
4cd64: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
rtems_rfs_buffer_mark_dirty (&handle);
4cd68: 7201 moveq #1,%d1 <== NOT EXECUTED
4cd6a: 1d41 ffee moveb %d1,%fp@(-18) <== NOT EXECUTED
4cd6e: 600e bras 4cd7e <rtems_rfs_format+0x802> <== NOT EXECUTED
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
4cd70: 5687 addql #3,%d7 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
4cd72: 4286 clrl %d6 <== NOT EXECUTED
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
4cd74: 47f9 0005 5d00 lea 55d00 <rtems_rfs_buffer_handle_request>,%a3<== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
4cd7a: 2d47 ff28 movel %d7,%fp@(-216) <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
4cd7e: bcae ff24 cmpl %fp@(-220),%d6 <== NOT EXECUTED
4cd82: 6d8a blts 4cd0e <rtems_rfs_format+0x792> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
4cd84: 2f05 movel %d5,%sp@-
4cd86: 2f04 movel %d4,%sp@-
4cd88: 4eba f752 jsr %pc@(4c4dc <rtems_rfs_buffer_handle_close>)
if (rc > 0)
4cd8c: 508f addql #8,%sp
4cd8e: 4a80 tstl %d0
4cd90: 6f00 02a8 blew 4d03a <rtems_rfs_format+0xabe>
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
4cd94: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cd96: 2c00 movel %d0,%d6 <== NOT EXECUTED
4cd98: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cd9e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cda0: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4cda2: 4879 0006 a82b pea 6a82b <ramdisk_ops+0x641> <== NOT EXECUTED
4cda8: 6000 026a braw 4d014 <rtems_rfs_format+0xa98> <== NOT EXECUTED
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4cdac: 260e movel %fp,%d3
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
4cdae: 4282 clrl %d2
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
4cdb0: 49f9 0005 b318 lea 5b318 <printf>,%a4
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4cdb6: 0683 ffff ffd6 addil #-42,%d3
4cdbc: 4bf9 0005 4bd6 lea 54bd6 <rtems_rfs_bitmap_open>,%a5
4cdc2: 2d4a ff2c movel %a2,%fp@(-212)
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
4cdc6: b4ae ff50 cmpl %fp@(-176),%d2
4cdca: 6d00 fcd6 bltw 4caa2 <rtems_rfs_format+0x526>
4cdce: 246e ff2c moveal %fp@(-212),%a2
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
4cdd2: 4a2a 0015 tstb %a2@(21)
4cdd6: 670c beqs 4cde4 <rtems_rfs_format+0x868> <== ALWAYS TAKEN
printf ("\n");
4cdd8: 4878 000a pea a <LASTO> <== NOT EXECUTED
4cddc: 4eb9 0005 b358 jsr 5b358 <putchar> <== NOT EXECUTED
4cde2: 588f addql #4,%sp <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
4cde4: 486e ff30 pea %fp@(-208)
4cde8: 4eb9 0005 622e jsr 5622e <rtems_rfs_buffer_close>
if (rc > 0)
4cdee: 588f addql #4,%sp
return -1;
if (config->verbose)
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
4cdf0: 2400 movel %d0,%d2
if (rc > 0)
4cdf2: 6f16 bles 4ce0a <rtems_rfs_format+0x88e> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
4cdf4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cdf6: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cdfc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cdfe: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ce00: 4879 0006 a868 pea 6a868 <ramdisk_ops+0x67e> <== NOT EXECUTED
4ce06: 6000 020c braw 4d014 <rtems_rfs_format+0xa98> <== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
4ce0a: 486e fff8 pea %fp@(-8)
4ce0e: 4878 0004 pea 4 <CONTEXT_ARG>
4ce12: 42a7 clrl %sp@-
4ce14: 2f2e 0008 movel %fp@(8),%sp@-
4ce18: 4eb9 0005 807c jsr 5807c <rtems_rfs_fs_open>
if (rc < 0)
4ce1e: 4fef 0010 lea %sp@(16),%sp
4ce22: 4a80 tstl %d0
4ce24: 6c26 bges 4ce4c <rtems_rfs_format+0x8d0> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
4ce26: 45f9 0005 a88c lea 5a88c <__errno>,%a2 <== NOT EXECUTED
4ce2c: 4e92 jsr %a2@ <== NOT EXECUTED
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
4ce2e: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ce30: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4ce32: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4ce38: 2400 movel %d0,%d2 <== NOT EXECUTED
errno, strerror (errno));
4ce3a: 4e92 jsr %a2@ <== NOT EXECUTED
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
4ce3c: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ce3e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ce40: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4ce42: 4879 0006 a898 pea 6a898 <ramdisk_ops+0x6ae> <== NOT EXECUTED
4ce48: 6000 01a8 braw 4cff2 <rtems_rfs_format+0xa76> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
4ce4c: 486e fffc pea %fp@(-4)
4ce50: 4878 0001 pea 1 <ADD>
4ce54: 2f2e fff8 movel %fp@(-8),%sp@-
4ce58: 4eb9 0004 d60c jsr 4d60c <rtems_rfs_inode_alloc>
if (rc > 0)
4ce5e: 4fef 000c lea %sp@(12),%sp
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
4ce62: 2400 movel %d0,%d2
if (rc > 0)
4ce64: 6f2a bles 4ce90 <rtems_rfs_format+0x914> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
4ce66: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ce68: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4ce6e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ce70: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ce72: 4879 0006 a8cc pea 6a8cc <ramdisk_ops+0x6e2> <== NOT EXECUTED
4ce78: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
4ce7e: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4ce82: 4eb9 0005 882a jsr 5882a <rtems_rfs_fs_close> <== NOT EXECUTED
4ce88: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4ce8c: 6000 0174 braw 4d002 <rtems_rfs_format+0xa86> <== NOT EXECUTED
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
4ce90: 202e fffc movel %fp@(-4),%d0
4ce94: 7201 moveq #1,%d1
4ce96: b280 cmpl %d0,%d1
4ce98: 6720 beqs 4ceba <rtems_rfs_format+0x93e> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
4ce9a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ce9c: 4879 0006 a900 pea 6a900 <ramdisk_ops+0x716> <== NOT EXECUTED
4cea2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
4cea8: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4ceac: 4eb9 0005 882a jsr 5882a <rtems_rfs_fs_close> <== NOT EXECUTED
4ceb2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4ceb6: 6000 016a braw 4d022 <rtems_rfs_format+0xaa6> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ceba: 4878 0001 pea 1 <ADD>
4cebe: 260e movel %fp,%d3
4cec0: 0683 ffff ffb0 addil #-80,%d3
4cec6: 2f03 movel %d3,%sp@-
4cec8: 4878 0001 pea 1 <ADD>
4cecc: 2f2e fff8 movel %fp@(-8),%sp@-
4ced0: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
4ced6: 4fef 0010 lea %sp@(16),%sp
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ceda: 2400 movel %d0,%d2
if (rc > 0)
4cedc: 6f3c bles 4cf1a <rtems_rfs_format+0x99e> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
4cede: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cee0: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cee6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cee8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4ceea: 4879 0006 a936 pea 6a936 <ramdisk_ops+0x74c> <== NOT EXECUTED
4cef0: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
4cef6: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
4cefa: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4cefe: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4cf02: 4eb9 0004 d44a jsr 4d44a <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
4cf08: 2f2e fff8 movel %fp@(-8),%sp@- <== NOT EXECUTED
4cf0c: 4eb9 0005 882a jsr 5882a <rtems_rfs_fs_close> <== NOT EXECUTED
4cf12: 4fef 0020 lea %sp@(32),%sp <== NOT EXECUTED
4cf16: 6000 00ea braw 4d002 <rtems_rfs_format+0xa86> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
4cf1a: 42a7 clrl %sp@-
4cf1c: 42a7 clrl %sp@-
4cf1e: 4878 41c9 pea 41c9 <D_MAX_EXP+0x39ca>
4cf22: 42a7 clrl %sp@-
4cf24: 2f03 movel %d3,%sp@-
4cf26: 4eb9 0004 da76 jsr 4da76 <rtems_rfs_inode_initialise>
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
4cf2c: 4fef 0014 lea %sp@(20),%sp
rtems_rfs_group_bitmap_free (fs, true, ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
4cf30: 2400 movel %d0,%d2
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
4cf32: 6f1c bles 4cf50 <rtems_rfs_format+0x9d4> <== ALWAYS TAKEN
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
4cf34: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cf36: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cf3c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cf3e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cf40: 4879 0006 a964 pea 6a964 <ramdisk_ops+0x77a> <== NOT EXECUTED
4cf46: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4cf4c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
4cf50: 2f2e fffc movel %fp@(-4),%sp@-
4cf54: 4878 0001 pea 1 <ADD>
4cf58: 4879 0006 8e0a pea 68e0a <_rodata_start+0x1aa>
4cf5e: 486e ffb0 pea %fp@(-80)
4cf62: 2f2e fff8 movel %fp@(-8),%sp@-
4cf66: 4eb9 0005 6758 jsr 56758 <rtems_rfs_dir_add_entry>
if (rc > 0)
4cf6c: 4fef 0014 lea %sp@(20),%sp
0, 0);
if (rc > 0)
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
4cf70: 2400 movel %d0,%d2
if (rc > 0)
4cf72: 6f1c bles 4cf90 <rtems_rfs_format+0xa14> <== ALWAYS TAKEN
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
4cf74: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cf76: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cf7c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cf7e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cf80: 4879 0006 a998 pea 6a998 <ramdisk_ops+0x7ae> <== NOT EXECUTED
4cf86: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4cf8c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
4cf90: 486e ffb0 pea %fp@(-80)
4cf94: 2f2e fff8 movel %fp@(-8),%sp@-
4cf98: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
if (rc > 0)
4cf9e: 508f addql #8,%sp
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
if (rc > 0)
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
4cfa0: 2400 movel %d0,%d2
if (rc > 0)
4cfa2: 6f1c bles 4cfc0 <rtems_rfs_format+0xa44> <== ALWAYS TAKEN
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
4cfa4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cfa6: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cfac: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4cfae: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cfb0: 4879 0006 a9c9 pea 6a9c9 <ramdisk_ops+0x7df> <== NOT EXECUTED
4cfb6: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4cfbc: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
4cfc0: 2f2e fff8 movel %fp@(-8),%sp@-
4cfc4: 4eb9 0005 882a jsr 5882a <rtems_rfs_fs_close>
if (rc < 0)
4cfca: 588f addql #4,%sp
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
4cfcc: 2400 movel %d0,%d2
if (rc < 0)
4cfce: 6c2e bges 4cffe <rtems_rfs_format+0xa82> <== ALWAYS TAKEN
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
4cfd0: 45f9 0005 a88c lea 5a88c <__errno>,%a2 <== NOT EXECUTED
4cfd6: 4e92 jsr %a2@ <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
4cfd8: 2040 moveal %d0,%a0 <== NOT EXECUTED
4cfda: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4cfdc: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4cfe2: 2400 movel %d0,%d2 <== NOT EXECUTED
errno, strerror (errno));
4cfe4: 4e92 jsr %a2@ <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
4cfe6: 2040 moveal %d0,%a0 <== NOT EXECUTED
4cfe8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4cfea: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4cfec: 4879 0006 a9f8 pea 6a9f8 <ramdisk_ops+0x80e> <== NOT EXECUTED
4cff2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4cff8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4cffc: 6024 bras 4d022 <rtems_rfs_format+0xaa6> <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
4cffe: 4a80 tstl %d0
4d000: 6f20 bles 4d022 <rtems_rfs_format+0xaa6> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
4d002: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d004: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4d00a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d00c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d00e: 4879 0006 aa2d pea 6aa2d <ramdisk_ops+0x843> <== NOT EXECUTED
4d014: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
4d01a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d01e: 70ff moveq #-1,%d0 <== NOT EXECUTED
4d020: 6002 bras 4d024 <rtems_rfs_format+0xaa8> <== NOT EXECUTED
}
return 0;
4d022: 4280 clrl %d0
}
4d024: 4cee 3cfc fefc moveml %fp@(-260),%d2-%d7/%a2-%a5
4d02a: 4e5e unlk %fp
4d02c: 4e75 rts
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
4d02e: 4a2a 0015 tstb %a2@(21)
4d032: 6700 f870 beqw 4c8a4 <rtems_rfs_format+0x328>
4d036: 6000 f788 braw 4c7c0 <rtems_rfs_format+0x244> <== NOT EXECUTED
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
4d03a: 5282 addql #1,%d2
4d03c: 6000 fd88 braw 4cdc6 <rtems_rfs_format+0x84a>
0005882a <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
5882a: 4e56 fff0 linkw %fp,#-16
5882e: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
58832: 4878 0002 pea 2 <DOUBLE_FLOAT>
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
58836: 246e 0008 moveal %fp@(8),%a2
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
5883a: 42a7 clrl %sp@-
5883c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
58842: 508f addql #8,%sp
58844: 4a00 tstb %d0
58846: 670e beqs 58856 <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
printf ("rtems-rfs: close\n");
58848: 4879 0006 c4ef pea 6c4ef <CSWTCH.1+0x1249> <== NOT EXECUTED
5884e: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
58854: 588f addql #4,%sp <== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
58856: 4283 clrl %d3
58858: 4282 clrl %d2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
rtems_rfs_group_close (fs, &fs->groups[group]);
5885a: 47f9 0004 d22a lea 4d22a <rtems_rfs_group_close>,%a3
58860: 6016 bras 58878 <rtems_rfs_fs_close+0x4e>
58862: 202a 001c movel %a2@(28),%d0
58866: d083 addl %d3,%d0
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
58868: 5282 addql #1,%d2
5886a: 0683 0000 004c addil #76,%d3
rtems_rfs_group_close (fs, &fs->groups[group]);
58870: 2f00 movel %d0,%sp@-
58872: 2f0a movel %a2,%sp@-
58874: 4e93 jsr %a3@
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
58876: 508f addql #8,%sp
58878: b4aa 0020 cmpl %a2@(32),%d2
5887c: 6de4 blts 58862 <rtems_rfs_fs_close+0x38>
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
5887e: 2f0a movel %a2,%sp@-
58880: 4eb9 0005 622e jsr 5622e <rtems_rfs_buffer_close>
free (fs);
58886: 2f0a movel %a2,%sp@-
58888: 4eb9 0004 54d0 jsr 454d0 <free>
return 0;
}
5888e: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
58894: 4280 clrl %d0
58896: 4e5e unlk %fp
...
0005807c <rtems_rfs_fs_open>:
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
5807c: 4e56 ff98 linkw %fp,#-104
58080: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58084: 4878 0001 pea 1 <ADD>
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
58088: 242e 0008 movel %fp@(8),%d2
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
5808c: 42a7 clrl %sp@-
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
5808e: 286e 0014 moveal %fp@(20),%a4
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58092: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
58098: 508f addql #8,%sp
5809a: 4a00 tstb %d0
5809c: 6710 beqs 580ae <rtems_rfs_fs_open+0x32> <== ALWAYS TAKEN
printf ("rtems-rfs: open: %s\n", name);
5809e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
580a0: 4879 0006 c1e8 pea 6c1e8 <CSWTCH.1+0xf42> <== NOT EXECUTED
580a6: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
580ac: 508f addql #8,%sp <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
580ae: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
580b2: 4eb9 0004 5af0 jsr 45af0 <malloc>
if (!*fs)
580b8: 588f addql #4,%sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
580ba: 2880 movel %d0,%a4@
if (!*fs)
580bc: 6630 bnes 580ee <rtems_rfs_fs_open+0x72> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
580be: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
580c2: 42a7 clrl %sp@- <== NOT EXECUTED
580c4: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
580ca: 508f addql #8,%sp <== NOT EXECUTED
580cc: 4a00 tstb %d0 <== NOT EXECUTED
580ce: 670e beqs 580de <rtems_rfs_fs_open+0x62> <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
580d0: 4879 0006 c1fd pea 6c1fd <CSWTCH.1+0xf57> <== NOT EXECUTED
580d6: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
580dc: 588f addql #4,%sp <== NOT EXECUTED
errno = ENOMEM;
580de: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
580e4: 720c moveq #12,%d1 <== NOT EXECUTED
580e6: 2040 moveal %d0,%a0 <== NOT EXECUTED
580e8: 2081 movel %d1,%a0@ <== NOT EXECUTED
580ea: 6000 00dc braw 581c8 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
580ee: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
580f2: 42a7 clrl %sp@-
580f4: 2f00 movel %d0,%sp@-
580f6: 4eb9 0005 b28c jsr 5b28c <memset>
(*fs)->user = user;
580fc: 2054 moveal %a4@,%a0
rtems_chain_initialize_empty (&(*fs)->buffers);
rtems_chain_initialize_empty (&(*fs)->release);
rtems_chain_initialize_empty (&(*fs)->release_modified);
rtems_chain_initialize_empty (&(*fs)->file_shares);
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
580fe: 7005 moveq #5,%d0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
58100: 216e 000c 007c movel %fp@(12),%a0@(124)
rtems_chain_initialize_empty (&(*fs)->buffers);
58106: 2054 moveal %a4@,%a0
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
58108: 43e8 0044 lea %a0@(68),%a1
5810c: 2149 0040 movel %a1,%a0@(64)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58110: 43e8 0040 lea %a0@(64),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
58114: 42a8 0044 clrl %a0@(68)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58118: 2149 0048 movel %a1,%a0@(72)
rtems_chain_initialize_empty (&(*fs)->release);
5811c: 2054 moveal %a4@,%a0
Chain_Node *tail = _Chain_Tail( the_chain );
5811e: 43e8 0054 lea %a0@(84),%a1
58122: 2149 0050 movel %a1,%a0@(80)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58126: 43e8 0050 lea %a0@(80),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
5812a: 42a8 0054 clrl %a0@(84)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
5812e: 2149 0058 movel %a1,%a0@(88)
rtems_chain_initialize_empty (&(*fs)->release_modified);
58132: 2054 moveal %a4@,%a0
Chain_Node *tail = _Chain_Tail( the_chain );
58134: 43e8 0064 lea %a0@(100),%a1
58138: 2149 0060 movel %a1,%a0@(96)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
5813c: 43e8 0060 lea %a0@(96),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
58140: 42a8 0064 clrl %a0@(100)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58144: 2149 0068 movel %a1,%a0@(104)
rtems_chain_initialize_empty (&(*fs)->file_shares);
58148: 2054 moveal %a4@,%a0
Chain_Node *tail = _Chain_Tail( the_chain );
5814a: 43e8 0074 lea %a0@(116),%a1
5814e: 2149 0070 movel %a1,%a0@(112)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
58152: 43e8 0070 lea %a0@(112),%a1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
58156: 42a8 0074 clrl %a0@(116)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
5815a: 2149 0078 movel %a1,%a0@(120)
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
5815e: 2054 moveal %a4@,%a0
(*fs)->buffers_count = 0;
(*fs)->release_count = 0;
(*fs)->release_modified_count = 0;
(*fs)->flags = flags;
58160: 20ae 0010 movel %fp@(16),%a0@
rtems_chain_initialize_empty (&(*fs)->buffers);
rtems_chain_initialize_empty (&(*fs)->release);
rtems_chain_initialize_empty (&(*fs)->release_modified);
rtems_chain_initialize_empty (&(*fs)->file_shares);
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
58164: 2140 003c movel %d0,%a0@(60)
(*fs)->buffers_count = 0;
58168: 42a8 004c clrl %a0@(76)
(*fs)->release_count = 0;
5816c: 42a8 005c clrl %a0@(92)
(*fs)->release_modified_count = 0;
58170: 42a8 006c clrl %a0@(108)
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
58174: 2f08 movel %a0,%sp@-
58176: 2f02 movel %d2,%sp@-
58178: 4eb9 0005 5f12 jsr 55f12 <rtems_rfs_buffer_open>
if (rc > 0)
5817e: 4fef 0014 lea %sp@(20),%sp
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
58182: 2400 movel %d0,%d2
if (rc > 0)
58184: 6f48 bles 581ce <rtems_rfs_fs_open+0x152> <== ALWAYS TAKEN
{
free (*fs);
58186: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
58188: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
5818e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58192: 42a7 clrl %sp@- <== NOT EXECUTED
58194: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5819a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5819e: 4a00 tstb %d0 <== NOT EXECUTED
581a0: 671c beqs 581be <rtems_rfs_fs_open+0x142> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
581a2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
581a4: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
581aa: 2f00 movel %d0,%sp@- <== NOT EXECUTED
581ac: 2f02 movel %d2,%sp@- <== NOT EXECUTED
581ae: 4879 0006 c22d pea 6c22d <CSWTCH.1+0xf87> <== NOT EXECUTED
581b4: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
581ba: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
581be: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
581c4: 2040 moveal %d0,%a0 <== NOT EXECUTED
581c6: 2082 movel %d2,%a0@ <== NOT EXECUTED
return -1;
581c8: 70ff moveq #-1,%d0 <== NOT EXECUTED
581ca: 6000 0630 braw 587fc <rtems_rfs_fs_open+0x780> <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
581ce: 2654 moveal %a4@,%a3
printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
581d0: 4878 0001 pea 1 <ADD>
581d4: 2a0e movel %fp,%d5
581d6: 0685 ffff fff6 addil #-10,%d5
581dc: 42a7 clrl %sp@-
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
581de: 4200 clrb %d0
581e0: 2f05 movel %d5,%sp@-
581e2: 1d40 fff6 moveb %d0,%fp@(-10)
581e6: 2f0b movel %a3,%sp@-
handle->bnum = 0;
581e8: 42ae fff8 clrl %fp@(-8)
handle->buffer = NULL;
581ec: 42ae fffc clrl %fp@(-4)
581f0: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
if (rc > 0)
581f6: 4fef 0010 lea %sp@(16),%sp
printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
581fa: 2400 movel %d0,%d2
if (rc > 0)
581fc: 6f2a bles 58228 <rtems_rfs_fs_open+0x1ac> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
581fe: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58202: 42a7 clrl %sp@- <== NOT EXECUTED
58204: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5820a: 508f addql #8,%sp <== NOT EXECUTED
5820c: 4a00 tstb %d0 <== NOT EXECUTED
5820e: 6700 0488 beqw 58698 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
58212: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58214: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
5821a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5821c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5821e: 4879 0006 c25a pea 6c25a <CSWTCH.1+0xfb4> <== NOT EXECUTED
58224: 6000 0446 braw 5866c <rtems_rfs_fs_open+0x5f0> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
58228: 206e fffc moveal %fp@(-4),%a0
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
5822c: 4280 clrl %d0
5822e: 7218 moveq #24,%d1
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
58230: 2468 001e moveal %a0@(30),%a2
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
58234: 1012 moveb %a2@,%d0
58236: e3a8 lsll %d1,%d0
58238: 4281 clrl %d1
5823a: 122a 0001 moveb %a2@(1),%d1
5823e: 4841 swap %d1
58240: 4241 clrw %d1
58242: 8081 orl %d1,%d0
58244: 4281 clrl %d1
58246: 122a 0003 moveb %a2@(3),%d1
5824a: 8081 orl %d1,%d0
5824c: 122a 0002 moveb %a2@(2),%d1
58250: e189 lsll #8,%d1
58252: 8081 orl %d1,%d0
58254: 0c80 2809 2001 cmpil #671686657,%d0
5825a: 671e beqs 5827a <rtems_rfs_fs_open+0x1fe> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
5825c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58260: 42a7 clrl %sp@- <== NOT EXECUTED
58262: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58268: 508f addql #8,%sp <== NOT EXECUTED
5826a: 4a00 tstb %d0 <== NOT EXECUTED
5826c: 6700 0154 beqw 583c2 <rtems_rfs_fs_open+0x346> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
58270: 4879 0006 c28c pea 6c28c <CSWTCH.1+0xfe6> <== NOT EXECUTED
58276: 6000 00ca braw 58342 <rtems_rfs_fs_open+0x2c6> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
5827a: 4280 clrl %d0
5827c: 4281 clrl %d1
5827e: 102a 000c moveb %a2@(12),%d0
58282: 122a 000d moveb %a2@(13),%d1
58286: 7418 moveq #24,%d2
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
58288: 4284 clrl %d4
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
5828a: 2c3c 0006 713c movel #422204,%d6
58290: 2046 moveal %d6,%a0
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
58292: e5a8 lsll %d2,%d0
58294: 4841 swap %d1
58296: 4241 clrw %d1
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
58298: 2a6b 000c moveal %a3@(12),%a5
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
5829c: 8081 orl %d1,%d0
5829e: 4281 clrl %d1
582a0: 122a 000f moveb %a2@(15),%d1
582a4: 8081 orl %d1,%d0
582a6: 122a 000e moveb %a2@(14),%d1
582aa: e189 lsll #8,%d1
582ac: 8081 orl %d1,%d0
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
582ae: 4281 clrl %d1
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
582b0: 2740 0004 movel %d0,%a3@(4)
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
582b4: 182a 0008 moveb %a2@(8),%d4
582b8: 122a 0009 moveb %a2@(9),%d1
582bc: e5ac lsll %d2,%d4
582be: 4841 swap %d1
582c0: 4241 clrw %d1
582c2: 8881 orl %d1,%d4
582c4: 4281 clrl %d1
582c6: 122a 000b moveb %a2@(11),%d1
582ca: 8881 orl %d1,%d4
582cc: 122a 000a moveb %a2@(10),%d1
582d0: e189 lsll #8,%d1
582d2: 8881 orl %d1,%d4
582d4: 2744 0008 movel %d4,%a3@(8)
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
582d8: 2f00 movel %d0,%sp@-
582da: 42a7 clrl %sp@-
582dc: 2f04 movel %d4,%sp@-
582de: 42a7 clrl %sp@-
582e0: 4e90 jsr %a0@
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
582e2: 226d 0024 moveal %a5@(36),%a1
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
582e6: 4fef 0010 lea %sp@(16),%sp
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
582ea: 91c8 subal %a0,%a0
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
582ec: 2a6d 001c moveal %a5@(28),%a5
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
582f0: 2d49 ffcc movel %a1,%fp@(-52)
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
582f4: 93c9 subal %a1,%a1
582f6: 2d4d ffc4 movel %a5,%fp@(-60)
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
582fa: 2f2e ffc4 movel %fp@(-60),%sp@-
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
582fe: 2400 movel %d0,%d2
58300: 2601 movel %d1,%d3
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
58302: 2d49 ffc0 movel %a1,%fp@(-64)
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
58306: 2f2e ffc0 movel %fp@(-64),%sp@-
5830a: 2f2e ffcc movel %fp@(-52),%sp@-
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
5830e: 2d48 ffc8 movel %a0,%fp@(-56)
return media_blocks * media_block_size;
58312: 2f2e ffc8 movel %fp@(-56),%sp@-
58316: 2046 moveal %d6,%a0
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
58318: 2c02 movel %d2,%d6
5831a: 2e03 movel %d3,%d7
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
5831c: 4e90 jsr %a0@
5831e: 4fef 0010 lea %sp@(16),%sp
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
58322: 9e81 subl %d1,%d7
58324: 9d80 subxl %d0,%d6
58326: 6324 blss 5834c <rtems_rfs_fs_open+0x2d0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58328: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5832c: 42a7 clrl %sp@- <== NOT EXECUTED
5832e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58334: 508f addql #8,%sp <== NOT EXECUTED
58336: 4a00 tstb %d0 <== NOT EXECUTED
58338: 6700 0088 beqw 583c2 <rtems_rfs_fs_open+0x346> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
5833c: 4879 0006 c2c6 pea 6c2c6 <CSWTCH.1+0x1020> <== NOT EXECUTED
58342: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
58348: 588f addql #4,%sp <== NOT EXECUTED
5834a: 6076 bras 583c2 <rtems_rfs_fs_open+0x346> <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
5834c: 4280 clrl %d0
5834e: 4281 clrl %d1
58350: 102a 0024 moveb %a2@(36),%d0
58354: 122a 0025 moveb %a2@(37),%d1
58358: 7e18 moveq #24,%d7
5835a: 4841 swap %d1
5835c: 4241 clrw %d1
5835e: efa8 lsll %d7,%d0
58360: 8081 orl %d1,%d0
58362: 4281 clrl %d1
58364: 122a 0027 moveb %a2@(39),%d1
58368: 8081 orl %d1,%d0
5836a: 122a 0026 moveb %a2@(38),%d1
5836e: e189 lsll #8,%d1
58370: 8081 orl %d1,%d0
58372: 7238 moveq #56,%d1
58374: b280 cmpl %d0,%d1
58376: 675c beqs 583d4 <rtems_rfs_fs_open+0x358> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58378: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
5837c: 42a7 clrl %sp@- <== NOT EXECUTED
5837e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58384: 508f addql #8,%sp <== NOT EXECUTED
58386: 4a00 tstb %d0 <== NOT EXECUTED
58388: 6738 beqs 583c2 <rtems_rfs_fs_open+0x346> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
5838a: 42a7 clrl %sp@- <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
5838c: 4280 clrl %d0 <== NOT EXECUTED
5838e: 4281 clrl %d1 <== NOT EXECUTED
58390: 102a 0004 moveb %a2@(4),%d0 <== NOT EXECUTED
58394: 122a 0005 moveb %a2@(5),%d1 <== NOT EXECUTED
58398: efa8 lsll %d7,%d0 <== NOT EXECUTED
5839a: 4841 swap %d1 <== NOT EXECUTED
5839c: 4241 clrw %d1 <== NOT EXECUTED
5839e: 8081 orl %d1,%d0 <== NOT EXECUTED
583a0: 4281 clrl %d1 <== NOT EXECUTED
583a2: 122a 0007 moveb %a2@(7),%d1 <== NOT EXECUTED
583a6: 8081 orl %d1,%d0 <== NOT EXECUTED
583a8: 122a 0006 moveb %a2@(6),%d1 <== NOT EXECUTED
583ac: e189 lsll #8,%d1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
583ae: 8081 orl %d1,%d0 <== NOT EXECUTED
583b0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
583b2: 4879 0006 c306 pea 6c306 <CSWTCH.1+0x1060> <== NOT EXECUTED
583b8: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
583be: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
583c2: 486e fff6 pea %fp@(-10) <== NOT EXECUTED
583c6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
583c8: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
583ce: 508f addql #8,%sp <== NOT EXECUTED
583d0: 6000 02c0 braw 58692 <rtems_rfs_fs_open+0x616> <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
583d4: 4280 clrl %d0
583d6: 4281 clrl %d1
583d8: 102a 0010 moveb %a2@(16),%d0
583dc: 122a 0011 moveb %a2@(17),%d1
583e0: 7418 moveq #24,%d2
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
583e2: 4286 clrl %d6
583e4: 7618 moveq #24,%d3
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
583e6: e5a8 lsll %d2,%d0
583e8: 4841 swap %d1
583ea: 4241 clrw %d1
583ec: 8081 orl %d1,%d0
583ee: 4281 clrl %d1
583f0: 122a 0013 moveb %a2@(19),%d1
583f4: 8081 orl %d1,%d0
583f6: 122a 0012 moveb %a2@(18),%d1
583fa: e189 lsll #8,%d1
583fc: 8081 orl %d1,%d0
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
583fe: 4281 clrl %d1
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
58400: 2740 0014 movel %d0,%a3@(20)
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
58404: 4280 clrl %d0
58406: 102a 0014 moveb %a2@(20),%d0
5840a: 122a 0015 moveb %a2@(21),%d1
5840e: e5a8 lsll %d2,%d0
58410: 4841 swap %d1
58412: 4241 clrw %d1
58414: 8081 orl %d1,%d0
58416: 4281 clrl %d1
58418: 122a 0017 moveb %a2@(23),%d1
5841c: 8081 orl %d1,%d0
5841e: 122a 0016 moveb %a2@(22),%d1
58422: e189 lsll #8,%d1
58424: 8081 orl %d1,%d0
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
58426: 4281 clrl %d1
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
58428: 2740 0018 movel %d0,%a3@(24)
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
5842c: 4280 clrl %d0
5842e: 122a 0018 moveb %a2@(24),%d1
58432: 102a 0019 moveb %a2@(25),%d0
58436: e5a9 lsll %d2,%d1
58438: 4840 swap %d0
5843a: 4240 clrw %d0
5843c: 8280 orl %d0,%d1
5843e: 4280 clrl %d0
58440: 102a 001b moveb %a2@(27),%d0
58444: 8280 orl %d0,%d1
58446: 102a 001a moveb %a2@(26),%d0
5844a: e188 lsll #8,%d0
5844c: 8280 orl %d0,%d1
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
5844e: 4280 clrl %d0
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
58450: 2741 0020 movel %d1,%a3@(32)
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
58454: 102a 001c moveb %a2@(28),%d0
58458: e5a8 lsll %d2,%d0
5845a: 4282 clrl %d2
5845c: 142a 001d moveb %a2@(29),%d2
58460: 4842 swap %d2
58462: 4242 clrw %d2
58464: 8082 orl %d2,%d0
58466: 4282 clrl %d2
58468: 142a 001f moveb %a2@(31),%d2
5846c: 8082 orl %d2,%d0
5846e: 142a 001e moveb %a2@(30),%d2
58472: e18a lsll #8,%d2
58474: 8082 orl %d2,%d0
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
58476: 4282 clrl %d2
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
58478: 2740 0024 movel %d0,%a3@(36)
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
5847c: 142a 0020 moveb %a2@(32),%d2
58480: 1c2a 0021 moveb %a2@(33),%d6
58484: e7aa lsll %d3,%d2
58486: 4846 swap %d6
58488: 4246 clrw %d6
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
5848a: 163c 0038 moveb #56,%d3
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
5848e: 8486 orl %d6,%d2
58490: 4286 clrl %d6
58492: 1c2a 0023 moveb %a2@(35),%d6
58496: 8486 orl %d6,%d2
58498: 1c2a 0022 moveb %a2@(34),%d6
5849c: 45f9 0005 5b88 lea 55b88 <rtems_rfs_buffer_handle_release>,%a2
584a2: e18e lsll #8,%d6
584a4: 8486 orl %d6,%d2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
584a6: 2c04 movel %d4,%d6
584a8: e48e lsrl #2,%d6
fs->block_map_singly_blocks =
584aa: 2046 moveal %d6,%a0
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
584ac: 2742 0028 movel %d2,%a3@(40)
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
584b0: 4c01 2800 mulsl %d1,%d2
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
584b4: 41f0 6c00 lea %a0@(00000000,%d6:l:4),%a0
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
584b8: 2746 0030 movel %d6,%a3@(48)
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
584bc: 4c06 6800 mulsl %d6,%d6
fs->inodes = fs->group_count * fs->group_inodes;
584c0: 2742 0010 movel %d2,%a3@(16)
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
584c4: 2404 movel %d4,%d2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
584c6: 2246 moveal %d6,%a1
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
584c8: 4c43 2002 remul %d3,%d2,%d2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
584cc: 43f1 6c00 lea %a1@(00000000,%d6:l:4),%a1
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
584d0: e78c lsll #3,%d4
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
584d2: 2748 0034 movel %a0,%a3@(52)
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
584d6: 2749 0038 movel %a1,%a3@(56)
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
584da: 2742 002c movel %d2,%a3@(44)
if (fs->group_blocks >
584de: b880 cmpl %d0,%d4
584e0: 643c bccs 5851e <rtems_rfs_fs_open+0x4a2> <== ALWAYS TAKEN
584e2: 2f05 movel %d5,%sp@- <== NOT EXECUTED
handle->dirty = false;
584e4: 4206 clrb %d6 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
584e6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
584e8: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
584ea: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
584ee: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
584f2: 1d46 fff6 moveb %d6,%fp@(-10) <== NOT EXECUTED
584f6: 42a7 clrl %sp@- <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
584f8: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
584fc: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58502: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58506: 4a00 tstb %d0 <== NOT EXECUTED
58508: 6700 0188 beqw 58692 <rtems_rfs_fs_open+0x616> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
5850c: 4879 0006 c34a pea 6c34a <CSWTCH.1+0x10a4> <== NOT EXECUTED
58512: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
58518: 588f addql #4,%sp <== NOT EXECUTED
5851a: 6000 0176 braw 58692 <rtems_rfs_fs_open+0x616> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
5851e: 2f05 movel %d5,%sp@-
handle->dirty = false;
58520: 4207 clrb %d7
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58522: 2f0b movel %a3,%sp@-
58524: 4e92 jsr %a2@
rtems_rfs_buffer_handle_close (fs, &handle);
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
58526: 2f2b 0008 movel %a3@(8),%sp@-
handle->dirty = false;
handle->bnum = 0;
5852a: 42ae fff8 clrl %fp@(-8)
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
5852e: 1d47 fff6 moveb %d7,%fp@(-10)
58532: 2f0b movel %a3,%sp@-
handle->bnum = 0;
handle->buffer = NULL;
58534: 42ae fffc clrl %fp@(-4)
58538: 4eb9 0005 6152 jsr 56152 <rtems_rfs_buffer_setblksize>
if (rc > 0)
5853e: 4fef 0010 lea %sp@(16),%sp
rtems_rfs_buffer_handle_close (fs, &handle);
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
58542: 2400 movel %d0,%d2
if (rc > 0)
58544: 6f3e bles 58584 <rtems_rfs_fs_open+0x508> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58546: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58548: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5854a: 4e92 jsr %a2@ <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
5854c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
58550: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
58554: 1d47 fff6 moveb %d7,%fp@(-10) <== NOT EXECUTED
58558: 42a7 clrl %sp@- <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
5855a: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
5855e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58564: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58568: 4a00 tstb %d0 <== NOT EXECUTED
5856a: 6700 012c beqw 58698 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
5856e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58570: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58576: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58578: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5857a: 4879 0006 c38b pea 6c38b <CSWTCH.1+0x10e5> <== NOT EXECUTED
58580: 6000 00ea braw 5866c <rtems_rfs_fs_open+0x5f0> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
58584: 4878 004c pea 4c <DBL_MANT_DIG+0x17>
58588: 2f2b 0020 movel %a3@(32),%sp@-
5858c: 4eb9 0004 4e3c jsr 44e3c <calloc>
if (!fs->groups)
58592: 508f addql #8,%sp
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
58594: 2740 001c movel %d0,%a3@(28)
if (!fs->groups)
58598: 6600 00e2 bnew 5867c <rtems_rfs_fs_open+0x600>
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
5859c: 2f05 movel %d5,%sp@- <== NOT EXECUTED
5859e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
585a0: 4e92 jsr %a2@ <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
585a2: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
handle->dirty = false;
585a6: 4200 clrb %d0 <== NOT EXECUTED
585a8: 42a7 clrl %sp@- <== NOT EXECUTED
585aa: 1d40 fff6 moveb %d0,%fp@(-10) <== NOT EXECUTED
handle->bnum = 0;
585ae: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
handle->buffer = NULL;
585b2: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
585b6: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
585bc: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
585c0: 4a00 tstb %d0 <== NOT EXECUTED
585c2: 6700 00d2 beqw 58696 <rtems_rfs_fs_open+0x61a> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
585c6: 4879 0006 c3cc pea 6c3cc <CSWTCH.1+0x1126> <== NOT EXECUTED
585cc: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
585d2: 588f addql #4,%sp <== NOT EXECUTED
585d4: 6000 00c0 braw 58696 <rtems_rfs_fs_open+0x61a> <== NOT EXECUTED
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
585d8: 222b 001c movel %a3@(28),%d1
585dc: d285 addl %d5,%d1
585de: 0685 0000 004c addil #76,%d5
rtems_rfs_fs_block (fs, group, 0),
585e4: 202b 0024 movel %a3@(36),%d0
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
585e8: 2f01 movel %d1,%sp@-
585ea: 2f2b 0028 movel %a3@(40),%sp@-
585ee: 2f00 movel %d0,%sp@-
rtems_rfs_fs_block (fs, group, 0),
585f0: 4c04 0800 mulsl %d4,%d0
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
585f4: 2040 moveal %d0,%a0
585f6: 4868 0001 pea %a0@(1)
585fa: 2f0b movel %a3,%sp@-
585fc: 4e92 jsr %a2@
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
585fe: 4fef 0014 lea %sp@(20),%sp
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
58602: 2400 movel %d0,%d2
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
58604: 6f72 bles 58678 <rtems_rfs_fs_open+0x5fc> <== ALWAYS TAKEN
58606: 4286 clrl %d6 <== NOT EXECUTED
58608: 4285 clrl %d5 <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
5860a: 45f9 0004 d22a lea 4d22a <rtems_rfs_group_close>,%a2 <== NOT EXECUTED
58610: 6016 bras 58628 <rtems_rfs_fs_open+0x5ac> <== NOT EXECUTED
58612: 226b 001c moveal %a3@(28),%a1 <== NOT EXECUTED
58616: d3c6 addal %d6,%a1 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
58618: 5285 addql #1,%d5 <== NOT EXECUTED
5861a: 0686 0000 004c addil #76,%d6 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
58620: 2f09 movel %a1,%sp@- <== NOT EXECUTED
58622: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58624: 4e92 jsr %a2@ <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
58626: 508f addql #8,%sp <== NOT EXECUTED
58628: b885 cmpl %d5,%d4 <== NOT EXECUTED
5862a: 6ee6 bgts 58612 <rtems_rfs_fs_open+0x596> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
5862c: 486e fff6 pea %fp@(-10) <== NOT EXECUTED
58630: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58632: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
58638: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
handle->dirty = false;
5863c: 4200 clrb %d0 <== NOT EXECUTED
5863e: 42a7 clrl %sp@- <== NOT EXECUTED
58640: 1d40 fff6 moveb %d0,%fp@(-10) <== NOT EXECUTED
handle->bnum = 0;
58644: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
handle->buffer = NULL;
58648: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
5864c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58652: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58656: 4a00 tstb %d0 <== NOT EXECUTED
58658: 673e beqs 58698 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
5865a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5865c: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58662: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58664: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58666: 4879 0006 c402 pea 6c402 <CSWTCH.1+0x115c> <== NOT EXECUTED
5866c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
58672: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58676: 6020 bras 58698 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
58678: 5284 addql #1,%d4
5867a: 600a bras 58686 <rtems_rfs_fs_open+0x60a>
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
5867c: 4285 clrl %d5
5867e: 4284 clrl %d4
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
58680: 45f9 0004 d040 lea 4d040 <rtems_rfs_group_open>,%a2
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
58686: b8ab 0020 cmpl %a3@(32),%d4
5868a: 6d00 ff4c bltw 585d8 <rtems_rfs_fs_open+0x55c>
5868e: 6000 0176 braw 58806 <rtems_rfs_fs_open+0x78a>
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
return EIO;
58692: 7405 moveq #5,%d2 <== NOT EXECUTED
58694: 6002 bras 58698 <rtems_rfs_fs_open+0x61c> <== NOT EXECUTED
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: no memory for group table\n");
return ENOMEM;
58696: 740c moveq #12,%d2 <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
58698: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
5869a: 4eb9 0005 622e jsr 5622e <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
586a0: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
586a2: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
586a8: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
586ac: 42a7 clrl %sp@- <== NOT EXECUTED
586ae: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
586b4: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
586b8: 4a00 tstb %d0 <== NOT EXECUTED
586ba: 6700 fb02 beqw 581be <rtems_rfs_fs_open+0x142> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
586be: 2f02 movel %d2,%sp@- <== NOT EXECUTED
586c0: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
586c6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
586c8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
586ca: 4879 0006 c43f pea 6c43f <CSWTCH.1+0x1199> <== NOT EXECUTED
586d0: 6000 fae2 braw 581b4 <rtems_rfs_fs_open+0x138> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
586d4: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
586d6: 4eb9 0005 622e jsr 5622e <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
586dc: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
586de: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
586e4: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
586e8: 42a7 clrl %sp@- <== NOT EXECUTED
586ea: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
586f0: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
586f4: 4a00 tstb %d0 <== NOT EXECUTED
586f6: 6700 00ea beqw 587e2 <rtems_rfs_fs_open+0x766> <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
586fa: 2f02 movel %d2,%sp@- <== NOT EXECUTED
586fc: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58702: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58704: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58706: 4879 0006 c46c pea 6c46c <CSWTCH.1+0x11c6> <== NOT EXECUTED
5870c: 6000 00ca braw 587d8 <rtems_rfs_fs_open+0x75c> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
58710: 2054 moveal %a4@,%a0
58712: 7004 moveq #4,%d0
58714: c090 andl %a0@,%d0
58716: 6678 bnes 58790 <rtems_rfs_fs_open+0x714>
{
mode = rtems_rfs_inode_get_mode (&inode);
58718: 226a 000c moveal %a2@(12),%a1
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
5871c: 4280 clrl %d0
5871e: 1029 0002 moveb %a1@(2),%d0
58722: 4281 clrl %d1
58724: 1229 0003 moveb %a1@(3),%d1
58728: e188 lsll #8,%d0
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
5872a: 8081 orl %d1,%d0
5872c: 0c80 0000 ffff cmpil #65535,%d0
58732: 670e beqs 58742 <rtems_rfs_fs_open+0x6c6> <== NEVER TAKEN
58734: 0280 0000 f000 andil #61440,%d0
5873a: 0c80 0000 4000 cmpil #16384,%d0
58740: 674e beqs 58790 <rtems_rfs_fs_open+0x714> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (*fs, &inode);
58742: 486e ffd0 pea %fp@(-48) <== NOT EXECUTED
58746: 2f08 movel %a0,%sp@- <== NOT EXECUTED
58748: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
5874e: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
58750: 4eb9 0005 622e jsr 5622e <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
58756: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
58758: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
5875e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58762: 42a7 clrl %sp@- <== NOT EXECUTED
58764: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5876a: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
5876e: 4a00 tstb %d0 <== NOT EXECUTED
58770: 670e beqs 58780 <rtems_rfs_fs_open+0x704> <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
58772: 4879 0006 c499 pea 6c499 <CSWTCH.1+0x11f3> <== NOT EXECUTED
58778: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
5877e: 588f addql #4,%sp <== NOT EXECUTED
errno = EIO;
58780: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
58786: 2040 moveal %d0,%a0 <== NOT EXECUTED
58788: 7005 moveq #5,%d0 <== NOT EXECUTED
5878a: 2080 movel %d0,%a0@ <== NOT EXECUTED
5878c: 6000 fa3a braw 581c8 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
58790: 486e ffd0 pea %fp@(-48)
58794: 2f08 movel %a0,%sp@-
58796: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
if (rc > 0)
5879c: 508f addql #8,%sp
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
5879e: 2400 movel %d0,%d2
if (rc > 0)
587a0: 6f4e bles 587f0 <rtems_rfs_fs_open+0x774> <== ALWAYS TAKEN
{
rtems_rfs_buffer_close (*fs);
587a2: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
587a4: 4eb9 0005 622e jsr 5622e <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
587aa: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
587ac: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
587b2: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
587b6: 42a7 clrl %sp@- <== NOT EXECUTED
587b8: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
587be: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
587c2: 4a00 tstb %d0 <== NOT EXECUTED
587c4: 671c beqs 587e2 <rtems_rfs_fs_open+0x766> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
587c6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
587c8: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
587ce: 2f00 movel %d0,%sp@- <== NOT EXECUTED
587d0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
587d2: 4879 0006 c4c2 pea 6c4c2 <CSWTCH.1+0x121c> <== NOT EXECUTED
587d8: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
587de: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
errno = rc;
587e2: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
587e8: 2240 moveal %d0,%a1 <== NOT EXECUTED
587ea: 2282 movel %d2,%a1@ <== NOT EXECUTED
587ec: 6000 f9da braw 581c8 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
return -1;
}
errno = 0;
587f0: 4eb9 0005 a88c jsr 5a88c <__errno>
587f6: 2040 moveal %d0,%a0
return 0;
587f8: 4280 clrl %d0
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
errno = 0;
587fa: 4290 clrl %a0@
return 0;
}
587fc: 4cee 3cfc ff98 moveml %fp@(-104),%d2-%d7/%a2-%a5
58802: 4e5e unlk %fp
58804: 4e75 rts
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
58806: 4878 0001 pea 1 <ADD>
5880a: 45ee ffd0 lea %fp@(-48),%a2
5880e: 2f0a movel %a2,%sp@-
58810: 4878 0001 pea 1 <ADD>
58814: 2f14 movel %a4@,%sp@-
58816: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
5881c: 4fef 0010 lea %sp@(16),%sp
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
58820: 2400 movel %d0,%d2
if (rc > 0)
58822: 6f00 feec blew 58710 <rtems_rfs_fs_open+0x694>
58826: 6000 feac braw 586d4 <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
00058018 <rtems_rfs_fs_size>:
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
58018: 91c8 subal %a0,%a0 <== NOT EXECUTED
uint64_t block_size = rtems_rfs_fs_block_size (fs);
5801a: 4280 clrl %d0 <== NOT EXECUTED
#include <rtems/rfs/rtems-rfs-inode.h>
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
5801c: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
58020: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58022: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
58026: 222a 0008 movel %a2@(8),%d1 <== NOT EXECUTED
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
5802a: 226a 0004 moveal %a2@(4),%a1 <== NOT EXECUTED
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
5802e: 2f09 movel %a1,%sp@- <== NOT EXECUTED
58030: 2f08 movel %a0,%sp@- <== NOT EXECUTED
58032: 2f01 movel %d1,%sp@- <== NOT EXECUTED
58034: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58036: 4eb9 0006 713c jsr 6713c <__muldi3> <== NOT EXECUTED
}
5803c: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
58040: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
58044: 4e5e unlk %fp <== NOT EXECUTED
0004d2c8 <rtems_rfs_group_bitmap_alloc>:
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
4d2c8: 4e56 ffc8 linkw %fp,#-56
4d2cc: 222e 000c movel %fp@(12),%d1
4d2d0: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4d2d4: 162e 0013 moveb %fp@(19),%d3
4d2d8: 246e 0008 moveal %fp@(8),%a2
4d2dc: 266e 0014 moveal %fp@(20),%a3
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
4d2e0: 6708 beqs 4d2ea <rtems_rfs_group_bitmap_alloc+0x22>
{
size = fs->group_inodes;
4d2e2: 202a 0028 movel %a2@(40),%d0
goal -= RTEMS_RFS_ROOT_INO;
4d2e6: 5381 subql #1,%d1
4d2e8: 6004 bras 4d2ee <rtems_rfs_group_bitmap_alloc+0x26>
}
else
size = fs->group_blocks;
4d2ea: 202a 0024 movel %a2@(36),%d0
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
4d2ee: 4285 clrl %d5
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
if (rc > 0)
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d2f0: 4bf9 0005 5b88 lea 55b88 <rtems_rfs_buffer_handle_release>,%a5
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
4d2f6: 4c40 1002 remul %d0,%d2,%d1
4d2fa: 4c40 1001 remul %d0,%d1,%d1
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
bit = direction > 0 ? 0 : size - 1;
4d2fe: 5380 subql #1,%d0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
4d300: 2d42 fffa movel %d2,%fp@(-6)
offset = 0;
updown = true;
direction = 1;
4d304: 7401 moveq #1,%d2
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
4d306: 2d41 fff4 movel %d1,%fp@(-12)
offset = 0;
updown = true;
4d30a: 7c01 moveq #1,%d6
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
bit = direction > 0 ? 0 : size - 1;
4d30c: 2d40 fff0 movel %d0,%fp@(-16)
4d310: 6004 bras 4d316 <rtems_rfs_group_bitmap_alloc+0x4e>
*/
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
4d312: 74ff moveq #-1,%d2 <== NOT EXECUTED
updown = false;
4d314: 4206 clrb %d6
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
4d316: 2802 movel %d2,%d4
4d318: 4c05 4800 mulsl %d5,%d4
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
4d31c: 4200 clrb %d0
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
4d31e: d8ae fff4 addl %fp@(-12),%d4
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
4d322: 1d40 ffff moveb %d0,%fp@(-1)
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
4d326: 4a85 tstl %d5
4d328: 6712 beqs 4d33c <rtems_rfs_group_bitmap_alloc+0x74>
bit = direction > 0 ? 0 : size - 1;
4d32a: 7001 moveq #1,%d0
4d32c: b082 cmpl %d2,%d0
4d32e: 6706 beqs 4d336 <rtems_rfs_group_bitmap_alloc+0x6e>
4d330: 202e fff0 movel %fp@(-16),%d0
4d334: 6002 bras 4d338 <rtems_rfs_group_bitmap_alloc+0x70>
4d336: 4280 clrl %d0
4d338: 2d40 fffa movel %d0,%fp@(-6)
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
4d33c: 4a84 tstl %d4
4d33e: 6d06 blts 4d346 <rtems_rfs_group_bitmap_alloc+0x7e>
4d340: b8aa 0020 cmpl %a2@(32),%d4
4d344: 6d10 blts 4d356 <rtems_rfs_group_bitmap_alloc+0x8e>
{
if (!updown)
4d346: 4a06 tstb %d6
4d348: 6700 00cc beqw 4d416 <rtems_rfs_group_bitmap_alloc+0x14e>
break;
direction = direction > 0 ? -1 : 1;
4d34c: 7001 moveq #1,%d0
4d34e: b082 cmpl %d2,%d0
4d350: 67c0 beqs 4d312 <rtems_rfs_group_bitmap_alloc+0x4a><== NEVER TAKEN
4d352: 7401 moveq #1,%d2
4d354: 60be bras 4d314 <rtems_rfs_group_bitmap_alloc+0x4c>
4d356: 7e4c moveq #76,%d7
4d358: 4c04 7800 mulsl %d4,%d7
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4d35c: 286a 001c moveal %a2@(28),%a4
4d360: d9c7 addal %d7,%a4
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
4d362: 4a03 tstb %d3
4d364: 6706 beqs 4d36c <rtems_rfs_group_bitmap_alloc+0xa4>
bitmap = &fs->groups[group].inode_bitmap;
4d366: 49ec 002a lea %a4@(42),%a4
4d36a: 6002 bras 4d36e <rtems_rfs_group_bitmap_alloc+0xa6>
else
bitmap = &fs->groups[group].block_bitmap;
4d36c: 508c addql #8,%a4
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
4d36e: 486e fffa pea %fp@(-6)
4d372: 486e ffff pea %fp@(-1)
4d376: 2f2e fffa movel %fp@(-6),%sp@-
4d37a: 2f0c movel %a4,%sp@-
4d37c: 4eb9 0005 4aaa jsr 54aaa <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
4d382: 4fef 0010 lea %sp@(16),%sp
4d386: 4a80 tstl %d0
4d388: 6e00 00b6 bgtw 4d440 <rtems_rfs_group_bitmap_alloc+0x178>
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
4d38c: 7001 moveq #1,%d0
4d38e: c092 andl %a2@,%d0
4d390: 6608 bnes 4d39a <rtems_rfs_group_bitmap_alloc+0xd2><== NEVER TAKEN
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d392: 2f14 movel %a4@,%sp@-
4d394: 2f0a movel %a2,%sp@-
4d396: 4e95 jsr %a5@
4d398: 508f addql #8,%sp
if (allocated)
4d39a: 4a2e ffff tstb %fp@(-1)
4d39e: 6762 beqs 4d402 <rtems_rfs_group_bitmap_alloc+0x13a><== NEVER TAKEN
{
if (inode)
4d3a0: 4a03 tstb %d3
4d3a2: 6714 beqs 4d3b8 <rtems_rfs_group_bitmap_alloc+0xf0>
*result = rtems_rfs_group_inode (fs, group, bit);
4d3a4: 45ea 0028 lea %a2@(40),%a2
4d3a8: 4c12 4800 mulsl %a2@,%d4
4d3ac: 206e fffa moveal %fp@(-6),%a0
4d3b0: 5288 addql #1,%a0
4d3b2: d1c4 addal %d4,%a0
4d3b4: 2688 movel %a0,%a3@
4d3b6: 600e bras 4d3c6 <rtems_rfs_group_bitmap_alloc+0xfe>
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
4d3b8: 206a 001c moveal %a2@(28),%a0
4d3bc: 242e fffa movel %fp@(-6),%d2
4d3c0: d4b0 7800 addl %a0@(00000000,%d7:l),%d2
4d3c4: 2682 movel %d2,%a3@
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d3c6: 2f3c 0002 0000 movel #131072,%sp@-
4d3cc: 42a7 clrl %sp@-
4d3ce: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d3d4: 508f addql #8,%sp
4d3d6: 4a00 tstb %d0
4d3d8: 6760 beqs 4d43a <rtems_rfs_group_bitmap_alloc+0x172><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
4d3da: 2213 movel %a3@,%d1 <== NOT EXECUTED
4d3dc: 203c 0006 a2d7 movel #434903,%d0 <== NOT EXECUTED
4d3e2: 4a03 tstb %d3 <== NOT EXECUTED
4d3e4: 6706 beqs 4d3ec <rtems_rfs_group_bitmap_alloc+0x124><== NOT EXECUTED
4d3e6: 203c 0006 ab72 movel #437106,%d0 <== NOT EXECUTED
4d3ec: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4d3ee: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d3f0: 4879 0006 ab78 pea 6ab78 <ramdisk_ops+0x98e> <== NOT EXECUTED
4d3f6: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d3fc: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4d400: 6038 bras 4d43a <rtems_rfs_group_bitmap_alloc+0x172><== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
4d402: 4a06 tstb %d6
4d404: 670a beqs 4d410 <rtems_rfs_group_bitmap_alloc+0x148><== NEVER TAKEN
direction = direction > 0 ? -1 : 1;
4d406: 7001 moveq #1,%d0
4d408: b082 cmpl %d2,%d0
4d40a: 57c2 seq %d2
4d40c: 49c2 extbl %d2
4d40e: 8480 orl %d0,%d2
offset++;
4d410: 5285 addql #1,%d5
4d412: 6000 ff02 braw 4d316 <rtems_rfs_group_bitmap_alloc+0x4e>
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d416: 2f3c 0002 0000 movel #131072,%sp@-
4d41c: 42a7 clrl %sp@-
4d41e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d424: 508f addql #8,%sp
4d426: 4a00 tstb %d0
4d428: 6714 beqs 4d43e <rtems_rfs_group_bitmap_alloc+0x176><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
4d42a: 4879 0006 abaa pea 6abaa <ramdisk_ops+0x9c0> <== NOT EXECUTED
4d430: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
4d436: 588f addql #4,%sp <== NOT EXECUTED
4d438: 6004 bras 4d43e <rtems_rfs_group_bitmap_alloc+0x176><== NOT EXECUTED
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
4d43a: 4280 clrl %d0
4d43c: 6002 bras 4d440 <rtems_rfs_group_bitmap_alloc+0x178>
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
4d43e: 701c moveq #28,%d0
}
4d440: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
4d446: 4e5e unlk %fp <== NOT EXECUTED
0004d44a <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
4d44a: 4e56 fff0 linkw %fp,#-16
4d44e: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d452: 2f3c 0002 0000 movel #131072,%sp@-
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
4d458: 246e 0008 moveal %fp@(8),%a2
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d45c: 42a7 clrl %sp@-
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
4d45e: 266e 0010 moveal %fp@(16),%a3
4d462: 142e 000f moveb %fp@(15),%d2
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d466: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d46c: 508f addql #8,%sp
4d46e: 4a00 tstb %d0
4d470: 6724 beqs 4d496 <rtems_rfs_group_bitmap_free+0x4c><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
4d472: 203c 0006 a2d7 movel #434903,%d0 <== NOT EXECUTED
4d478: 4a02 tstb %d2 <== NOT EXECUTED
4d47a: 6706 beqs 4d482 <rtems_rfs_group_bitmap_free+0x38><== NOT EXECUTED
4d47c: 203c 0006 ab72 movel #437106,%d0 <== NOT EXECUTED
4d482: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d484: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d486: 4879 0006 abdd pea 6abdd <ramdisk_ops+0x9f3> <== NOT EXECUTED
4d48c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d492: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4d496: 220b movel %a3,%d1
4d498: 5381 subql #1,%d1
inode ? "inode" : "block", no);
if (inode)
4d49a: 4a02 tstb %d2
4d49c: 6706 beqs 4d4a4 <rtems_rfs_group_bitmap_free+0x5a><== NEVER TAKEN
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
4d49e: 202a 0028 movel %a2@(40),%d0
4d4a2: 6004 bras 4d4a8 <rtems_rfs_group_bitmap_free+0x5e>
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
4d4a4: 202a 0024 movel %a2@(36),%d0 <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4d4a8: 266a 001c moveal %a2@(28),%a3
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
4d4ac: 4c40 1003 remul %d0,%d3,%d1
4d4b0: 4c40 1001 remul %d0,%d1,%d1
4d4b4: 2001 movel %d1,%d0
4d4b6: 724c moveq #76,%d1
4d4b8: 4c01 0800 mulsl %d1,%d0
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4d4bc: d7c0 addal %d0,%a3
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
4d4be: 4a02 tstb %d2
4d4c0: 6706 beqs 4d4c8 <rtems_rfs_group_bitmap_free+0x7e><== NEVER TAKEN
bitmap = &fs->groups[group].inode_bitmap;
4d4c2: 47eb 002a lea %a3@(42),%a3
4d4c6: 6002 bras 4d4ca <rtems_rfs_group_bitmap_free+0x80>
else
bitmap = &fs->groups[group].block_bitmap;
4d4c8: 508b addql #8,%a3 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
4d4ca: 2f03 movel %d3,%sp@-
4d4cc: 2f0b movel %a3,%sp@-
4d4ce: 4eb9 0005 490c jsr 5490c <rtems_rfs_bitmap_map_clear>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d4d4: 2f13 movel %a3@,%sp@-
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
4d4d6: 2400 movel %d0,%d2
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d4d8: 2f0a movel %a2,%sp@-
4d4da: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
return rc;
}
4d4e0: 2002 movel %d2,%d0
4d4e2: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4d4e8: 4e5e unlk %fp <== NOT EXECUTED
0004d4ec <rtems_rfs_group_bitmap_test>:
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
4d4ec: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
4d4f0: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d4f4: 2f3c 0002 0000 movel #131072,%sp@- <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
4d4fa: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d4fe: 42a7 clrl %sp@- <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
4d500: 242e 0010 movel %fp@(16),%d2 <== NOT EXECUTED
4d504: 162e 000f moveb %fp@(15),%d3 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4d508: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
4d50e: 508f addql #8,%sp <== NOT EXECUTED
4d510: 4a00 tstb %d0 <== NOT EXECUTED
4d512: 6724 beqs 4d538 <rtems_rfs_group_bitmap_test+0x4c><== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
4d514: 203c 0006 a2d7 movel #434903,%d0 <== NOT EXECUTED
4d51a: 4a03 tstb %d3 <== NOT EXECUTED
4d51c: 6706 beqs 4d524 <rtems_rfs_group_bitmap_test+0x38><== NOT EXECUTED
4d51e: 203c 0006 ab72 movel #437106,%d0 <== NOT EXECUTED
4d524: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d526: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d528: 4879 0006 ac09 pea 6ac09 <ramdisk_ops+0xa1f> <== NOT EXECUTED
4d52e: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d534: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
4d538: 4a03 tstb %d3 <== NOT EXECUTED
4d53a: 6712 beqs 4d54e <rtems_rfs_group_bitmap_test+0x62><== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
4d53c: 4a82 tstl %d2 <== NOT EXECUTED
4d53e: 6f58 bles 4d598 <rtems_rfs_group_bitmap_test+0xac><== NOT EXECUTED
4d540: b4aa 0010 cmpl %a2@(16),%d2 <== NOT EXECUTED
4d544: 6252 bhis 4d598 <rtems_rfs_group_bitmap_test+0xac><== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
4d546: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
4d54a: 5382 subql #1,%d2 <== NOT EXECUTED
4d54c: 600a bras 4d558 <rtems_rfs_group_bitmap_test+0x6c><== NOT EXECUTED
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
4d54e: b4aa 0004 cmpl %a2@(4),%d2 <== NOT EXECUTED
4d552: 6444 bccs 4d598 <rtems_rfs_group_bitmap_test+0xac><== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
4d554: 202a 0024 movel %a2@(36),%d0 <== NOT EXECUTED
}
group = no / size;
4d558: 4c40 2001 remul %d0,%d1,%d2 <== NOT EXECUTED
4d55c: 4c40 2002 remul %d0,%d2,%d2 <== NOT EXECUTED
4d560: 704c moveq #76,%d0 <== NOT EXECUTED
4d562: 4c00 2800 mulsl %d0,%d2 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4d566: d4aa 001c addl %a2@(28),%d2 <== NOT EXECUTED
4d56a: 2642 moveal %d2,%a3 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
4d56c: 4a03 tstb %d3 <== NOT EXECUTED
4d56e: 6706 beqs 4d576 <rtems_rfs_group_bitmap_test+0x8a><== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
4d570: 47eb 002a lea %a3@(42),%a3 <== NOT EXECUTED
4d574: 6002 bras 4d578 <rtems_rfs_group_bitmap_test+0x8c><== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
4d576: 508b addql #8,%a3 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
4d578: 2f2e 0014 movel %fp@(20),%sp@- <== NOT EXECUTED
4d57c: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4d57e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d580: 4eb9 0005 4978 jsr 54978 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d586: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
4d588: 2400 movel %d0,%d2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4d58a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4d58c: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
4d592: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4d596: 6002 bras 4d59a <rtems_rfs_group_bitmap_test+0xae><== NOT EXECUTED
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
4d598: 7416 moveq #22,%d2 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
rtems_rfs_bitmap_release_buffer (fs, bitmap);
return rc;
}
4d59a: 2002 movel %d2,%d0 <== NOT EXECUTED
4d59c: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3 <== NOT EXECUTED
4d5a2: 4e5e unlk %fp <== NOT EXECUTED
0004d22a <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
4d22a: 4e56 ffec linkw %fp,#-20
4d22e: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
4d232: 2f3c 0001 0000 movel #65536,%sp@-
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
4d238: 262e 0008 movel %fp@(8),%d3
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
4d23c: 42a7 clrl %sp@-
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
4d23e: 246e 000c moveal %fp@(12),%a2
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
4d242: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d248: 508f addql #8,%sp
4d24a: 4a00 tstb %d0
4d24c: 6710 beqs 4d25e <rtems_rfs_group_close+0x34> <== ALWAYS TAKEN
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
4d24e: 2f12 movel %a2@,%sp@- <== NOT EXECUTED
4d250: 4879 0006 ab50 pea 6ab50 <ramdisk_ops+0x966> <== NOT EXECUTED
4d256: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d25c: 508f addql #8,%sp <== NOT EXECUTED
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
4d25e: 486a 002a pea %a2@(42)
4d262: 47f9 0005 4c2e lea 54c2e <rtems_rfs_bitmap_close>,%a3
4d268: 4e93 jsr %a3@
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d26a: 486a 0042 pea %a2@(66)
4d26e: 2800 movel %d0,%d4
4d270: 2f03 movel %d3,%sp@-
4d272: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
4d278: 4200 clrb %d0
4d27a: 1540 0042 moveb %d0,%a2@(66)
handle->bnum = 0;
4d27e: 42aa 0044 clrl %a2@(68)
handle->buffer = NULL;
4d282: 42aa 0048 clrl %a2@(72)
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
4d286: 486a 0008 pea %a2@(8)
4d28a: 4e93 jsr %a3@
if (rc > 0)
4d28c: 4fef 0010 lea %sp@(16),%sp
4d290: 4a80 tstl %d0
4d292: 6e0c bgts 4d2a0 <rtems_rfs_group_close+0x76> <== NEVER TAKEN
4d294: 2404 movel %d4,%d2
4d296: 4682 notl %d2
4d298: d482 addl %d2,%d2
4d29a: 9582 subxl %d2,%d2
4d29c: c484 andl %d4,%d2
4d29e: 6002 bras 4d2a2 <rtems_rfs_group_close+0x78>
4d2a0: 2400 movel %d0,%d2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d2a2: 486a 0020 pea %a2@(32)
4d2a6: 2f03 movel %d3,%sp@-
4d2a8: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
4d2ae: 4200 clrb %d0
4d2b0: 1540 0020 moveb %d0,%a2@(32)
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
4d2b4: 2002 movel %d2,%d0
handle->bnum = 0;
4d2b6: 42aa 0022 clrl %a2@(34)
handle->buffer = NULL;
4d2ba: 42aa 0026 clrl %a2@(38)
4d2be: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
4d2c4: 4e5e unlk %fp <== NOT EXECUTED
0004d040 <rtems_rfs_group_open>:
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
4d040: 4e56 ffe0 linkw %fp,#-32
4d044: 222e 0014 movel %fp@(20),%d1
4d048: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@
4d04c: 266e 0008 moveal %fp@(8),%a3
4d050: 262e 000c movel %fp@(12),%d3
4d054: 242e 0010 movel %fp@(16),%d2
4d058: 246e 0018 moveal %fp@(24),%a2
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
4d05c: 202b 0004 movel %a3@(4),%d0
4d060: b083 cmpl %d3,%d0
4d062: 623a bhis 4d09e <rtems_rfs_group_open+0x5e> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
4d064: 2f3c 0000 8000 movel #32768,%sp@- <== NOT EXECUTED
4d06a: 42a7 clrl %sp@- <== NOT EXECUTED
4d06c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
4d072: 508f addql #8,%sp <== NOT EXECUTED
4d074: 4a00 tstb %d0 <== NOT EXECUTED
4d076: 6700 01a0 beqw 4d218 <rtems_rfs_group_open+0x1d8> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
4d07a: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
4d07e: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4d084: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d086: 4878 0005 pea 5 <COMPARE> <== NOT EXECUTED
4d08a: 4879 0006 aa61 pea 6aa61 <ramdisk_ops+0x877> <== NOT EXECUTED
4d090: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d096: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d09a: 6000 017c braw 4d218 <rtems_rfs_group_open+0x1d8> <== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
4d09e: 2042 moveal %d2,%a0
4d0a0: d1c3 addal %d3,%a0
4d0a2: b088 cmpl %a0,%d0
4d0a4: 6204 bhis 4d0aa <rtems_rfs_group_open+0x6a> <== NEVER TAKEN
size = rtems_rfs_fs_blocks (fs) - base;
4d0a6: 2400 movel %d0,%d2
4d0a8: 9483 subl %d3,%d2
4d0aa: 2a02 movel %d2,%d5
4d0ac: b282 cmpl %d2,%d1
4d0ae: 6402 bccs 4d0b2 <rtems_rfs_group_open+0x72> <== NEVER TAKEN
4d0b0: 2a01 movel %d1,%d5
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
4d0b2: 2f3c 0000 8000 movel #32768,%sp@-
4d0b8: 42a7 clrl %sp@-
4d0ba: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d0c0: 508f addql #8,%sp
4d0c2: 4a00 tstb %d0
4d0c4: 6716 beqs 4d0dc <rtems_rfs_group_open+0x9c> <== ALWAYS TAKEN
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
4d0c6: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4d0c8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d0ca: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4d0cc: 4879 0006 aaa0 pea 6aaa0 <ramdisk_ops+0x8b6> <== NOT EXECUTED
4d0d2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d0d8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
base, size, inodes);
group->base = base;
group->size = size;
4d0dc: 2542 0004 movel %d2,%a2@(4)
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
4d0e0: 280a movel %a2,%d4
4d0e2: 2c0a movel %a2,%d6
4d0e4: 0684 0000 0020 addil #32,%d4
4d0ea: 5086 addql #8,%d6
4d0ec: 49f9 0005 4bd6 lea 54bd6 <rtems_rfs_bitmap_open>,%a4
4d0f2: 4200 clrb %d0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
4d0f4: 2483 movel %d3,%a2@
4d0f6: 1540 0020 moveb %d0,%a2@(32)
handle->bnum = 0;
4d0fa: 42aa 0022 clrl %a2@(34)
handle->buffer = NULL;
4d0fe: 42aa 0026 clrl %a2@(38)
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
4d102: 2f03 movel %d3,%sp@-
4d104: 2f02 movel %d2,%sp@-
4d106: 2f04 movel %d4,%sp@-
4d108: 2f0b movel %a3,%sp@-
4d10a: 2f06 movel %d6,%sp@-
4d10c: 4e94 jsr %a4@
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
4d10e: 4fef 0014 lea %sp@(20),%sp
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
4d112: 2400 movel %d0,%d2
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
4d114: 6f46 bles 4d15c <rtems_rfs_group_open+0x11c> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d116: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4d118: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d11a: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
4d120: 4200 clrb %d0 <== NOT EXECUTED
handle->bnum = 0;
4d122: 42aa 0022 clrl %a2@(34) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
4d126: 1540 0020 moveb %d0,%a2@(32) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
4d12a: 42aa 0026 clrl %a2@(38) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
4d12e: 2f3c 0000 8000 movel #32768,%sp@- <== NOT EXECUTED
4d134: 42a7 clrl %sp@- <== NOT EXECUTED
4d136: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
4d13c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d140: 4a00 tstb %d0 <== NOT EXECUTED
4d142: 6700 00da beqw 4d21e <rtems_rfs_group_open+0x1de> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
4d146: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d148: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4d14e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d150: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d152: 4879 0006 aad8 pea 6aad8 <ramdisk_ops+0x8ee> <== NOT EXECUTED
4d158: 6000 0090 braw 4d1ea <rtems_rfs_group_open+0x1aa> <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
4d15c: 42aa 0044 clrl %a2@(68)
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
4d160: 260a movel %a2,%d3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4d162: 4200 clrb %d0
handle->bnum = 0;
handle->buffer = NULL;
4d164: 42aa 0048 clrl %a2@(72)
4d168: 0683 0000 0042 addil #66,%d3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4d16e: 1540 0042 moveb %d0,%a2@(66)
4d172: 2012 movel %a2@,%d0
4d174: 5280 addql #1,%d0
4d176: 2f00 movel %d0,%sp@-
4d178: 2f05 movel %d5,%sp@-
4d17a: 2f03 movel %d3,%sp@-
4d17c: 2f0b movel %a3,%sp@-
4d17e: 486a 002a pea %a2@(42)
4d182: 4e94 jsr %a4@
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
4d184: 4fef 0014 lea %sp@(20),%sp
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
4d188: 2400 movel %d0,%d2
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
4d18a: 6f6a bles 4d1f6 <rtems_rfs_group_open+0x1b6> <== ALWAYS TAKEN
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d18c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4d18e: 49f9 0005 5b88 lea 55b88 <rtems_rfs_buffer_handle_release>,%a4<== NOT EXECUTED
4d194: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d196: 4e94 jsr %a4@ <== NOT EXECUTED
handle->dirty = false;
4d198: 4200 clrb %d0 <== NOT EXECUTED
handle->bnum = 0;
4d19a: 42aa 0044 clrl %a2@(68) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
4d19e: 1540 0042 moveb %d0,%a2@(66) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
4d1a2: 42aa 0048 clrl %a2@(72) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
4d1a6: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4d1a8: 4eb9 0005 4c2e jsr 54c2e <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4d1ae: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4d1b0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4d1b2: 4e94 jsr %a4@ <== NOT EXECUTED
handle->dirty = false;
4d1b4: 4200 clrb %d0 <== NOT EXECUTED
handle->bnum = 0;
4d1b6: 42aa 0022 clrl %a2@(34) <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
4d1ba: 1540 0020 moveb %d0,%a2@(32) <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
4d1be: 42aa 0026 clrl %a2@(38) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
4d1c2: 2f3c 0000 8000 movel #32768,%sp@- <== NOT EXECUTED
4d1c8: 42a7 clrl %sp@- <== NOT EXECUTED
4d1ca: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
4d1d0: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
4d1d4: 4a00 tstb %d0 <== NOT EXECUTED
4d1d6: 6746 beqs 4d21e <rtems_rfs_group_open+0x1de> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
4d1d8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d1da: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
4d1e0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d1e2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d1e4: 4879 0006 ab14 pea 6ab14 <ramdisk_ops+0x92a> <== NOT EXECUTED
4d1ea: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d1f0: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4d1f4: 6028 bras 4d21e <rtems_rfs_group_open+0x1de> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
4d1f6: 7001 moveq #1,%d0
4d1f8: c093 andl %a3@,%d0
4d1fa: 6620 bnes 4d21c <rtems_rfs_group_open+0x1dc> <== NEVER TAKEN
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
4d1fc: 2f2a 0008 movel %a2@(8),%sp@-
4d200: 49f9 0005 5b88 lea 55b88 <rtems_rfs_buffer_handle_release>,%a4
4d206: 2f0b movel %a3,%sp@-
4d208: 4e94 jsr %a4@
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
4d20a: 2f2a 002a movel %a2@(42),%sp@-
4d20e: 2f0b movel %a3,%sp@-
4d210: 4e94 jsr %a4@
4d212: 4fef 0010 lea %sp@(16),%sp
4d216: 6004 bras 4d21c <rtems_rfs_group_open+0x1dc>
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
4d218: 7405 moveq #5,%d2 <== NOT EXECUTED
4d21a: 6002 bras 4d21e <rtems_rfs_group_open+0x1de> <== NOT EXECUTED
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
4d21c: 4282 clrl %d2
}
4d21e: 2002 movel %d2,%d0
4d220: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
4d226: 4e5e unlk %fp <== NOT EXECUTED
0004d5a6 <rtems_rfs_group_usage>:
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
4d5a6: 4281 clrl %d1 <== NOT EXECUTED
4d5a8: 4280 clrl %d0 <== NOT EXECUTED
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
4d5aa: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
4d5ae: 226e 000c moveal %fp@(12),%a1 <== NOT EXECUTED
4d5b2: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ <== NOT EXECUTED
4d5b6: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
4d5ba: 206e 0010 moveal %fp@(16),%a0 <== NOT EXECUTED
int g;
*blocks = 0;
4d5be: 4291 clrl %a1@ <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
4d5c0: 242a 0020 movel %a2@(32),%d2 <== NOT EXECUTED
size_t* inodes)
{
int g;
*blocks = 0;
*inodes = 0;
4d5c4: 4290 clrl %a0@ <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
4d5c6: 6022 bras 4d5ea <rtems_rfs_group_usage+0x44> <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
4d5c8: 266a 001c moveal %a2@(28),%a3 <== NOT EXECUTED
4d5cc: d7c1 addal %d1,%a3 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
4d5ce: 5280 addql #1,%d0 <== NOT EXECUTED
4d5d0: 0681 0000 004c addil #76,%d1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
4d5d6: 262b 0014 movel %a3@(20),%d3 <== NOT EXECUTED
4d5da: 96ab 0018 subl %a3@(24),%d3 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
4d5de: d791 addl %d3,%a1@ <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
4d5e0: 262b 0036 movel %a3@(54),%d3 <== NOT EXECUTED
4d5e4: 96ab 003a subl %a3@(58),%d3 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
4d5e8: d790 addl %d3,%a0@ <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
4d5ea: b480 cmpl %d0,%d2 <== NOT EXECUTED
4d5ec: 6eda bgts 4d5c8 <rtems_rfs_group_usage+0x22> <== NOT EXECUTED
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
4d5ee: 202a 0004 movel %a2@(4),%d0 <== NOT EXECUTED
4d5f2: b091 cmpl %a1@,%d0 <== NOT EXECUTED
4d5f4: 6402 bccs 4d5f8 <rtems_rfs_group_usage+0x52> <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
4d5f6: 2280 movel %d0,%a1@ <== NOT EXECUTED
if (*inodes > rtems_rfs_fs_inodes (fs))
4d5f8: 202a 0010 movel %a2@(16),%d0 <== NOT EXECUTED
4d5fc: b090 cmpl %a0@,%d0 <== NOT EXECUTED
4d5fe: 6402 bccs 4d602 <rtems_rfs_group_usage+0x5c> <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
4d600: 2080 movel %d0,%a0@ <== NOT EXECUTED
return 0;
}
4d602: 4280 clrl %d0 <== NOT EXECUTED
4d604: 4cd7 0c0c moveml %sp@,%d2-%d3/%a2-%a3 <== NOT EXECUTED
4d608: 4e5e unlk %fp <== NOT EXECUTED
0004d876 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d876: 4e56 0000 linkw %fp,#0
4d87a: 2f0a movel %a2,%sp@-
4d87c: 246e 000c moveal %fp@(12),%a2
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
4d880: 2f3c 0008 0000 movel #524288,%sp@-
4d886: 42a7 clrl %sp@-
4d888: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d88e: 508f addql #8,%sp
4d890: 4a00 tstb %d0
4d892: 6712 beqs 4d8a6 <rtems_rfs_inode_close+0x30> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
4d894: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4d898: 4879 0006 acc2 pea 6acc2 <ramdisk_ops+0xad8> <== NOT EXECUTED
4d89e: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d8a4: 508f addql #8,%sp <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
4d8a6: 4878 0001 pea 1 <ADD>
4d8aa: 2f0a movel %a2,%sp@-
4d8ac: 2f2e 0008 movel %fp@(8),%sp@-
4d8b0: 4eb9 0004 d7a0 jsr 4d7a0 <rtems_rfs_inode_unload>
if ((rc == 0) && (handle->loads > 0))
4d8b6: 4fef 000c lea %sp@(12),%sp
4d8ba: 4a80 tstl %d0
4d8bc: 662e bnes 4d8ec <rtems_rfs_inode_close+0x76> <== NEVER TAKEN
4d8be: 4aaa 0022 tstl %a2@(34)
4d8c2: 6f28 bles 4d8ec <rtems_rfs_inode_close+0x76> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
4d8c4: 2f3c 0008 0000 movel #524288,%sp@- <== NOT EXECUTED
4d8ca: 42a7 clrl %sp@- <== NOT EXECUTED
4d8cc: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
4d8d2: 508f addql #8,%sp <== NOT EXECUTED
4d8d4: 4a00 tstb %d0 <== NOT EXECUTED
4d8d6: 6712 beqs 4d8ea <rtems_rfs_inode_close+0x74> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
4d8d8: 2f2a 0022 movel %a2@(34),%sp@- <== NOT EXECUTED
4d8dc: 4879 0006 ace4 pea 6ace4 <ramdisk_ops+0xafa> <== NOT EXECUTED
4d8e2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d8e8: 508f addql #8,%sp <== NOT EXECUTED
handle->loads);
rc = EIO;
4d8ea: 7005 moveq #5,%d0 <== NOT EXECUTED
}
handle->ino = 0;
4d8ec: 42aa 0008 clrl %a2@(8)
return rc;
}
4d8f0: 246e fffc moveal %fp@(-4),%a2
4d8f4: 4e5e unlk %fp <== NOT EXECUTED
0004dbd0 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
4dbd0: 4e56 ff88 linkw %fp,#-120
4dbd4: 302e 0026 movew %fp@(38),%d0
4dbd8: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
4dbdc: 2f3c 0040 0000 movel #4194304,%sp@-
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
4dbe2: 242e 0008 movel %fp@(8),%d2
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
4dbe6: 42a7 clrl %sp@-
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
4dbe8: 282e 000c movel %fp@(12),%d4
4dbec: 246e 0028 moveal %fp@(40),%a2
4dbf0: 3e2e 001a movew %fp@(26),%d7
4dbf4: 386e 001e moveaw %fp@(30),%a4
4dbf8: 3a6e 0022 moveaw %fp@(34),%a5
4dbfc: 3d40 ffb2 movew %d0,%fp@(-78)
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
4dc00: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4dc06: 508f addql #8,%sp
4dc08: 4a00 tstb %d0
4dc0a: 6700 00a6 beqw 4dcb2 <rtems_rfs_inode_create+0xe2>
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
4dc0e: 4285 clrl %d5 <== NOT EXECUTED
type = "dir";
4dc10: 263c 0006 8f81 movel #429953,%d3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
4dc16: 3a07 movew %d7,%d5 <== NOT EXECUTED
4dc18: 2005 movel %d5,%d0 <== NOT EXECUTED
4dc1a: 0280 0000 f000 andil #61440,%d0 <== NOT EXECUTED
4dc20: 0c80 0000 4000 cmpil #16384,%d0 <== NOT EXECUTED
4dc26: 673e beqs 4dc66 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
4dc28: 263c 0006 ad3e movel #437566,%d3 <== NOT EXECUTED
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
4dc2e: 0c80 0000 2000 cmpil #8192,%d0 <== NOT EXECUTED
4dc34: 6730 beqs 4dc66 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
4dc36: 263c 0006 a2d7 movel #434903,%d3 <== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
4dc3c: 0c80 0000 6000 cmpil #24576,%d0 <== NOT EXECUTED
4dc42: 6722 beqs 4dc66 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
4dc44: 263c 0006 8ef5 movel #429813,%d3 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
4dc4a: 0c80 0000 8000 cmpil #32768,%d0 <== NOT EXECUTED
4dc50: 6714 beqs 4dc66 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
4dc52: 263c 0006 cb24 movel #445220,%d3 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
4dc58: 0c80 0000 a000 cmpil #40960,%d0 <== NOT EXECUTED
4dc5e: 6706 beqs 4dc66 <rtems_rfs_inode_create+0x96> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
4dc60: 263c 0006 ad43 movel #437571,%d3 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
4dc66: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4dc68: 4879 0006 ad4b pea 6ad4b <ramdisk_ops+0xb61> <== NOT EXECUTED
for (c = 0; c < length; c++)
4dc6e: 4286 clrl %d6 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
4dc70: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4dc76: 266e 0010 moveal %fp@(16),%a3 <== NOT EXECUTED
for (c = 0; c < length; c++)
4dc7a: 508f addql #8,%sp <== NOT EXECUTED
4dc7c: 6010 bras 4dc8e <rtems_rfs_inode_create+0xbe> <== NOT EXECUTED
4dc7e: 5286 addql #1,%d6 <== NOT EXECUTED
printf ("%c", name[c]);
4dc80: 101b moveb %a3@+,%d0 <== NOT EXECUTED
4dc82: 49c0 extbl %d0 <== NOT EXECUTED
4dc84: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4dc86: 4eb9 0005 b358 jsr 5b358 <putchar> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
4dc8c: 588f addql #4,%sp <== NOT EXECUTED
4dc8e: bcae 0014 cmpl %fp@(20),%d6 <== NOT EXECUTED
4dc92: 66ea bnes 4dc7e <rtems_rfs_inode_create+0xae> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
4dc94: 2005 movel %d5,%d0 <== NOT EXECUTED
4dc96: 0280 0000 03ff andil #1023,%d0 <== NOT EXECUTED
4dc9c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4dc9e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4dca0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4dca2: 4879 0006 ad75 pea 6ad75 <ramdisk_ops+0xb8b> <== NOT EXECUTED
4dca8: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4dcae: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
4dcb2: 0287 0000 ffff andil #65535,%d7
4dcb8: 2a07 movel %d7,%d5
4dcba: 0285 0000 f000 andil #61440,%d5
4dcc0: 0c85 0000 6000 cmpil #24576,%d5
4dcc6: 6728 beqs 4dcf0 <rtems_rfs_inode_create+0x120> <== NEVER TAKEN
4dcc8: 6e14 bgts 4dcde <rtems_rfs_inode_create+0x10e>
4dcca: 0c85 0000 2000 cmpil #8192,%d5
4dcd0: 671e beqs 4dcf0 <rtems_rfs_inode_create+0x120> <== NEVER TAKEN
4dcd2: 0c85 0000 4000 cmpil #16384,%d5
4dcd8: 6600 01d8 bnew 4deb2 <rtems_rfs_inode_create+0x2e2>
4dcdc: 6012 bras 4dcf0 <rtems_rfs_inode_create+0x120>
4dcde: 0c85 0000 8000 cmpil #32768,%d5
4dce4: 670a beqs 4dcf0 <rtems_rfs_inode_create+0x120>
4dce6: 0c85 0000 a000 cmpil #40960,%d5
4dcec: 6600 01c4 bnew 4deb2 <rtems_rfs_inode_create+0x2e2>
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
4dcf0: 2f0a movel %a2,%sp@-
4dcf2: 2f04 movel %d4,%sp@-
4dcf4: 2f02 movel %d2,%sp@-
4dcf6: 4eb9 0004 d60c jsr 4d60c <rtems_rfs_inode_alloc>
if (rc > 0)
4dcfc: 4fef 000c lea %sp@(12),%sp
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
4dd00: 2600 movel %d0,%d3
if (rc > 0)
4dd02: 6e00 01b4 bgtw 4deb8 <rtems_rfs_inode_create+0x2e8>
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
4dd06: 4878 0001 pea 1 <ADD>
4dd0a: 2c0e movel %fp,%d6
4dd0c: 0686 ffff ffda addil #-38,%d6
4dd12: 2f06 movel %d6,%sp@-
4dd14: 2f12 movel %a2@,%sp@-
4dd16: 2f02 movel %d2,%sp@-
4dd18: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
4dd1e: 4fef 0010 lea %sp@(16),%sp
rc = rtems_rfs_inode_alloc (fs, parent, ino);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
4dd22: 2600 movel %d0,%d3
if (rc > 0)
4dd24: 6e00 017e bgtw 4dea4 <rtems_rfs_inode_create+0x2d4>
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
4dd28: 3f2e ffb2 movew %fp@(-78),%sp@-
4dd2c: 4267 clrw %sp@-
4dd2e: 3f0d movew %a5,%sp@-
4dd30: 4267 clrw %sp@-
4dd32: 2f07 movel %d7,%sp@-
4dd34: 3f0c movew %a4,%sp@-
4dd36: 4267 clrw %sp@-
4dd38: 2f06 movel %d6,%sp@-
4dd3a: 4eb9 0004 da76 jsr 4da76 <rtems_rfs_inode_initialise>
if (rc > 0)
4dd40: 4fef 0014 lea %sp@(20),%sp
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
4dd44: 2600 movel %d0,%d3
if (rc > 0)
4dd46: 6f18 bles 4dd60 <rtems_rfs_inode_create+0x190> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
4dd48: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4dd4a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4dd4c: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
4dd52: 2f12 movel %a2@,%sp@- <== NOT EXECUTED
4dd54: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4dd56: 4eb9 0004 d632 jsr 4d632 <rtems_rfs_inode_free> <== NOT EXECUTED
4dd5c: 6000 0134 braw 4de92 <rtems_rfs_inode_create+0x2c2> <== NOT EXECUTED
/*
* Only handle the specifics of a directory. Let caller handle the others.
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
4dd60: 0c85 0000 4000 cmpil #16384,%d5
4dd66: 663c bnes 4dda4 <rtems_rfs_inode_create+0x1d4>
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
4dd68: 2f12 movel %a2@,%sp@-
4dd6a: 47f9 0005 6758 lea 56758 <rtems_rfs_dir_add_entry>,%a3
4dd70: 4878 0001 pea 1 <ADD>
4dd74: 4879 0006 8e0a pea 68e0a <_rodata_start+0x1aa>
4dd7a: 2f06 movel %d6,%sp@-
4dd7c: 2f02 movel %d2,%sp@-
4dd7e: 4e93 jsr %a3@
if (rc == 0)
4dd80: 4fef 0014 lea %sp@(20),%sp
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
4dd84: 2600 movel %d0,%d3
if (rc == 0)
4dd86: 6618 bnes 4dda0 <rtems_rfs_inode_create+0x1d0>
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
4dd88: 2f04 movel %d4,%sp@-
4dd8a: 4878 0002 pea 2 <DOUBLE_FLOAT>
4dd8e: 4879 0006 8e09 pea 68e09 <_rodata_start+0x1a9>
4dd94: 2f06 movel %d6,%sp@-
4dd96: 2f02 movel %d2,%sp@-
4dd98: 4e93 jsr %a3@
4dd9a: 4fef 0014 lea %sp@(20),%sp
4dd9e: 2600 movel %d0,%d3
if (rc > 0)
4dda0: 4a83 tstl %d3
4dda2: 6e1c bgts 4ddc0 <rtems_rfs_inode_create+0x1f0>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4dda4: 4878 0001 pea 1 <ADD>
4dda8: 47ee ffb4 lea %fp@(-76),%a3
4ddac: 2f0b movel %a3,%sp@-
4ddae: 2f04 movel %d4,%sp@-
4ddb0: 2f02 movel %d2,%sp@-
4ddb2: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
4ddb8: 4fef 0010 lea %sp@(16),%sp
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
4ddbc: 2600 movel %d0,%d3
if (rc > 0)
4ddbe: 6f20 bles 4dde0 <rtems_rfs_inode_create+0x210> <== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
4ddc0: 280e movel %fp,%d4
4ddc2: 0684 ffff ffda addil #-38,%d4
4ddc8: 2f04 movel %d4,%sp@-
4ddca: 2f02 movel %d2,%sp@-
4ddcc: 4eb9 0004 d8f8 jsr 4d8f8 <rtems_rfs_inode_delete>
rtems_rfs_inode_close (fs, &inode);
4ddd2: 2f04 movel %d4,%sp@-
4ddd4: 2f02 movel %d2,%sp@-
4ddd6: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
4dddc: 6000 00b4 braw 4de92 <rtems_rfs_inode_create+0x2c2>
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
4dde0: 2f12 movel %a2@,%sp@-
4dde2: 2f2e 0014 movel %fp@(20),%sp@-
4dde6: 2f2e 0010 movel %fp@(16),%sp@-
4ddea: 2f0b movel %a3,%sp@-
4ddec: 2f02 movel %d2,%sp@-
4ddee: 4eb9 0005 6758 jsr 56758 <rtems_rfs_dir_add_entry>
if (rc > 0)
4ddf4: 4fef 0014 lea %sp@(20),%sp
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
4ddf8: 2600 movel %d0,%d3
if (rc > 0)
4ddfa: 6f2c bles 4de28 <rtems_rfs_inode_create+0x258> <== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
4ddfc: 280e movel %fp,%d4 <== NOT EXECUTED
4ddfe: 0684 ffff ffda addil #-38,%d4 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4de04: 45f9 0004 d876 lea 4d876 <rtems_rfs_inode_close>,%a2 <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
4de0a: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4de0c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4de0e: 4eb9 0004 d8f8 jsr 4d8f8 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4de14: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4de16: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4de18: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4de1a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4de1c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4de1e: 4e92 jsr %a2@ <== NOT EXECUTED
return rc;
4de20: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4de24: 6000 0092 braw 4deb8 <rtems_rfs_inode_create+0x2e8> <== NOT EXECUTED
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
4de28: 0c85 0000 4000 cmpil #16384,%d5
4de2e: 6636 bnes 4de66 <rtems_rfs_inode_create+0x296>
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
4de30: 206b 000c moveal %a3@(12),%a0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
4de34: 4280 clrl %d0
4de36: 1010 moveb %a0@,%d0
4de38: 4281 clrl %d1
4de3a: 1228 0001 moveb %a0@(1),%d1
4de3e: e188 lsll #8,%d0
4de40: 8081 orl %d1,%d0
if (links == 0xffff)
4de42: 3200 movew %d0,%d1
links = 0;
4de44: 0c81 0000 ffff cmpil #65535,%d1
4de4a: 56c1 sne %d1
4de4c: 4881 extw %d1
4de4e: c081 andl %d1,%d0
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
4de50: 5280 addql #1,%d0
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
4de52: 2200 movel %d0,%d1
4de54: e089 lsrl #8,%d1
4de56: 1081 moveb %d1,%a0@
4de58: 206e ffc0 moveal %fp@(-64),%a0
4de5c: 1140 0001 moveb %d0,%a0@(1)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4de60: 7001 moveq #1,%d0
4de62: 1d40 ffc4 moveb %d0,%fp@(-60)
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
4de66: 486e ffb4 pea %fp@(-76)
4de6a: 47f9 0004 d876 lea 4d876 <rtems_rfs_inode_close>,%a3
4de70: 280e movel %fp,%d4
4de72: 0684 ffff ffda addil #-38,%d4
4de78: 2f02 movel %d2,%sp@-
4de7a: 4e93 jsr %a3@
if (rc > 0)
4de7c: 508f addql #8,%sp
*/
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
4de7e: 2600 movel %d0,%d3
if (rc > 0)
4de80: 6f16 bles 4de98 <rtems_rfs_inode_create+0x2c8> <== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
4de82: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4de84: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4de86: 4eb9 0004 d8f8 jsr 4d8f8 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4de8c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4de8e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4de90: 4e93 jsr %a3@ <== NOT EXECUTED
return rc;
4de92: 4fef 0010 lea %sp@(16),%sp
4de96: 6020 bras 4deb8 <rtems_rfs_inode_create+0x2e8>
}
rc = rtems_rfs_inode_close (fs, &inode);
4de98: 2f04 movel %d4,%sp@-
4de9a: 2f02 movel %d2,%sp@-
4de9c: 4e93 jsr %a3@
if (rc > 0)
4de9e: 508f addql #8,%sp
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
4dea0: 2600 movel %d0,%d3
if (rc > 0)
4dea2: 6f12 bles 4deb6 <rtems_rfs_inode_create+0x2e6> <== ALWAYS TAKEN
{
rtems_rfs_inode_free (fs, *ino);
4dea4: 2f12 movel %a2@,%sp@- <== NOT EXECUTED
4dea6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4dea8: 4eb9 0004 d632 jsr 4d632 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
4deae: 508f addql #8,%sp <== NOT EXECUTED
4deb0: 6006 bras 4deb8 <rtems_rfs_inode_create+0x2e8> <== NOT EXECUTED
case RTEMS_RFS_S_IFBLK:
case RTEMS_RFS_S_IFREG:
case RTEMS_RFS_S_IFLNK:
break;
default:
return EINVAL;
4deb2: 7616 moveq #22,%d3 <== NOT EXECUTED
4deb4: 6002 bras 4deb8 <rtems_rfs_inode_create+0x2e8> <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
4deb6: 4283 clrl %d3
}
4deb8: 2003 movel %d3,%d0
4deba: 4cee 3cfc ff88 moveml %fp@(-120),%d2-%d7/%a2-%a5
4dec0: 4e5e unlk %fp <== NOT EXECUTED
0004d8f8 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d8f8: 4e56 ffa8 linkw %fp,#-88
4d8fc: 48d7 040c moveml %d2-%d3/%a2,%sp@
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
4d900: 2f3c 0080 0000 movel #8388608,%sp@-
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d906: 242e 0008 movel %fp@(8),%d2
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
4d90a: 42a7 clrl %sp@-
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d90c: 246e 000c moveal %fp@(12),%a2
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
4d910: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d916: 508f addql #8,%sp
4d918: 4a00 tstb %d0
4d91a: 6728 beqs 4d944 <rtems_rfs_inode_delete+0x4c> <== ALWAYS TAKEN
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
4d91c: 203c 0006 b028 movel #438312,%d0 <== NOT EXECUTED
4d922: 4aaa 000c tstl %a2@(12) <== NOT EXECUTED
4d926: 6706 beqs 4d92e <rtems_rfs_inode_delete+0x36> <== NOT EXECUTED
4d928: 203c 0006 ac35 movel #437301,%d0 <== NOT EXECUTED
4d92e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d930: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4d934: 4879 0006 ad12 pea 6ad12 <ramdisk_ops+0xb28> <== NOT EXECUTED
4d93a: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d940: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
4d944: 4aaa 000c tstl %a2@(12)
4d948: 6774 beqs 4d9be <rtems_rfs_inode_delete+0xc6> <== NEVER TAKEN
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
4d94a: 2f2a 0008 movel %a2@(8),%sp@-
4d94e: 2f02 movel %d2,%sp@-
4d950: 4eb9 0004 d632 jsr 4d632 <rtems_rfs_inode_free>
if (rc > 0)
4d956: 508f addql #8,%sp
4d958: 4a80 tstl %d0
4d95a: 6e64 bgts 4d9c0 <rtems_rfs_inode_delete+0xc8> <== NEVER TAKEN
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
4d95c: 260e movel %fp,%d3
4d95e: 0683 ffff ffb6 addil #-74,%d3
4d964: 2f03 movel %d3,%sp@-
4d966: 2f0a movel %a2,%sp@-
4d968: 2f02 movel %d2,%sp@-
4d96a: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open>
if (rc == 0)
4d970: 4fef 000c lea %sp@(12),%sp
4d974: 4a80 tstl %d0
4d976: 6648 bnes 4d9c0 <rtems_rfs_inode_delete+0xc8> <== NEVER TAKEN
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
4d978: 2f03 movel %d3,%sp@-
4d97a: 2f02 movel %d2,%sp@-
4d97c: 4eb9 0005 5a0c jsr 55a0c <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
4d982: 2f03 movel %d3,%sp@-
4d984: 2f02 movel %d2,%sp@-
4d986: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close>
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
4d98c: 4878 0038 pea 38 <DBL_MANT_DIG+0x3>
4d990: 4878 00ff pea ff <DBL_MANT_DIG+0xca>
4d994: 2f2a 000c movel %a2@(12),%sp@-
4d998: 4eb9 0005 b28c jsr 5b28c <memset>
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4d99e: 7001 moveq #1,%d0
4d9a0: 1540 0010 moveb %d0,%a2@(16)
/*
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
4d9a4: 486a 0010 pea %a2@(16)
4d9a8: 2f02 movel %d2,%sp@-
4d9aa: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
handle->loads = 0;
handle->node = NULL;
4d9b0: 4fef 0024 lea %sp@(36),%sp
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
handle->loads = 0;
4d9b4: 42aa 0022 clrl %a2@(34)
handle->node = NULL;
4d9b8: 42aa 000c clrl %a2@(12)
4d9bc: 6002 bras 4d9c0 <rtems_rfs_inode_delete+0xc8>
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
int rc = 0;
4d9be: 4280 clrl %d0 <== NOT EXECUTED
handle->loads = 0;
handle->node = NULL;
}
}
return rc;
}
4d9c0: 4cee 040c ffa8 moveml %fp@(-88),%d2-%d3/%a2
4d9c6: 4e5e unlk %fp <== NOT EXECUTED
00059494 <rtems_rfs_inode_get_block.isra.0>:
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
59494: 4280 clrl %d0 <== NOT EXECUTED
* @param handle The inode handle.
* @param block The block number to return.
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
59496: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
5949a: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
5949e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
594a0: 7618 moveq #24,%d3 <== NOT EXECUTED
* @param handle The inode handle.
* @param block The block number to return.
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
594a2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
594a4: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
594a8: 2202 movel %d2,%d1 <== NOT EXECUTED
594aa: 1431 2c1c moveb %a1@(0000001c,%d2:l:4),%d2 <== NOT EXECUTED
594ae: e589 lsll #2,%d1 <== NOT EXECUTED
594b0: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
594b6: 1031 181f moveb %a1@(0000001f,%d1:l),%d0 <== NOT EXECUTED
594ba: e7aa lsll %d3,%d2 <== NOT EXECUTED
594bc: 8082 orl %d2,%d0 <== NOT EXECUTED
594be: 4282 clrl %d2 <== NOT EXECUTED
594c0: 1431 181d moveb %a1@(0000001d,%d1:l),%d2 <== NOT EXECUTED
594c4: 1231 181e moveb %a1@(0000001e,%d1:l),%d1 <== NOT EXECUTED
594c8: 4842 swap %d2 <== NOT EXECUTED
594ca: 4242 clrw %d2 <== NOT EXECUTED
594cc: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
594d2: 8082 orl %d2,%d0 <== NOT EXECUTED
}
594d4: 241f movel %sp@+,%d2 <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
594d6: e189 lsll #8,%d1 <== NOT EXECUTED
}
594d8: 261f movel %sp@+,%d3 <== NOT EXECUTED
594da: 4e5e unlk %fp <== NOT EXECUTED
594dc: 8081 orl %d1,%d0 <== NOT EXECUTED
0004e0b0 <rtems_rfs_inode_get_block.isra.9>:
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4e0b0: 4280 clrl %d0 <== NOT EXECUTED
* @param handle The inode handle.
* @param block The block number to return.
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
4e0b2: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
4e0b6: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
4e0ba: 2f03 movel %d3,%sp@- <== NOT EXECUTED
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4e0bc: 7618 moveq #24,%d3 <== NOT EXECUTED
* @param handle The inode handle.
* @param block The block number to return.
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
4e0be: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e0c0: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4e0c4: 2202 movel %d2,%d1 <== NOT EXECUTED
4e0c6: 1431 2c1c moveb %a1@(0000001c,%d2:l:4),%d2 <== NOT EXECUTED
4e0ca: e589 lsll #2,%d1 <== NOT EXECUTED
4e0cc: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
4e0d2: 1031 181f moveb %a1@(0000001f,%d1:l),%d0 <== NOT EXECUTED
4e0d6: e7aa lsll %d3,%d2 <== NOT EXECUTED
4e0d8: 8082 orl %d2,%d0 <== NOT EXECUTED
4e0da: 4282 clrl %d2 <== NOT EXECUTED
4e0dc: 1431 181d moveb %a1@(0000001d,%d1:l),%d2 <== NOT EXECUTED
4e0e0: 1231 181e moveb %a1@(0000001e,%d1:l),%d1 <== NOT EXECUTED
4e0e4: 4842 swap %d2 <== NOT EXECUTED
4e0e6: 4242 clrw %d2 <== NOT EXECUTED
4e0e8: 0281 0000 00ff andil #255,%d1 <== NOT EXECUTED
4e0ee: 8082 orl %d2,%d0 <== NOT EXECUTED
}
4e0f0: 241f movel %sp@+,%d2 <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4e0f2: e189 lsll #8,%d1 <== NOT EXECUTED
}
4e0f4: 261f movel %sp@+,%d3 <== NOT EXECUTED
4e0f6: 4e5e unlk %fp <== NOT EXECUTED
4e0f8: 8081 orl %d1,%d0 <== NOT EXECUTED
0004d64c <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
4d64c: 4e56 0000 linkw %fp,#0
4d650: 2f0a movel %a2,%sp@-
4d652: 246e 000c moveal %fp@(12),%a2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
4d656: 2f3c 0010 0000 movel #1048576,%sp@-
4d65c: 42a7 clrl %sp@-
4d65e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d664: 508f addql #8,%sp
4d666: 4a00 tstb %d0
4d668: 672c beqs 4d696 <rtems_rfs_inode_load+0x4a> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
4d66a: 203c 0006 b028 movel #438312,%d0 <== NOT EXECUTED
4d670: 4aaa 000c tstl %a2@(12) <== NOT EXECUTED
4d674: 6706 beqs 4d67c <rtems_rfs_inode_load+0x30> <== NOT EXECUTED
4d676: 203c 0006 ac35 movel #437301,%d0 <== NOT EXECUTED
4d67c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d67e: 2f2a 0022 movel %a2@(34),%sp@- <== NOT EXECUTED
4d682: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4d686: 4879 0006 ac39 pea 6ac39 <ramdisk_ops+0xa4f> <== NOT EXECUTED
4d68c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d692: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
4d696: 4aaa 000c tstl %a2@(12)
4d69a: 6636 bnes 4d6d2 <rtems_rfs_inode_load+0x86>
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
4d69c: 4878 0001 pea 1 <ADD>
4d6a0: 2f2a 001a movel %a2@(26),%sp@-
4d6a4: 486a 0010 pea %a2@(16)
4d6a8: 2f2e 0008 movel %fp@(8),%sp@-
4d6ac: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request>
handle->block, true);
if (rc > 0)
4d6b2: 4fef 0010 lea %sp@(16),%sp
4d6b6: 4a80 tstl %d0
4d6b8: 6e1e bgts 4d6d8 <rtems_rfs_inode_load+0x8c> <== NEVER TAKEN
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
4d6ba: 202a 001e movel %a2@(30),%d0
4d6be: 2200 movel %d0,%d1
4d6c0: ed88 lsll #6,%d0
4d6c2: e789 lsll #3,%d1
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
handle->block, true);
if (rc > 0)
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
4d6c4: 206a 0016 moveal %a2@(22),%a0
handle->node += handle->offset;
4d6c8: 9081 subl %d1,%d0
4d6ca: d0a8 001e addl %a0@(30),%d0
4d6ce: 2540 000c movel %d0,%a2@(12)
}
handle->loads++;
4d6d2: 52aa 0022 addql #1,%a2@(34)
return 0;
4d6d6: 4280 clrl %d0
}
4d6d8: 246e fffc moveal %fp@(-4),%a2
4d6dc: 4e5e unlk %fp <== NOT EXECUTED
0004d6e0 <rtems_rfs_inode_open>:
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
4d6e0: 4e56 fff0 linkw %fp,#-16
4d6e4: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
4d6e8: 2f3c 0004 0000 movel #262144,%sp@-
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
4d6ee: 266e 0008 moveal %fp@(8),%a3
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
4d6f2: 42a7 clrl %sp@-
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
4d6f4: 242e 000c movel %fp@(12),%d2
4d6f8: 246e 0010 moveal %fp@(16),%a2
4d6fc: 162e 0017 moveb %fp@(23),%d3
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
4d700: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d706: 508f addql #8,%sp
4d708: 4a00 tstb %d0
4d70a: 6710 beqs 4d71c <rtems_rfs_inode_open+0x3c> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
4d70c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4d70e: 4879 0006 ac6c pea 6ac6c <ramdisk_ops+0xa82> <== NOT EXECUTED
4d714: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d71a: 508f addql #8,%sp <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
4d71c: 4a82 tstl %d2
4d71e: 6774 beqs 4d794 <rtems_rfs_inode_open+0xb4> <== NEVER TAKEN
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
4d720: 2002 movel %d2,%d0
4d722: 5380 subql #1,%d0
4d724: b0ab 0010 cmpl %a3@(16),%d0
4d728: 626a bhis 4d794 <rtems_rfs_inode_open+0xb4> <== NEVER TAKEN
return EINVAL;
handle->ino = ino;
4d72a: 2542 0008 movel %d2,%a2@(8)
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4d72e: 206b 001c moveal %a3@(28),%a0
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
4d732: 42aa 000c clrl %a2@(12)
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
4d736: 4c6b 0001 0028 remul %a3@(40),%d1,%d0
4d73c: 4c6b 0000 0028 remul %a3@(40),%d0,%d0
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
4d742: 42aa 0022 clrl %a2@(34)
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
4d746: 4c6b 1002 002c remul %a3@(44),%d2,%d1
4d74c: 4c6b 1001 002c remul %a3@(44),%d1,%d1
4d752: 2542 001e movel %d2,%a2@(30)
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4d756: 744c moveq #76,%d2
4d758: 4c02 0800 mulsl %d2,%d0
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
4d75c: 2070 0800 moveal %a0@(00000000,%d0:l),%a0
4d760: 5488 addql #2,%a0
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
4d762: d1c1 addal %d1,%a0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4d764: 4200 clrb %d0
4d766: 2548 001a movel %a0,%a2@(26)
4d76a: 1540 0010 moveb %d0,%a2@(16)
handle->bnum = 0;
4d76e: 42aa 0012 clrl %a2@(18)
handle->buffer = NULL;
4d772: 42aa 0016 clrl %a2@(22)
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
4d776: 4a03 tstb %d3
4d778: 6716 beqs 4d790 <rtems_rfs_inode_open+0xb0> <== NEVER TAKEN
rc = rtems_rfs_inode_load (fs, handle);
4d77a: 2d4a 000c movel %a2,%fp@(12)
4d77e: 2d4b 0008 movel %a3,%fp@(8)
return rc;
}
4d782: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
4d788: 4e5e unlk %fp
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
4d78a: 4ef9 0004 d64c jmp 4d64c <rtems_rfs_inode_load>
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
4d790: 4280 clrl %d0 <== NOT EXECUTED
4d792: 6002 bras 4d796 <rtems_rfs_inode_open+0xb6> <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
4d794: 7016 moveq #22,%d0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
return rc;
}
4d796: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3 <== NOT EXECUTED
4d79c: 4e5e unlk %fp <== NOT EXECUTED
0004c52a <rtems_rfs_inode_overhead>:
/**
* Return the inode overhead given a number of inodes.
*/
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
4c52a: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
4c52e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4c530: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
4c534: 2f02 movel %d2,%sp@- <== NOT EXECUTED
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
4c536: 242a 0008 movel %a2@(8),%d2 <== NOT EXECUTED
4c53a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4c53c: 202a 0028 movel %a2@(40),%d0 <== NOT EXECUTED
4c540: 2200 movel %d0,%d1 <== NOT EXECUTED
4c542: ed88 lsll #6,%d0 <== NOT EXECUTED
4c544: e789 lsll #3,%d1 <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4c546: e78a lsll #3,%d2 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
4c548: 9081 subl %d1,%d0 <== NOT EXECUTED
4c54a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4c54c: 4eb9 0004 c506 jsr 4c506 <rtems_rfs_rup_quotient> <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
4c552: 222a 0004 movel %a2@(4),%d1 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
4c556: 508f addql #8,%sp <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
4c558: 5381 subql #1,%d1 <== NOT EXECUTED
4c55a: b282 cmpl %d2,%d1 <== NOT EXECUTED
4c55c: 6402 bccs 4c560 <rtems_rfs_inode_overhead+0x36> <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
4c55e: 2401 movel %d1,%d2 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
4c560: 223c 0000 03e8 movel #1000,%d1 <== NOT EXECUTED
4c566: 5280 addql #1,%d0 <== NOT EXECUTED
4c568: 4c01 0800 mulsl %d1,%d0 <== NOT EXECUTED
}
4c56c: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
4c570: 4c42 0800 remsl %d2,%d0,%d0 <== NOT EXECUTED
4c574: 242e fff8 movel %fp@(-8),%d2 <== NOT EXECUTED
4c578: 4e5e unlk %fp <== NOT EXECUTED
0004df20 <rtems_rfs_inode_set_block>:
* @param block The block index.
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
4df20: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
4df24: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
4df28: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4df2a: 202e 0010 movel %fp@(16),%d0 <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
4df2e: 7618 moveq #24,%d3 <== NOT EXECUTED
* @param block The block index.
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
4df30: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
4df32: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
4df36: 2400 movel %d0,%d2 <== NOT EXECUTED
4df38: e6aa lsrl %d3,%d2 <== NOT EXECUTED
* @param block The block index.
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
4df3a: 222e 000c movel %fp@(12),%d1 <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
4df3e: 1382 1c1c moveb %d2,%a1@(0000001c,%d1:l:4) <== NOT EXECUTED
4df42: 2400 movel %d0,%d2 <== NOT EXECUTED
4df44: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
4df48: e589 lsll #2,%d1 <== NOT EXECUTED
4df4a: 4242 clrw %d2 <== NOT EXECUTED
4df4c: 4842 swap %d2 <== NOT EXECUTED
4df4e: 1382 181d moveb %d2,%a1@(0000001d,%d1:l) <== NOT EXECUTED
4df52: 2400 movel %d0,%d2 <== NOT EXECUTED
4df54: e08a lsrl #8,%d2 <== NOT EXECUTED
4df56: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
4df5a: 1382 181e moveb %d2,%a1@(0000001e,%d1:l) <== NOT EXECUTED
4df5e: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
4df62: 1380 181f moveb %d0,%a1@(0000001f,%d1:l) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4df66: 7001 moveq #1,%d0 <== NOT EXECUTED
}
4df68: 241f movel %sp@+,%d2 <== NOT EXECUTED
4df6a: 261f movel %sp@+,%d3 <== NOT EXECUTED
4df6c: 4e5e unlk %fp <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4df6e: 1140 0010 moveb %d0,%a0@(16) <== NOT EXECUTED
}
0004d9ca <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
4d9ca: 4e56 fff4 linkw %fp,#-12
4d9ce: 48d7 040c moveml %d2-%d3/%a2,%sp@
4d9d2: 246e 0008 moveal %fp@(8),%a2
4d9d6: 162e 000f moveb %fp@(15),%d3
4d9da: 142e 0013 moveb %fp@(19),%d2
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
4d9de: 4aaa 000c tstl %a2@(12)
4d9e2: 6700 0082 beqw 4da66 <rtems_rfs_inode_time_stamp_now+0x9c>
return ENXIO;
now = time (NULL);
4d9e6: 42a7 clrl %sp@-
4d9e8: 4eb9 0005 e53c jsr 5e53c <time>
if (atime)
4d9ee: 588f addql #4,%sp
4d9f0: 4a03 tstb %d3
4d9f2: 6736 beqs 4da2a <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4d9f4: 206a 000c moveal %a2@(12),%a0
4d9f8: 2200 movel %d0,%d1
4d9fa: 7618 moveq #24,%d3
4d9fc: e6a9 lsrl %d3,%d1
4d9fe: 1141 0010 moveb %d1,%a0@(16)
4da02: 2200 movel %d0,%d1
4da04: 206a 000c moveal %a2@(12),%a0
4da08: 4241 clrw %d1
4da0a: 4841 swap %d1
4da0c: 1141 0011 moveb %d1,%a0@(17)
4da10: 2200 movel %d0,%d1
4da12: e089 lsrl #8,%d1
4da14: 206a 000c moveal %a2@(12),%a0
4da18: 1141 0012 moveb %d1,%a0@(18)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4da1c: 7201 moveq #1,%d1
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4da1e: 206a 000c moveal %a2@(12),%a0
4da22: 1140 0013 moveb %d0,%a0@(19)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4da26: 1541 0010 moveb %d1,%a2@(16)
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
4da2a: 4a02 tstb %d2
4da2c: 673c beqs 4da6a <rtems_rfs_inode_time_stamp_now+0xa0><== NEVER TAKEN
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4da2e: 206a 000c moveal %a2@(12),%a0
4da32: 2200 movel %d0,%d1
4da34: 7418 moveq #24,%d2
4da36: e4a9 lsrl %d2,%d1
4da38: 1141 0014 moveb %d1,%a0@(20)
4da3c: 2200 movel %d0,%d1
4da3e: 206a 000c moveal %a2@(12),%a0
4da42: 4241 clrw %d1
4da44: 4841 swap %d1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4da46: 7601 moveq #1,%d3
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4da48: 1141 0015 moveb %d1,%a0@(21)
4da4c: 2200 movel %d0,%d1
4da4e: e089 lsrl #8,%d1
4da50: 206a 000c moveal %a2@(12),%a0
4da54: 1141 0016 moveb %d1,%a0@(22)
4da58: 206a 000c moveal %a2@(12),%a0
4da5c: 1140 0017 moveb %d0,%a0@(23)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4da60: 1543 0010 moveb %d3,%a2@(16)
4da64: 6004 bras 4da6a <rtems_rfs_inode_time_stamp_now+0xa0>
bool atime,
bool mtime)
{
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
return ENXIO;
4da66: 7006 moveq #6,%d0 <== NOT EXECUTED
4da68: 6002 bras 4da6c <rtems_rfs_inode_time_stamp_now+0xa2><== NOT EXECUTED
now = time (NULL);
if (atime)
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
rtems_rfs_inode_set_mtime (handle, now);
return 0;
4da6a: 4280 clrl %d0
}
4da6c: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
4da72: 4e5e unlk %fp <== NOT EXECUTED
0004d7a0 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
4d7a0: 4e56 0000 linkw %fp,#0
4d7a4: 2f0a movel %a2,%sp@-
4d7a6: 246e 000c moveal %fp@(12),%a2
4d7aa: 2f02 movel %d2,%sp@-
4d7ac: 142e 0013 moveb %fp@(19),%d2
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
4d7b0: 2f3c 0020 0000 movel #2097152,%sp@-
4d7b6: 42a7 clrl %sp@-
4d7b8: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
4d7be: 508f addql #8,%sp
4d7c0: 4a00 tstb %d0
4d7c2: 672c beqs 4d7f0 <rtems_rfs_inode_unload+0x50> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
4d7c4: 203c 0006 b028 movel #438312,%d0 <== NOT EXECUTED
4d7ca: 4aaa 000c tstl %a2@(12) <== NOT EXECUTED
4d7ce: 6706 beqs 4d7d6 <rtems_rfs_inode_unload+0x36> <== NOT EXECUTED
4d7d0: 203c 0006 ac35 movel #437301,%d0 <== NOT EXECUTED
4d7d6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4d7d8: 2f2a 0022 movel %a2@(34),%sp@- <== NOT EXECUTED
4d7dc: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
4d7e0: 4879 0006 ac8d pea 6ac8d <ramdisk_ops+0xaa3> <== NOT EXECUTED
4d7e6: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4d7ec: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
4d7f0: 4aaa 000c tstl %a2@(12)
4d7f4: 6772 beqs 4d868 <rtems_rfs_inode_unload+0xc8>
{
if (handle->loads == 0)
4d7f6: 202a 0022 movel %a2@(34),%d0
4d7fa: 6768 beqs 4d864 <rtems_rfs_inode_unload+0xc4> <== NEVER TAKEN
return EIO;
handle->loads--;
4d7fc: 5380 subql #1,%d0
4d7fe: 2540 0022 movel %d0,%a2@(34)
if (handle->loads == 0)
4d802: 6664 bnes 4d868 <rtems_rfs_inode_unload+0xc8>
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
4d804: 4a2a 0010 tstb %a2@(16)
4d808: 6744 beqs 4d84e <rtems_rfs_inode_unload+0xae>
4d80a: 4a02 tstb %d2
4d80c: 6740 beqs 4d84e <rtems_rfs_inode_unload+0xae> <== NEVER TAKEN
rtems_rfs_inode_set_ctime (handle, time (NULL));
4d80e: 42a7 clrl %sp@-
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
4d810: 7418 moveq #24,%d2
4d812: 4eb9 0005 e53c jsr 5e53c <time>
4d818: 206a 000c moveal %a2@(12),%a0
4d81c: 2200 movel %d0,%d1
4d81e: e4a9 lsrl %d2,%d1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4d820: 588f addql #4,%sp
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
4d822: 1141 0018 moveb %d1,%a0@(24)
4d826: 2200 movel %d0,%d1
4d828: 206a 000c moveal %a2@(12),%a0
4d82c: 4241 clrw %d1
4d82e: 4841 swap %d1
4d830: 1141 0019 moveb %d1,%a0@(25)
4d834: 2200 movel %d0,%d1
4d836: e089 lsrl #8,%d1
4d838: 206a 000c moveal %a2@(12),%a0
4d83c: 1141 001a moveb %d1,%a0@(26)
4d840: 206a 000c moveal %a2@(12),%a0
4d844: 1140 001b moveb %d0,%a0@(27)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4d848: 7001 moveq #1,%d0
4d84a: 1540 0010 moveb %d0,%a2@(16)
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
4d84e: 486a 0010 pea %a2@(16)
4d852: 2f2e 0008 movel %fp@(8),%sp@-
4d856: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release>
handle->node = NULL;
4d85c: 508f addql #8,%sp
4d85e: 42aa 000c clrl %a2@(12)
4d862: 6006 bras 4d86a <rtems_rfs_inode_unload+0xca>
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
4d864: 7005 moveq #5,%d0 <== NOT EXECUTED
4d866: 6002 bras 4d86a <rtems_rfs_inode_unload+0xca> <== NOT EXECUTED
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
4d868: 4280 clrl %d0
handle->node = NULL;
}
}
return rc;
}
4d86a: 242e fff8 movel %fp@(-8),%d2
4d86e: 246e fffc moveal %fp@(-4),%a2
4d872: 4e5e unlk %fp <== NOT EXECUTED
0005889c <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
5889c: 4e56 ff90 linkw %fp,#-112
588a0: 48d7 1cfc moveml %d2-%d7/%a2-%a4,%sp@
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
588a4: 2f3c 0100 0000 movel #16777216,%sp@-
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
588aa: 262e 0008 movel %fp@(8),%d3
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
588ae: 42a7 clrl %sp@-
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
588b0: 2a2e 000c movel %fp@(12),%d5
588b4: 2c2e 0010 movel %fp@(16),%d6
588b8: 2e2e 0014 movel %fp@(20),%d7
588bc: 246e 0018 moveal %fp@(24),%a2
588c0: 182e 001f moveb %fp@(31),%d4
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
588c4: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
588ca: 508f addql #8,%sp
588cc: 4a00 tstb %d0
588ce: 673c beqs 5890c <rtems_rfs_link+0x70> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
588d0: 2f07 movel %d7,%sp@- <== NOT EXECUTED
588d2: 4879 0006 c500 pea 6c500 <CSWTCH.1+0x125a> <== NOT EXECUTED
588d8: 2645 moveal %d5,%a3 <== NOT EXECUTED
for (c = 0; c < length; c++)
588da: 4282 clrl %d2 <== NOT EXECUTED
printf ("%c", name[c]);
588dc: 49f9 0005 b358 lea 5b358 <putchar>,%a4 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
588e2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
588e8: 508f addql #8,%sp <== NOT EXECUTED
588ea: 600c bras 588f8 <rtems_rfs_link+0x5c> <== NOT EXECUTED
588ec: 5282 addql #1,%d2 <== NOT EXECUTED
printf ("%c", name[c]);
588ee: 101b moveb %a3@+,%d0 <== NOT EXECUTED
588f0: 49c0 extbl %d0 <== NOT EXECUTED
588f2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
588f4: 4e94 jsr %a4@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
for (c = 0; c < length; c++)
588f6: 588f addql #4,%sp <== NOT EXECUTED
588f8: bc82 cmpl %d2,%d6 <== NOT EXECUTED
588fa: 6ef0 bgts 588ec <rtems_rfs_link+0x50> <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
588fc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
588fe: 4879 0006 c545 pea 6c545 <CSWTCH.1+0x129f> <== NOT EXECUTED
58904: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5890a: 508f addql #8,%sp <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
5890c: 4878 0001 pea 1 <ADD>
58910: 47ee ffda lea %fp@(-38),%a3
58914: 2f0b movel %a3,%sp@-
58916: 2f0a movel %a2,%sp@-
58918: 2f03 movel %d3,%sp@-
5891a: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc)
58920: 4fef 0010 lea %sp@(16),%sp
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
58924: 2400 movel %d0,%d2
if (rc)
58926: 6600 0116 bnew 58a3e <rtems_rfs_link+0x1a2>
/*
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
5892a: 4a04 tstb %d4
5892c: 662e bnes 5895c <rtems_rfs_link+0xc0> <== NEVER TAKEN
5892e: 206e ffe6 moveal %fp@(-26),%a0
58932: 4280 clrl %d0
58934: 1028 0002 moveb %a0@(2),%d0
58938: e188 lsll #8,%d0
5893a: 0280 0000 f000 andil #61440,%d0
58940: 0c80 0000 4000 cmpil #16384,%d0
58946: 6614 bnes 5895c <rtems_rfs_link+0xc0> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
58948: 2f0b movel %a3,%sp@- <== NOT EXECUTED
return ENOTSUP;
5894a: 143c ff86 moveb #-122,%d2 <== NOT EXECUTED
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
{
rtems_rfs_inode_close (fs, &target_inode);
5894e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58950: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
return ENOTSUP;
58956: 508f addql #8,%sp <== NOT EXECUTED
58958: 6000 00e4 braw 58a3e <rtems_rfs_link+0x1a2> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
5895c: 4878 0001 pea 1 <ADD>
58960: 280e movel %fp,%d4
58962: 0684 ffff ffb4 addil #-76,%d4
58968: 2f04 movel %d4,%sp@-
5896a: 2f07 movel %d7,%sp@-
5896c: 2f03 movel %d3,%sp@-
5896e: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc)
58974: 4fef 0010 lea %sp@(16),%sp
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
58978: 2400 movel %d0,%d2
if (rc)
5897a: 6710 beqs 5898c <rtems_rfs_link+0xf0> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
5897c: 486e ffda pea %fp@(-38) <== NOT EXECUTED
58980: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58982: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
58988: 6000 00b2 braw 58a3c <rtems_rfs_link+0x1a0> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
5898c: 2f0a movel %a2,%sp@-
5898e: 2f06 movel %d6,%sp@-
58990: 2f05 movel %d5,%sp@-
58992: 2f04 movel %d4,%sp@-
58994: 2f03 movel %d3,%sp@-
58996: 4eb9 0005 6758 jsr 56758 <rtems_rfs_dir_add_entry>
if (rc > 0)
5899c: 4fef 0014 lea %sp@(20),%sp
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
589a0: 2400 movel %d0,%d2
if (rc > 0)
589a2: 6f12 bles 589b6 <rtems_rfs_link+0x11a> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &parent_inode);
589a4: 2f04 movel %d4,%sp@- <== NOT EXECUTED
589a6: 45f9 0004 d876 lea 4d876 <rtems_rfs_inode_close>,%a2 <== NOT EXECUTED
589ac: 2f03 movel %d3,%sp@- <== NOT EXECUTED
589ae: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
589b0: 486e ffda pea %fp@(-38) <== NOT EXECUTED
589b4: 6060 bras 58a16 <rtems_rfs_link+0x17a> <== NOT EXECUTED
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
589b6: 47ee ffda lea %fp@(-38),%a3
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
589ba: 4280 clrl %d0
589bc: 4281 clrl %d1
589be: 45f9 0004 d876 lea 4d876 <rtems_rfs_inode_close>,%a2
589c4: 206b 000c moveal %a3@(12),%a0
589c8: 1010 moveb %a0@,%d0
589ca: 1228 0001 moveb %a0@(1),%d1
589ce: e188 lsll #8,%d0
589d0: 8081 orl %d1,%d0
if (links == 0xffff)
589d2: 3200 movew %d0,%d1
links = 0;
589d4: 0c81 0000 ffff cmpil #65535,%d1
589da: 56c1 sne %d1
589dc: 4881 extw %d1
589de: c081 andl %d1,%d0
589e0: 5280 addql #1,%d0
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
589e2: 2200 movel %d0,%d1
589e4: e089 lsrl #8,%d1
589e6: 1081 moveb %d1,%a0@
589e8: 206e ffe6 moveal %fp@(-26),%a0
589ec: 1140 0001 moveb %d0,%a0@(1)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
589f0: 7001 moveq #1,%d0
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
589f2: 4878 0001 pea 1 <ADD>
589f6: 4878 0001 pea 1 <ADD>
589fa: 1d40 ffea moveb %d0,%fp@(-22)
589fe: 2f04 movel %d4,%sp@-
58a00: 4eb9 0004 d9ca jsr 4d9ca <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
58a06: 4fef 000c lea %sp@(12),%sp
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
58a0a: 2400 movel %d0,%d2
if (rc > 0)
58a0c: 6f12 bles 58a20 <rtems_rfs_link+0x184> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &parent_inode);
58a0e: 2f04 movel %d4,%sp@- <== NOT EXECUTED
58a10: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58a12: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
58a14: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58a16: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58a18: 4e92 jsr %a2@ <== NOT EXECUTED
return rc;
58a1a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58a1e: 601e bras 58a3e <rtems_rfs_link+0x1a2> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
58a20: 2f04 movel %d4,%sp@-
58a22: 2f03 movel %d3,%sp@-
58a24: 4e92 jsr %a2@
if (rc > 0)
58a26: 508f addql #8,%sp
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
58a28: 2400 movel %d0,%d2
if (rc > 0)
58a2a: 6f08 bles 58a34 <rtems_rfs_link+0x198> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
58a2c: 2f0b movel %a3,%sp@- <== NOT EXECUTED
58a2e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58a30: 4e92 jsr %a2@ <== NOT EXECUTED
58a32: 6008 bras 58a3c <rtems_rfs_link+0x1a0> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
58a34: 2f0b movel %a3,%sp@-
58a36: 2f03 movel %d3,%sp@-
58a38: 4e92 jsr %a2@
58a3a: 2400 movel %d0,%d2
return rc;
58a3c: 508f addql #8,%sp
}
58a3e: 2002 movel %d2,%d0
58a40: 4cee 1cfc ff90 moveml %fp@(-112),%d2-%d7/%a2-%a4
58a46: 4e5e unlk %fp <== NOT EXECUTED
00059210 <rtems_rfs_mutex_create>:
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
59210: 4e56 0000 linkw %fp,#0
59214: 2f02 movel %d2,%sp@-
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
59216: 2f2e 0008 movel %fp@(8),%sp@-
5921a: 42a7 clrl %sp@-
5921c: 4878 0024 pea 24 <OPER2+0x10>
59220: 4878 0001 pea 1 <ADD>
59224: 2f3c 5246 536d movel #1380340589,%sp@-
5922a: 4eb9 0004 8cd4 jsr 48cd4 <rtems_semaphore_create>
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
59230: 4fef 0014 lea %sp@(20),%sp
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
59234: 2400 movel %d0,%d2
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
59236: 672e beqs 59266 <rtems_rfs_mutex_create+0x56> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
59238: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
5923c: 42a7 clrl %sp@- <== NOT EXECUTED
5923e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
59244: 508f addql #8,%sp <== NOT EXECUTED
59246: 4a00 tstb %d0 <== NOT EXECUTED
59248: 6720 beqs 5926a <rtems_rfs_mutex_create+0x5a> <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
5924a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5924c: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
59252: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59254: 4879 0006 c71e pea 6c71e <CSWTCH.1+0x1478> <== NOT EXECUTED
5925a: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
59260: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
59264: 6004 bras 5926a <rtems_rfs_mutex_create+0x5a> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
59266: 4280 clrl %d0
59268: 6002 bras 5926c <rtems_rfs_mutex_create+0x5c>
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
5926a: 7005 moveq #5,%d0 <== NOT EXECUTED
}
#endif
return 0;
}
5926c: 242e fffc movel %fp@(-4),%d2
59270: 4e5e unlk %fp <== NOT EXECUTED
00059274 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
59274: 4e56 0000 linkw %fp,#0
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
59278: 206e 0008 moveal %fp@(8),%a0
return 0;
}
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
5927c: 2f02 movel %d2,%sp@-
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
5927e: 2f10 movel %a0@,%sp@-
59280: 4eb9 0004 8e74 jsr 48e74 <rtems_semaphore_delete>
if (sc != RTEMS_SUCCESSFUL)
59286: 588f addql #4,%sp
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
59288: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
5928a: 672e beqs 592ba <rtems_rfs_mutex_destroy+0x46> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
5928c: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
59290: 42a7 clrl %sp@- <== NOT EXECUTED
59292: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
59298: 508f addql #8,%sp <== NOT EXECUTED
5929a: 4a00 tstb %d0 <== NOT EXECUTED
5929c: 6720 beqs 592be <rtems_rfs_mutex_destroy+0x4a> <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
5929e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
592a0: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
592a6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
592a8: 4879 0006 c741 pea 6c741 <CSWTCH.1+0x149b> <== NOT EXECUTED
592ae: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
592b4: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
592b8: 6004 bras 592be <rtems_rfs_mutex_destroy+0x4a> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
592ba: 4280 clrl %d0
592bc: 6002 bras 592c0 <rtems_rfs_mutex_destroy+0x4c>
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
592be: 7005 moveq #5,%d0 <== NOT EXECUTED
}
#endif
return 0;
}
592c0: 242e fffc movel %fp@(-4),%d2
592c4: 4e5e unlk %fp <== NOT EXECUTED
0004e0fc <rtems_rfs_mutex_lock.isra.15>:
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
4e0fc: 4e56 0000 linkw %fp,#0
4e100: 2f02 movel %d2,%sp@-
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4e102: 42a7 clrl %sp@-
4e104: 42a7 clrl %sp@-
4e106: 2f2e 0008 movel %fp@(8),%sp@-
4e10a: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
4e110: 4fef 000c lea %sp@(12),%sp
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4e114: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
4e116: 672e beqs 4e146 <rtems_rfs_mutex_lock.isra.15+0x4a><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4e118: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4e11c: 42a7 clrl %sp@- <== NOT EXECUTED
4e11e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
4e124: 508f addql #8,%sp <== NOT EXECUTED
4e126: 4a00 tstb %d0 <== NOT EXECUTED
4e128: 6720 beqs 4e14a <rtems_rfs_mutex_lock.isra.15+0x4e><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4e12a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e12c: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
4e132: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4e134: 4879 0006 adb6 pea 6adb6 <ramdisk_ops+0xbcc> <== NOT EXECUTED
4e13a: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4e140: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4e144: 6004 bras 4e14a <rtems_rfs_mutex_lock.isra.15+0x4e><== NOT EXECUTED
rtems_status_text (sc));
#endif
return EIO;
}
#endif
return 0;
4e146: 4280 clrl %d0
4e148: 6002 bras 4e14c <rtems_rfs_mutex_lock.isra.15+0x50>
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: obtain failed: %s\n",
rtems_status_text (sc));
#endif
return EIO;
4e14a: 7005 moveq #5,%d0 <== NOT EXECUTED
}
#endif
return 0;
}
4e14c: 242e fffc movel %fp@(-4),%d2
4e150: 4e5e unlk %fp <== NOT EXECUTED
00055a28 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
55a28: 4e56 ffe4 linkw %fp,#-28
55a2c: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55a30: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
55a34: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55a38: 42a7 clrl %sp@-
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
55a3a: 266e 000c moveal %fp@(12),%a3
55a3e: 162e 0013 moveb %fp@(19),%d3
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55a42: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55a48: 508f addql #8,%sp
55a4a: 4a00 tstb %d0
55a4c: 6710 beqs 55a5e <rtems_rfs_release_chain+0x36> <== ALWAYS TAKEN
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
55a4e: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
55a50: 4879 0006 b39a pea 6b39a <CSWTCH.1+0xf4> <== NOT EXECUTED
55a56: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55a5c: 508f addql #8,%sp <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
55a5e: 280a movel %a2,%d4
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
55a60: 4282 clrl %d2
55a62: 5884 addql #4,%d4
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
55a64: 4bf9 0004 9a0c lea 49a0c <_Chain_Get>,%a5
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
55a6a: 49f9 0005 a58a lea 5a58a <rtems_rfs_buffer_bdbuf_release>,%a4
55a70: 0283 0000 00ff andil #255,%d3
55a76: 6020 bras 55a98 <rtems_rfs_release_chain+0x70>
55a78: 2f0a movel %a2,%sp@-
55a7a: 4e95 jsr %a5@
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
55a7c: 5393 subql #1,%a3@
buffer->user = (void*) 0;
55a7e: 2040 moveal %d0,%a0
55a80: 42a8 0036 clrl %a0@(54)
rc = rtems_rfs_buffer_io_release (buffer, modified);
55a84: 2f03 movel %d3,%sp@-
55a86: 2f00 movel %d0,%sp@-
55a88: 4e94 jsr %a4@
if ((rc > 0) && (rrc == 0))
55a8a: 4fef 000c lea %sp@(12),%sp
55a8e: 4a80 tstl %d0
55a90: 6f06 bles 55a98 <rtems_rfs_release_chain+0x70> <== ALWAYS TAKEN
55a92: 4a82 tstl %d2 <== NOT EXECUTED
55a94: 6602 bnes 55a98 <rtems_rfs_release_chain+0x70> <== NOT EXECUTED
55a96: 2400 movel %d0,%d2 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
55a98: b892 cmpl %a2@,%d4
55a9a: 66dc bnes 55a78 <rtems_rfs_release_chain+0x50>
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
55a9c: 2002 movel %d2,%d0
55a9e: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
55aa4: 4e5e unlk %fp <== NOT EXECUTED
0004e5ea <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
4e5ea: 4e56 ffc4 linkw %fp,#-60
4e5ee: 206e 0008 moveal %fp@(8),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e5f2: 2268 0010 moveal %a0@(16),%a1
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
4e5f6: 48d7 043c moveml %d2-%d5/%a2,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e5fa: 2810 movel %a0@,%d4
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e5fc: 240e movel %fp,%d2
4e5fe: 0682 ffff ffda addil #-38,%d2
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e604: 2469 0034 moveal %a1@(52),%a2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
4e608: 2f2a 007c movel %a2@(124),%sp@-
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
4e60c: 362e 000e movew %fp@(14),%d3
4e610: 3a2e 0012 movew %fp@(18),%d5
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
4e614: 4eba fc0c jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e618: 4878 0001 pea 1 <ADD>
4e61c: 2f02 movel %d2,%sp@-
4e61e: 2f04 movel %d4,%sp@-
4e620: 2f0a movel %a2,%sp@-
4e622: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
4e628: 4fef 0014 lea %sp@(20),%sp
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e62c: 2800 movel %d0,%d4
if (rc > 0)
4e62e: 6f12 bles 4e642 <rtems_rfs_rtems_chown+0x58> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e630: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e632: 4eba f9d0 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: opening inode", rc);
4e636: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e63c: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e63e: 2084 movel %d4,%a0@ <== NOT EXECUTED
4e640: 6060 bras 4e6a2 <rtems_rfs_rtems_chown+0xb8> <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
4e642: 4280 clrl %d0
4e644: 7218 moveq #24,%d1
4e646: 3003 movew %d3,%d0
4e648: 4845 swap %d5
4e64a: 4245 clrw %d5
4e64c: 206e ffe6 moveal %fp@(-26),%a0
4e650: 8a80 orl %d0,%d5
4e652: 2005 movel %d5,%d0
4e654: e2a8 lsrl %d1,%d0
4e656: 1140 0004 moveb %d0,%a0@(4)
4e65a: 2005 movel %d5,%d0
4e65c: e08d lsrl #8,%d5
4e65e: 206e ffe6 moveal %fp@(-26),%a0
4e662: 4240 clrw %d0
4e664: 4840 swap %d0
4e666: 1140 0005 moveb %d0,%a0@(5)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4e66a: 7001 moveq #1,%d0
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
4e66c: 206e ffe6 moveal %fp@(-26),%a0
4e670: 1145 0006 moveb %d5,%a0@(6)
4e674: 206e ffe6 moveal %fp@(-26),%a0
4e678: 1143 0007 moveb %d3,%a0@(7)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4e67c: 1d40 ffea moveb %d0,%fp@(-22)
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
4e680: 2f02 movel %d2,%sp@-
4e682: 2f0a movel %a2,%sp@-
4e684: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
if (rc)
4e68a: 508f addql #8,%sp
4e68c: 41fa f976 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
4e690: 2400 movel %d0,%d2
if (rc)
4e692: 6714 beqs 4e6a8 <rtems_rfs_rtems_chown+0xbe> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e694: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e696: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: closing inode", rc);
4e698: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e69e: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e6a0: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e6a2: 588f addql #4,%sp <== NOT EXECUTED
4e6a4: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e6a6: 6008 bras 4e6b0 <rtems_rfs_rtems_chown+0xc6> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e6a8: 2f0a movel %a2,%sp@-
4e6aa: 4e90 jsr %a0@
return 0;
4e6ac: 588f addql #4,%sp
4e6ae: 4280 clrl %d0
}
4e6b0: 4cee 043c ffc4 moveml %fp@(-60),%d2-%d5/%a2
4e6b6: 4e5e unlk %fp <== NOT EXECUTED
00059400 <rtems_rfs_rtems_device_close>:
* @return int
*/
static int
rtems_rfs_rtems_device_close (rtems_libio_t* iop)
{
59400: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED
59404: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
59408: 2028 0030 movel %a0@(48),%d0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
5940c: 2228 0034 movel %a0@(52),%d1 <== NOT EXECUTED
args.iop = iop;
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
59410: 486e fff4 pea %fp@(-12) <== NOT EXECUTED
59414: 2f01 movel %d1,%sp@- <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
59416: 2d48 fff4 movel %a0,%fp@(-12) <== NOT EXECUTED
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
5941a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
5941c: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
args.mode = 0;
59420: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
status = rtems_io_close (major, minor, (void *) &args);
59424: 4eb9 0005 a2d8 jsr 5a2d8 <rtems_io_close> <== NOT EXECUTED
return rtems_deviceio_errno (status);
5942a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5942c: 4eb9 0005 9de4 jsr 59de4 <rtems_deviceio_errno> <== NOT EXECUTED
}
59432: 4e5e unlk %fp <== NOT EXECUTED
000592d8 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
{
return 0;
}
592d8: 4280 clrl %d0 <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
{
592da: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return 0;
}
592de: 4e5e unlk %fp <== NOT EXECUTED
000592e2 <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
uint32_t command,
void* buffer)
{
592e2: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
592e6: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
rtems_libio_ioctl_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
592ea: 2028 0030 movel %a0@(48),%d0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
592ee: 2228 0034 movel %a0@(52),%d1 <== NOT EXECUTED
args.iop = iop;
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
592f2: 486e fff0 pea %fp@(-16) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.command = command;
592f6: 2d6e 000c fff4 movel %fp@(12),%fp@(-12) <== NOT EXECUTED
args.buffer = buffer;
592fc: 2d6e 0010 fff8 movel %fp@(16),%fp@(-8) <== NOT EXECUTED
status = rtems_io_control (major, minor, (void *) &args);
59302: 2f01 movel %d1,%sp@- <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
59304: 2d48 fff0 movel %a0,%fp@(-16) <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
59308: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5930a: 4eb9 0005 a31c jsr 5a31c <rtems_io_control> <== NOT EXECUTED
if (status)
59310: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
59314: 4a80 tstl %d0 <== NOT EXECUTED
59316: 670c beqs 59324 <rtems_rfs_rtems_device_ioctl+0x42><== NOT EXECUTED
return rtems_deviceio_errno (status);
59318: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5931a: 4eb9 0005 9de4 jsr 59de4 <rtems_deviceio_errno> <== NOT EXECUTED
59320: 588f addql #4,%sp <== NOT EXECUTED
59322: 6004 bras 59328 <rtems_rfs_rtems_device_ioctl+0x46><== NOT EXECUTED
return args.ioctl_return;
59324: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
}
59328: 4e5e unlk %fp <== NOT EXECUTED
000592c8 <rtems_rfs_rtems_device_lseek>:
static rtems_off64_t
rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
592c8: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return offset;
}
592cc: 202e 000c movel %fp@(12),%d0 <== NOT EXECUTED
592d0: 222e 0010 movel %fp@(16),%d1 <== NOT EXECUTED
592d4: 4e5e unlk %fp <== NOT EXECUTED
000594e0 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
594e0: 4e56 ffb4 linkw %fp,#-76 <== NOT EXECUTED
594e4: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@ <== NOT EXECUTED
594e8: 246e 0008 moveal %fp@(8),%a2 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
594ec: 206a 0028 moveal %a2@(40),%a0 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
594f0: 262a 0018 movel %a2@(24),%d3 <== NOT EXECUTED
const char *pathname,
uint32_t flag,
uint32_t mode)
{
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
594f4: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
594f8: 42a7 clrl %sp@- <== NOT EXECUTED
594fa: 42a7 clrl %sp@- <== NOT EXECUTED
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_filesystem_default_fsync,
.fdatasync_h = rtems_filesystem_default_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
594fc: 206b 007c moveal %a3@(124),%a0 <== NOT EXECUTED
59500: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
59502: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
59508: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
5950c: 2400 movel %d0,%d2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
5950e: 672c beqs 5953c <rtems_rfs_rtems_device_open+0x5c><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
59510: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
59514: 42a7 clrl %sp@- <== NOT EXECUTED
59516: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5951c: 508f addql #8,%sp <== NOT EXECUTED
5951e: 4a00 tstb %d0 <== NOT EXECUTED
59520: 671a beqs 5953c <rtems_rfs_rtems_device_open+0x5c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
59522: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59524: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
5952a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5952c: 4879 0006 adb6 pea 6adb6 <ramdisk_ops+0xbcc> <== NOT EXECUTED
59532: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
59538: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
5953c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
59540: 49ee ffce lea %fp@(-50),%a4 <== NOT EXECUTED
59544: 2f0c movel %a4,%sp@- <== NOT EXECUTED
59546: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59548: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5954a: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
59550: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
59554: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
59556: 6f12 bles 5956a <rtems_rfs_rtems_device_open+0x8a><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
59558: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5955a: 4eba feda jsr %pc@(59436 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
5955e: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59564: 2040 moveal %d0,%a0 <== NOT EXECUTED
59566: 2082 movel %d2,%a0@ <== NOT EXECUTED
59568: 6042 bras 595ac <rtems_rfs_rtems_device_open+0xcc><== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
5956a: 262c 000c movel %a4@(12),%d3 <== NOT EXECUTED
5956e: 4bfa ff24 lea %pc@(59494 <rtems_rfs_inode_get_block.isra.0>),%a5<== NOT EXECUTED
59572: 42a7 clrl %sp@- <== NOT EXECUTED
59574: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59576: 4e95 jsr %a5@ <== NOT EXECUTED
59578: 508f addql #8,%sp <== NOT EXECUTED
5957a: 2400 movel %d0,%d2 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
5957c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
59580: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59582: 4e95 jsr %a5@ <== NOT EXECUTED
59584: 508f addql #8,%sp <== NOT EXECUTED
59586: 2600 movel %d0,%d3 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
59588: 2f0c movel %a4,%sp@- <== NOT EXECUTED
5958a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5958c: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
59592: 508f addql #8,%sp <== NOT EXECUTED
59594: 41fa fea0 lea %pc@(59436 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
rc = rtems_rfs_inode_close (fs, &inode);
59598: 2840 moveal %d0,%a4 <== NOT EXECUTED
if (rc > 0)
5959a: 4a80 tstl %d0 <== NOT EXECUTED
5959c: 6f14 bles 595b2 <rtems_rfs_rtems_device_open+0xd2><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
5959e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
595a0: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
595a2: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
595a8: 2040 moveal %d0,%a0 <== NOT EXECUTED
595aa: 208c movel %a4,%a0@ <== NOT EXECUTED
595ac: 588f addql #4,%sp <== NOT EXECUTED
595ae: 70ff moveq #-1,%d0 <== NOT EXECUTED
595b0: 6036 bras 595e8 <rtems_rfs_rtems_device_open+0x108><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
595b2: 2f0b movel %a3,%sp@- <== NOT EXECUTED
595b4: 4e90 jsr %a0@ <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
595b6: 2d6a 0014 fff8 movel %a2@(20),%fp@(-8) <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
595bc: 2542 0030 movel %d2,%a2@(48) <== NOT EXECUTED
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
595c0: 2d6e 0014 fffc movel %fp@(20),%fp@(-4) <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
595c6: 2543 0034 movel %d3,%a2@(52) <== NOT EXECUTED
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
595ca: 486e fff4 pea %fp@(-12) <== NOT EXECUTED
595ce: 2f03 movel %d3,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
595d0: 2d4a fff4 movel %a2,%fp@(-12) <== NOT EXECUTED
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
595d4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
595d6: 4eb9 0005 a360 jsr 5a360 <rtems_io_open> <== NOT EXECUTED
return rtems_deviceio_errno (status);
595dc: 2f00 movel %d0,%sp@- <== NOT EXECUTED
595de: 4eb9 0005 9de4 jsr 59de4 <rtems_deviceio_errno> <== NOT EXECUTED
595e4: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
}
595e8: 4cee 3c0c ffb4 moveml %fp@(-76),%d2-%d3/%a2-%a5 <== NOT EXECUTED
595ee: 4e5e unlk %fp <== NOT EXECUTED
...
00059396 <rtems_rfs_rtems_device_read>:
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
59396: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
5939a: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
5939e: 2d68 0014 fff8 movel %a0@(20),%fp@(-8) <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
593a4: 2028 0030 movel %a0@(48),%d0 <== NOT EXECUTED
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
593a8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
593aa: 2228 0034 movel %a0@(52),%d1 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
593ae: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
593b2: 2468 0010 moveal %a0@(16),%a2 <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
593b6: 486e ffe4 pea %fp@(-28) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
593ba: 2d6e 000c fff0 movel %fp@(12),%fp@(-16) <== NOT EXECUTED
args.count = count;
593c0: 2d6e 0010 fff4 movel %fp@(16),%fp@(-12) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
593c6: 2d49 ffe8 movel %a1,%fp@(-24) <== NOT EXECUTED
593ca: 2d4a ffec movel %a2,%fp@(-20) <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
593ce: 2f01 movel %d1,%sp@- <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
593d0: 2d48 ffe4 movel %a0,%fp@(-28) <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
593d4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
593d6: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
status = rtems_io_read (major, minor, (void *) &args);
593da: 4eb9 0005 a3a4 jsr 5a3a4 <rtems_io_read> <== NOT EXECUTED
if (status)
593e0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
593e4: 4a80 tstl %d0 <== NOT EXECUTED
593e6: 670c beqs 593f4 <rtems_rfs_rtems_device_read+0x5e><== NOT EXECUTED
return rtems_deviceio_errno (status);
593e8: 2f00 movel %d0,%sp@- <== NOT EXECUTED
593ea: 4eb9 0005 9de4 jsr 59de4 <rtems_deviceio_errno> <== NOT EXECUTED
593f0: 588f addql #4,%sp <== NOT EXECUTED
593f2: 6004 bras 593f8 <rtems_rfs_rtems_device_read+0x62><== NOT EXECUTED
return (ssize_t) args.bytes_moved;
593f4: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
}
593f8: 246e ffe0 moveal %fp@(-32),%a2 <== NOT EXECUTED
593fc: 4e5e unlk %fp <== NOT EXECUTED
0005932c <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
5932c: 4e56 ffe4 linkw %fp,#-28 <== NOT EXECUTED
59330: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
59334: 2d68 0014 fff8 movel %a0@(20),%fp@(-8) <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
5933a: 2028 0030 movel %a0@(48),%d0 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
5933e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
59340: 2228 0034 movel %a0@(52),%d1 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
59344: 2268 000c moveal %a0@(12),%a1 <== NOT EXECUTED
59348: 2468 0010 moveal %a0@(16),%a2 <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
5934c: 486e ffe4 pea %fp@(-28) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
59350: 2d6e 000c fff0 movel %fp@(12),%fp@(-16) <== NOT EXECUTED
args.count = count;
59356: 2d6e 0010 fff4 movel %fp@(16),%fp@(-12) <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
5935c: 2d49 ffe8 movel %a1,%fp@(-24) <== NOT EXECUTED
59360: 2d4a ffec movel %a2,%fp@(-20) <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
59364: 2f01 movel %d1,%sp@- <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
59366: 2d48 ffe4 movel %a0,%fp@(-28) <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
5936a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
5936c: 42ae fffc clrl %fp@(-4) <== NOT EXECUTED
status = rtems_io_write (major, minor, (void *) &args);
59370: 4eb9 0005 a3e8 jsr 5a3e8 <rtems_io_write> <== NOT EXECUTED
if (status)
59376: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
5937a: 4a80 tstl %d0 <== NOT EXECUTED
5937c: 670c beqs 5938a <rtems_rfs_rtems_device_write+0x5e><== NOT EXECUTED
return rtems_deviceio_errno (status);
5937e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
59380: 4eb9 0005 9de4 jsr 59de4 <rtems_deviceio_errno> <== NOT EXECUTED
59386: 588f addql #4,%sp <== NOT EXECUTED
59388: 6004 bras 5938e <rtems_rfs_rtems_device_write+0x62><== NOT EXECUTED
return (ssize_t) args.bytes_moved;
5938a: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
}
5938e: 246e ffe0 moveal %fp@(-32),%a2 <== NOT EXECUTED
59392: 4e5e unlk %fp <== NOT EXECUTED
0005965c <rtems_rfs_rtems_dir_lseek>:
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
switch (whence)
5965c: 7001 moveq #1,%d0 <== NOT EXECUTED
*/
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
5965e: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
switch (whence)
59662: b0ae 0014 cmpl %fp@(20),%d0 <== NOT EXECUTED
59666: 6412 bccs 5967a <rtems_rfs_rtems_dir_lseek+0x1e> <== NOT EXECUTED
break;
case SEEK_END: /* Movement past the end of the directory via lseek */
/* is not a permitted operation */
default:
return rtems_rfs_rtems_error ("dir_lseek: bad whence", EINVAL);
59668: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
5966e: 2040 moveal %d0,%a0 <== NOT EXECUTED
59670: 7016 moveq #22,%d0 <== NOT EXECUTED
59672: 2080 movel %d0,%a0@ <== NOT EXECUTED
59674: 70ff moveq #-1,%d0 <== NOT EXECUTED
59676: 72ff moveq #-1,%d1 <== NOT EXECUTED
59678: 6004 bras 5967e <rtems_rfs_rtems_dir_lseek+0x22> <== NOT EXECUTED
break;
}
return 0;
5967a: 4280 clrl %d0 <== NOT EXECUTED
5967c: 4281 clrl %d1 <== NOT EXECUTED
}
5967e: 4e5e unlk %fp <== NOT EXECUTED
000597d0 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
597d0: 4e56 ffc8 linkw %fp,#-56
597d4: 48d7 1c04 moveml %d2/%a2-%a4,%sp@
597d8: 286e 0008 moveal %fp@(8),%a4
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
597dc: 47ee ffda lea %fp@(-38),%a3
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
597e0: 206c 0028 moveal %a4@(40),%a0
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
597e4: 242c 0018 movel %a4@(24),%d2
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
597e8: 2468 0034 moveal %a0@(52),%a2
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
597ec: 2f2a 007c movel %a2@(124),%sp@-
597f0: 4eba fe90 jsr %pc@(59682 <rtems_rfs_rtems_lock.isra.3>)
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
597f4: 4878 0001 pea 1 <ADD>
597f8: 2f0b movel %a3,%sp@-
597fa: 2f02 movel %d2,%sp@-
597fc: 2f0a movel %a2,%sp@-
597fe: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc)
59804: 4fef 0014 lea %sp@(20),%sp
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
59808: 2400 movel %d0,%d2
if (rc)
5980a: 6714 beqs 59820 <rtems_rfs_rtems_dir_open+0x50> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
5980c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5980e: 4eba fdee jsr %pc@(595fe <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
59812: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59818: 588f addql #4,%sp <== NOT EXECUTED
5981a: 2040 moveal %d0,%a0 <== NOT EXECUTED
5981c: 2082 movel %d2,%a0@ <== NOT EXECUTED
5981e: 603a bras 5985a <rtems_rfs_rtems_dir_open+0x8a> <== NOT EXECUTED
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
59820: 206b 000c moveal %a3@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
59824: 4280 clrl %d0
59826: 1028 0002 moveb %a0@(2),%d0
5982a: e188 lsll #8,%d0
5982c: 0280 0000 f000 andil #61440,%d0
59832: 0c80 0000 4000 cmpil #16384,%d0
59838: 6724 beqs 5985e <rtems_rfs_rtems_dir_open+0x8e> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
5983a: 2f0b movel %a3,%sp@- <== NOT EXECUTED
5983c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5983e: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
59844: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59846: 4eba fdb6 jsr %pc@(595fe <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
5984a: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59850: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
59854: 7214 moveq #20,%d1 <== NOT EXECUTED
59856: 2040 moveal %d0,%a0 <== NOT EXECUTED
59858: 2081 movel %d1,%a0@ <== NOT EXECUTED
5985a: 70ff moveq #-1,%d0 <== NOT EXECUTED
5985c: 6022 bras 59880 <rtems_rfs_rtems_dir_open+0xb0> <== NOT EXECUTED
}
iop->offset = 0;
5985e: 4280 clrl %d0
59860: 4281 clrl %d1
59862: 2940 000c movel %d0,%a4@(12)
59866: 2941 0010 movel %d1,%a4@(16)
rtems_rfs_inode_close (fs, &inode);
5986a: 2f0b movel %a3,%sp@-
5986c: 2f0a movel %a2,%sp@-
5986e: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
59874: 2f0a movel %a2,%sp@-
59876: 4eba fd86 jsr %pc@(595fe <rtems_rfs_rtems_unlock>)
return 0;
5987a: 4fef 000c lea %sp@(12),%sp
5987e: 4280 clrl %d0
}
59880: 4cee 1c04 ffc8 moveml %fp@(-56),%d2/%a2-%a4
59886: 4e5e unlk %fp <== NOT EXECUTED
000596d4 <rtems_rfs_rtems_dir_read>:
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
596d4: 223c 0000 0110 movel #272,%d1 <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
596da: 4e56 ffa4 linkw %fp,#-92 <== NOT EXECUTED
596de: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
596e2: 266e 0008 moveal %fp@(8),%a3 <== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
596e6: 2a0e movel %fp,%d5 <== NOT EXECUTED
596e8: 0685 ffff ffd6 addil #-42,%d5 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
596ee: 206b 0028 moveal %a3@(40),%a0 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
596f2: 242b 0018 movel %a3@(24),%d2 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
596f6: 2468 0034 moveal %a0@(52),%a2 <== NOT EXECUTED
int rc;
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
596fa: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
596fe: 2e2e 0010 movel %fp@(16),%d7 <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
59702: 2a6e 000c moveal %fp@(12),%a5 <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
59706: 4c41 7007 remul %d1,%d7,%d7 <== NOT EXECUTED
dirent = buffer;
rtems_rfs_rtems_lock (fs);
5970a: 4eba ff76 jsr %pc@(59682 <rtems_rfs_rtems_lock.isra.3>)<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
5970e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
59712: 2f05 movel %d5,%sp@- <== NOT EXECUTED
59714: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59716: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59718: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
5971e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
59722: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
59724: 660e bnes 59734 <rtems_rfs_rtems_dir_read+0x60> <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
59726: 2c0e movel %fp,%d6 <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
59728: 4284 clrl %d4 <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
5972a: 5986 subql #4,%d6 <== NOT EXECUTED
5972c: 49f9 0005 6e24 lea 56e24 <rtems_rfs_dir_read>,%a4 <== NOT EXECUTED
59732: 6072 bras 597a6 <rtems_rfs_rtems_dir_read+0xd2> <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
59734: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59736: 4eba fec6 jsr %pc@(595fe <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
5973a: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59740: 588f addql #4,%sp <== NOT EXECUTED
59742: 2040 moveal %d0,%a0 <== NOT EXECUTED
59744: 2082 movel %d2,%a0@ <== NOT EXECUTED
59746: 74ff moveq #-1,%d2 <== NOT EXECUTED
59748: 607a bras 597c4 <rtems_rfs_rtems_dir_read+0xf0> <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
5974a: 2f06 movel %d6,%sp@- <== NOT EXECUTED
5974c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
5974e: 2f2b 0010 movel %a3@(16),%sp@- <== NOT EXECUTED
59752: 2f2b 000c movel %a3@(12),%sp@- <== NOT EXECUTED
59756: 2f05 movel %d5,%sp@- <== NOT EXECUTED
59758: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5975a: 4e94 jsr %a4@ <== NOT EXECUTED
if (rc == ENOENT)
5975c: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
59760: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc == ENOENT)
59762: 7002 moveq #2,%d0 <== NOT EXECUTED
59764: b083 cmpl %d3,%d0 <== NOT EXECUTED
59766: 6746 beqs 597ae <rtems_rfs_rtems_dir_read+0xda> <== NOT EXECUTED
{
rc = 0;
break;
}
if (rc > 0)
59768: 4a83 tstl %d3 <== NOT EXECUTED
5976a: 6f0e bles 5977a <rtems_rfs_rtems_dir_read+0xa6> <== NOT EXECUTED
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
5976c: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59772: 74ff moveq #-1,%d2 <== NOT EXECUTED
59774: 2040 moveal %d0,%a0 <== NOT EXECUTED
59776: 2083 movel %d3,%a0@ <== NOT EXECUTED
59778: 6034 bras 597ae <rtems_rfs_rtems_dir_read+0xda> <== NOT EXECUTED
break;
}
iop->offset += size;
5977a: 202e fffc movel %fp@(-4),%d0 <== NOT EXECUTED
5977e: 91c8 subal %a0,%a0 <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
59780: 0682 0000 0110 addil #272,%d2 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
59786: 5284 addql #1,%d4 <== NOT EXECUTED
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
59788: 2d40 ffd0 movel %d0,%fp@(-48) <== NOT EXECUTED
5978c: 2d48 ffcc movel %a0,%fp@(-52) <== NOT EXECUTED
59790: 202e ffcc movel %fp@(-52),%d0 <== NOT EXECUTED
59794: 222e ffd0 movel %fp@(-48),%d1 <== NOT EXECUTED
59798: d3ab 0010 addl %d1,%a3@(16) <== NOT EXECUTED
5979c: 262b 000c movel %a3@(12),%d3 <== NOT EXECUTED
597a0: d780 addxl %d0,%d3 <== NOT EXECUTED
597a2: 2743 000c movel %d3,%a3@(12) <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
597a6: 200d movel %a5,%d0 <== NOT EXECUTED
597a8: d082 addl %d2,%d0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
597aa: be84 cmpl %d4,%d7 <== NOT EXECUTED
597ac: 669c bnes 5974a <rtems_rfs_rtems_dir_read+0x76> <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
597ae: 486e ffd6 pea %fp@(-42) <== NOT EXECUTED
597b2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
597b4: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
597ba: 2f0a movel %a2,%sp@- <== NOT EXECUTED
597bc: 4eba fe40 jsr %pc@(595fe <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return bytes_transferred;
597c0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
597c4: 2002 movel %d2,%d0 <== NOT EXECUTED
597c6: 4cee 3cfc ffa4 moveml %fp@(-92),%d2-%d7/%a2-%a5 <== NOT EXECUTED
597cc: 4e5e unlk %fp <== NOT EXECUTED
0005988a <rtems_rfs_rtems_dir_rmnod>:
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
5988a: 7001 moveq #1,%d0 <== NOT EXECUTED
}
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
5988c: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
59890: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
59894: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
}
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
59898: 48d7 041c moveml %d2-%d4/%a2,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
5989c: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
598a0: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
598a4: 2410 movel %a0@,%d2 <== NOT EXECUTED
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
598a6: 2611 movel %a1@,%d3 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
598a8: 2828 0004 movel %a0@(4),%d4 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
598ac: b082 cmpl %d2,%d0 <== NOT EXECUTED
598ae: 660e bnes 598be <rtems_rfs_rtems_dir_rmnod+0x34> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
598b0: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
598b6: 7410 moveq #16,%d2 <== NOT EXECUTED
598b8: 2040 moveal %d0,%a0 <== NOT EXECUTED
598ba: 2082 movel %d2,%a0@ <== NOT EXECUTED
598bc: 6036 bras 598f4 <rtems_rfs_rtems_dir_rmnod+0x6a> <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
598be: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
598c2: 4eba fdbe jsr %pc@(59682 <rtems_rfs_rtems_lock.isra.3>)<== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
598c6: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
598ca: 2f04 movel %d4,%sp@- <== NOT EXECUTED
598cc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
598ce: 2f03 movel %d3,%sp@- <== NOT EXECUTED
598d0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
598d2: 4eb9 0005 8a4a jsr 58a4a <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
598d8: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
598dc: 41fa fd20 lea %pc@(595fe <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
if (ino == RTEMS_RFS_ROOT_INO)
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
598e0: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
598e2: 6714 beqs 598f8 <rtems_rfs_rtems_dir_rmnod+0x6e> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
598e4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
598e6: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
598e8: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
598ee: 588f addql #4,%sp <== NOT EXECUTED
598f0: 2040 moveal %d0,%a0 <== NOT EXECUTED
598f2: 2082 movel %d2,%a0@ <== NOT EXECUTED
598f4: 70ff moveq #-1,%d0 <== NOT EXECUTED
598f6: 6008 bras 59900 <rtems_rfs_rtems_dir_rmnod+0x76> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
598f8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
598fa: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
598fc: 588f addql #4,%sp <== NOT EXECUTED
598fe: 4280 clrl %d0 <== NOT EXECUTED
}
59900: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 <== NOT EXECUTED
59906: 4e5e unlk %fp <== NOT EXECUTED
...
0004e8d6 <rtems_rfs_rtems_eval_for_make>:
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
4e8d6: 4e56 ffa4 linkw %fp,#-92
4e8da: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4e8de: 286e 000c moveal %fp@(12),%a4
*name = path + strlen (path);
while (*name != path)
{
(*name)--;
if (rtems_filesystem_is_separator (**name))
4e8e2: 47f9 0004 6a68 lea 46a68 <rtems_filesystem_is_separator>,%a3
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e8e8: 206c 0010 moveal %a4@(16),%a0
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e8ec: 2d54 fff4 movel %a4@,%fp@(-12)
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e8f0: 2468 0034 moveal %a0@(52),%a2
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
4e8f4: 242e 0008 movel %fp@(8),%d2
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_ino node_ino;
uint32_t doff = 0;
4e8f8: 42ae fffc clrl %fp@(-4)
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
4e8fc: 2a6e 0010 moveal %fp@(16),%a5
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
4e900: 2f02 movel %d2,%sp@-
4e902: 4eb9 0005 bf54 jsr 5bf54 <strlen>
4e908: 588f addql #4,%sp
4e90a: d082 addl %d2,%d0
4e90c: 2a80 movel %d0,%a5@
while (*name != path)
4e90e: 601a bras 4e92a <rtems_rfs_rtems_eval_for_make+0x54>
{
(*name)--;
4e910: 2008 movel %a0,%d0
4e912: 5380 subql #1,%d0
4e914: 2a80 movel %d0,%a5@
if (rtems_filesystem_is_separator (**name))
4e916: 1228 ffff moveb %a0@(-1),%d1
4e91a: 49c1 extbl %d1
4e91c: 2f01 movel %d1,%sp@-
4e91e: 4e93 jsr %a3@
4e920: 588f addql #4,%sp
4e922: 4a80 tstl %d0
4e924: 6704 beqs 4e92a <rtems_rfs_rtems_eval_for_make+0x54>
{
(*name)++;
4e926: 5295 addql #1,%a5@
break;
4e928: 6006 bras 4e930 <rtems_rfs_rtems_eval_for_make+0x5a>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
while (*name != path)
4e92a: 2055 moveal %a5@,%a0
4e92c: b488 cmpl %a0,%d2
4e92e: 66e0 bnes 4e910 <rtems_rfs_rtems_eval_for_make+0x3a>
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
4e930: 2f02 movel %d2,%sp@-
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4e932: 2e0e movel %fp,%d7
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e934: 47ee ffce lea %fp@(-50),%a3
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4e938: 0687 ffff fff4 addil #-12,%d7
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
4e93e: 4eb9 0005 bf54 jsr 5bf54 <strlen>
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
4e944: 2c3c 0004 6a68 movel #289384,%d6
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
4e94a: 2e80 movel %d0,%sp@
4e94c: 2f02 movel %d2,%sp@-
4e94e: 4eb9 0004 537e jsr 4537e <rtems_filesystem_prefix_separators>
path += stripped;
rtems_rfs_rtems_lock (fs);
4e954: 2f2a 007c movel %a2@(124),%sp@-
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
path += stripped;
4e958: d480 addl %d0,%d2
rtems_rfs_rtems_lock (fs);
4e95a: 4eba f8c6 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
4e95e: 4fef 000c lea %sp@(12),%sp
4e962: 6002 bras 4e966 <rtems_rfs_rtems_eval_for_make+0x90>
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
path += stripped;
4e964: 2404 movel %d4,%d2
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e966: 4878 0001 pea 1 <ADD>
4e96a: 2f0b movel %a3,%sp@-
4e96c: 2f2e fff4 movel %fp@(-12),%sp@-
4e970: 2f0a movel %a2,%sp@-
4e972: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
4e978: 4fef 0010 lea %sp@(16),%sp
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e97c: 2600 movel %d0,%d3
if (rc > 0)
4e97e: 6f14 bles 4e994 <rtems_rfs_rtems_eval_for_make+0xbe><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e980: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e982: 4eba f680 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);
4e986: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e98c: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e98e: 2083 movel %d3,%a0@ <== NOT EXECUTED
4e990: 6000 020c braw 4eb9e <rtems_rfs_rtems_eval_for_make+0x2c8><== NOT EXECUTED
}
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
4e994: 206b 000c moveal %a3@(12),%a0
4e998: 4280 clrl %d0
4e99a: 1028 0002 moveb %a0@(2),%d0
4e99e: e188 lsll #8,%d0
4e9a0: 0280 0000 f000 andil #61440,%d0
4e9a6: 0c80 0000 4000 cmpil #16384,%d0
4e9ac: 6638 bnes 4e9e6 <rtems_rfs_rtems_eval_for_make+0x110>
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
4e9ae: 4878 0001 pea 1 <ADD>
4e9b2: 2f0b movel %a3,%sp@-
4e9b4: 4eb9 0004 f2f0 jsr 4f2f0 <rtems_rfs_rtems_eval_perms>
}
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
4e9ba: 508f addql #8,%sp
4e9bc: 4a00 tstb %d0
4e9be: 6626 bnes 4e9e6 <rtems_rfs_rtems_eval_for_make+0x110><== ALWAYS TAKEN
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
4e9c0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
4e9c2: 7a0d moveq #13,%d5 <== NOT EXECUTED
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
4e9c4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e9c6: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4e9cc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e9ce: 4eba f634 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
4e9d2: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e9d8: 2240 moveal %d0,%a1 <== NOT EXECUTED
4e9da: 2285 movel %d5,%a1@ <== NOT EXECUTED
4e9dc: 4fef 000c lea %sp@(12),%sp
4e9e0: 74ff moveq #-1,%d2
4e9e2: 6000 02b6 braw 4ec9a <rtems_rfs_rtems_eval_for_make+0x3c4>
}
/*
* Is this the end of the pathname we where given ?
*/
if (path == *name)
4e9e6: b495 cmpl %a5@,%d2
4e9e8: 6700 01ba beqw 4eba4 <rtems_rfs_rtems_eval_for_make+0x2ce>
4e9ec: 2a02 movel %d2,%d5
4e9ee: 4283 clrl %d3
4e9f0: 6002 bras 4e9f4 <rtems_rfs_rtems_eval_for_make+0x11e>
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
{
node_len++;
4e9f2: 5283 addql #1,%d3
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
4e9f4: 2045 moveal %d5,%a0
4e9f6: 2246 moveal %d6,%a1
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
{
node_len++;
4e9f8: 2805 movel %d5,%d4
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
4e9fa: 1010 moveb %a0@,%d0
4e9fc: 49c0 extbl %d0
4e9fe: 2f00 movel %d0,%sp@-
4ea00: 4e91 jsr %a1@
4ea02: 588f addql #4,%sp
4ea04: 4a80 tstl %d0
4ea06: 6612 bnes 4ea1a <rtems_rfs_rtems_eval_for_make+0x144>
4ea08: 5285 addql #1,%d5
4ea0a: 2044 moveal %d4,%a0
4ea0c: 4a10 tstb %a0@
4ea0e: 670a beqs 4ea1a <rtems_rfs_rtems_eval_for_make+0x144><== NEVER TAKEN
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
4ea10: 202a 0018 movel %a2@(24),%d0
4ea14: 5380 subql #1,%d0
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
(*path != '\0') &&
4ea16: b083 cmpl %d3,%d0
4ea18: 62d8 bhis 4e9f2 <rtems_rfs_rtems_eval_for_make+0x11c><== ALWAYS TAKEN
}
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
4ea1a: 2f04 movel %d4,%sp@-
4ea1c: 4eb9 0005 bf54 jsr 5bf54 <strlen>
4ea22: 2e80 movel %d0,%sp@
4ea24: 2f04 movel %d4,%sp@-
4ea26: 4eb9 0004 537e jsr 4537e <rtems_filesystem_prefix_separators>
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
4ea2c: 508f addql #8,%sp
4ea2e: 2242 moveal %d2,%a1
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
path += stripped;
4ea30: d880 addl %d0,%d4
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
4ea32: 722e moveq #46,%d1
4ea34: 1011 moveb %a1@,%d0
4ea36: 49c0 extbl %d0
4ea38: b280 cmpl %d0,%d1
4ea3a: 662c bnes 4ea68 <rtems_rfs_rtems_eval_for_make+0x192><== ALWAYS TAKEN
4ea3c: 1029 0001 moveb %a1@(1),%d0 <== NOT EXECUTED
4ea40: 670e beqs 4ea50 <rtems_rfs_rtems_eval_for_make+0x17a><== NOT EXECUTED
4ea42: 49c0 extbl %d0 <== NOT EXECUTED
4ea44: 2046 moveal %d6,%a0 <== NOT EXECUTED
4ea46: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ea48: 4e90 jsr %a0@ <== NOT EXECUTED
4ea4a: 588f addql #4,%sp <== NOT EXECUTED
4ea4c: 4a80 tstl %d0 <== NOT EXECUTED
4ea4e: 6718 beqs 4ea68 <rtems_rfs_rtems_eval_for_make+0x192><== NOT EXECUTED
{
if (*path)
4ea50: 2244 moveal %d4,%a1 <== NOT EXECUTED
4ea52: 4a11 tstb %a1@ <== NOT EXECUTED
4ea54: 6700 014e beqw 4eba4 <rtems_rfs_rtems_eval_for_make+0x2ce><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4ea58: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ea5a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ea5c: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
continue;
4ea62: 508f addql #8,%sp <== NOT EXECUTED
4ea64: 6000 fefe braw 4e964 <rtems_rfs_rtems_eval_for_make+0x8e><== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (path))
4ea68: 2044 moveal %d4,%a0
4ea6a: 722e moveq #46,%d1
4ea6c: 1010 moveb %a0@,%d0
4ea6e: 49c0 extbl %d0
4ea70: b280 cmpl %d0,%d1
4ea72: 6600 00ea bnew 4eb5e <rtems_rfs_rtems_eval_for_make+0x288>
4ea76: 1028 0001 moveb %a0@(1),%d0 <== NOT EXECUTED
4ea7a: 49c0 extbl %d0 <== NOT EXECUTED
4ea7c: b280 cmpl %d0,%d1 <== NOT EXECUTED
4ea7e: 6600 00de bnew 4eb5e <rtems_rfs_rtems_eval_for_make+0x288><== NOT EXECUTED
4ea82: 1028 0002 moveb %a0@(2),%d0 <== NOT EXECUTED
4ea86: 6710 beqs 4ea98 <rtems_rfs_rtems_eval_for_make+0x1c2><== NOT EXECUTED
4ea88: 49c0 extbl %d0 <== NOT EXECUTED
4ea8a: 2046 moveal %d6,%a0 <== NOT EXECUTED
4ea8c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ea8e: 4e90 jsr %a0@ <== NOT EXECUTED
4ea90: 588f addql #4,%sp <== NOT EXECUTED
4ea92: 4a80 tstl %d0 <== NOT EXECUTED
4ea94: 6700 00c8 beqw 4eb5e <rtems_rfs_rtems_eval_for_make+0x288><== NOT EXECUTED
{
/*
* If we are at the root inode of the file system we have a crossmount
* path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
4ea98: 7001 moveq #1,%d0 <== NOT EXECUTED
4ea9a: b0ae fff4 cmpl %fp@(-12),%d0 <== NOT EXECUTED
4ea9e: 6642 bnes 4eae2 <rtems_rfs_rtems_eval_for_make+0x20c><== NOT EXECUTED
{
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
path - node_len);
rtems_rfs_inode_close (fs, &inode);
4eaa0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4eaa2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eaa4: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4eaaa: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eaac: 4eba f556 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
*pathloc = pathloc->mt_entry->mt_point_node;
4eab0: 4878 0014 pea 14 <OPER2> <== NOT EXECUTED
4eab4: 222c 0010 movel %a4@(16),%d1 <== NOT EXECUTED
4eab8: 5081 addql #8,%d1 <== NOT EXECUTED
4eaba: 2f01 movel %d1,%sp@- <== NOT EXECUTED
4eabc: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4eabe: 4eb9 0005 b134 jsr 5b134 <memcpy> <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
4eac4: 206c 000c moveal %a4@(12),%a0 <== NOT EXECUTED
4eac8: 2244 moveal %d4,%a1 <== NOT EXECUTED
4eaca: 2f0d movel %a5,%sp@- <== NOT EXECUTED
4eacc: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4eace: 4869 0002 pea %a1@(2) <== NOT EXECUTED
4ead2: 2068 0004 moveal %a0@(4),%a0 <== NOT EXECUTED
4ead6: 4e90 jsr %a0@ <== NOT EXECUTED
4ead8: 4fef 0024 lea %sp@(36),%sp <== NOT EXECUTED
4eadc: 2400 movel %d0,%d2 <== NOT EXECUTED
4eade: 6000 01ba braw 4ec9a <rtems_rfs_rtems_eval_for_make+0x3c4><== NOT EXECUTED
/*
* If not a directory give and up return. We cannot change dir from a
* regular file or device node.
*/
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
4eae2: 206b 000c moveal %a3@(12),%a0 <== NOT EXECUTED
4eae6: 4280 clrl %d0 <== NOT EXECUTED
4eae8: 1028 0002 moveb %a0@(2),%d0 <== NOT EXECUTED
4eaec: e188 lsll #8,%d0 <== NOT EXECUTED
4eaee: 0280 0000 f000 andil #61440,%d0 <== NOT EXECUTED
4eaf4: 0c80 0000 4000 cmpil #16384,%d0 <== NOT EXECUTED
4eafa: 6722 beqs 4eb1e <rtems_rfs_rtems_eval_for_make+0x248><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4eafc: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4eafe: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eb00: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4eb06: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eb08: 4eba f4fa jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
4eb0c: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4eb12: 2040 moveal %d0,%a0 <== NOT EXECUTED
4eb14: 20bc 0000 0086 movel #134,%a0@ <== NOT EXECUTED
4eb1a: 6000 fec0 braw 4e9dc <rtems_rfs_rtems_eval_for_make+0x106><== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
4eb1e: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4eb22: 2f07 movel %d7,%sp@- <== NOT EXECUTED
4eb24: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
4eb28: 4879 0006 8e09 pea 68e09 <_rodata_start+0x1a9> <== NOT EXECUTED
4eb2e: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4eb30: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eb32: 4eb9 0005 62e2 jsr 562e2 <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
if (rc > 0)
4eb38: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
4eb3c: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
4eb3e: 6f3c bles 4eb7c <rtems_rfs_rtems_eval_for_make+0x2a6><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
4eb40: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4eb42: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eb44: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4eb4a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eb4c: 4eba f4b6 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: read parent inode", rc);
4eb50: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4eb56: 2240 moveal %d0,%a1 <== NOT EXECUTED
4eb58: 2282 movel %d2,%a1@ <== NOT EXECUTED
4eb5a: 6000 fe80 braw 4e9dc <rtems_rfs_rtems_eval_for_make+0x106><== NOT EXECUTED
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4eb5e: 486e fffc pea %fp@(-4)
4eb62: 2f07 movel %d7,%sp@-
4eb64: 2f03 movel %d3,%sp@-
4eb66: 2f02 movel %d2,%sp@-
4eb68: 2f0b movel %a3,%sp@-
4eb6a: 2f0a movel %a2,%sp@-
4eb6c: 4eb9 0005 62e2 jsr 562e2 <rtems_rfs_dir_lookup_ino>
node, node_len - stripped, &ino, &doff);
if (rc > 0)
4eb72: 4fef 0018 lea %sp@(24),%sp
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4eb76: 2400 movel %d0,%d2
node, node_len - stripped, &ino, &doff);
if (rc > 0)
4eb78: 6e00 00cc bgtw 4ec46 <rtems_rfs_rtems_eval_for_make+0x370>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: down: path:%s ino:%" PRId32 "\n",
node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
4eb7c: 2f0b movel %a3,%sp@-
4eb7e: 2f0a movel %a2,%sp@-
4eb80: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
if (rc > 0)
4eb86: 508f addql #8,%sp
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: down: path:%s ino:%" PRId32 "\n",
node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
4eb88: 2400 movel %d0,%d2
if (rc > 0)
4eb8a: 6f00 fdd8 blew 4e964 <rtems_rfs_rtems_eval_for_make+0x8e>
{
rtems_rfs_rtems_unlock (fs);
4eb8e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eb90: 4eba f472 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
4eb94: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4eb9a: 2240 moveal %d0,%a1 <== NOT EXECUTED
4eb9c: 2282 movel %d2,%a1@ <== NOT EXECUTED
4eb9e: 588f addql #4,%sp <== NOT EXECUTED
4eba0: 6000 fe3e braw 4e9e0 <rtems_rfs_rtems_eval_for_make+0x10a><== NOT EXECUTED
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
4eba4: 47ee ffce lea %fp@(-50),%a3
4eba8: 4280 clrl %d0
4ebaa: 206b 000c moveal %a3@(12),%a0
4ebae: 1028 0002 moveb %a0@(2),%d0
4ebb2: e188 lsll #8,%d0
4ebb4: 0280 0000 f000 andil #61440,%d0
4ebba: 0c80 0000 4000 cmpil #16384,%d0
4ebc0: 6720 beqs 4ebe2 <rtems_rfs_rtems_eval_for_make+0x30c>
{
rtems_rfs_inode_close (fs, &inode);
4ebc2: 2f0b movel %a3,%sp@-
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
4ebc4: 7814 moveq #20,%d4
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
4ebc6: 2f0a movel %a2,%sp@-
4ebc8: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4ebce: 2f0a movel %a2,%sp@-
4ebd0: 4eba f432 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
4ebd4: 4eb9 0005 a88c jsr 5a88c <__errno>
4ebda: 2040 moveal %d0,%a0
4ebdc: 2084 movel %d4,%a0@
4ebde: 6000 fdfc braw 4e9dc <rtems_rfs_rtems_eval_for_make+0x106>
}
if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))
4ebe2: 4878 0003 pea 3 <DIVIDE>
4ebe6: 2f0b movel %a3,%sp@-
4ebe8: 4eb9 0004 f2f0 jsr 4f2f0 <rtems_rfs_rtems_eval_perms>
4ebee: 508f addql #8,%sp
4ebf0: 4a00 tstb %d0
4ebf2: 6700 fdcc beqw 4e9c0 <rtems_rfs_rtems_eval_for_make+0xea>
}
/*
* Make sure the name does not already exists in the directory.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
4ebf6: 2415 movel %a5@,%d2
4ebf8: 2f02 movel %d2,%sp@-
4ebfa: 4eb9 0005 bf54 jsr 5bf54 <strlen>
4ec00: 588f addql #4,%sp
4ec02: 486e fffc pea %fp@(-4)
4ec06: 486e fff8 pea %fp@(-8)
4ec0a: 2f00 movel %d0,%sp@-
4ec0c: 2f02 movel %d2,%sp@-
4ec0e: 2f0b movel %a3,%sp@-
4ec10: 2f0a movel %a2,%sp@-
4ec12: 4eb9 0005 62e2 jsr 562e2 <rtems_rfs_dir_lookup_ino>
&node_ino, &doff);
if (rc == 0)
4ec18: 4fef 0018 lea %sp@(24),%sp
}
/*
* Make sure the name does not already exists in the directory.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
4ec1c: 2400 movel %d0,%d2
&node_ino, &doff);
if (rc == 0)
4ec1e: 6620 bnes 4ec40 <rtems_rfs_rtems_eval_for_make+0x36a>
{
rtems_rfs_inode_close (fs, &inode);
4ec20: 2f0b movel %a3,%sp@-
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
4ec22: 7611 moveq #17,%d3
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
&node_ino, &doff);
if (rc == 0)
{
rtems_rfs_inode_close (fs, &inode);
4ec24: 2f0a movel %a2,%sp@-
4ec26: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4ec2c: 2f0a movel %a2,%sp@-
4ec2e: 4eba f3d4 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
4ec32: 4eb9 0005 a88c jsr 5a88c <__errno>
4ec38: 2040 moveal %d0,%a0
4ec3a: 2083 movel %d3,%a0@
4ec3c: 6000 fd9e braw 4e9dc <rtems_rfs_rtems_eval_for_make+0x106>
}
if (rc != ENOENT)
4ec40: 7002 moveq #2,%d0
4ec42: b082 cmpl %d2,%d0
4ec44: 671e beqs 4ec64 <rtems_rfs_rtems_eval_for_make+0x38e><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
4ec46: 2f0b movel %a3,%sp@-
4ec48: 2f0a movel %a2,%sp@-
4ec4a: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4ec50: 2f0a movel %a2,%sp@-
4ec52: 4eba f3b0 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
return rtems_rfs_rtems_error ("eval_for_make: look up", rc);
4ec56: 4eb9 0005 a88c jsr 5a88c <__errno>
4ec5c: 2040 moveal %d0,%a0
4ec5e: 2082 movel %d2,%a0@
4ec60: 6000 fd7a braw 4e9dc <rtems_rfs_rtems_eval_for_make+0x106>
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
4ec64: 28ae fff4 movel %fp@(-12),%a4@
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
4ec68: 296e fffc 0004 movel %fp@(-4),%a4@(4)
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
4ec6e: 2f0b movel %a3,%sp@-
4ec70: 2f0c movel %a4,%sp@-
4ec72: 4eb9 0004 f330 jsr 4f330 <rtems_rfs_rtems_set_handlers>
4ec78: 508f addql #8,%sp
4ec7a: 4a00 tstb %d0
4ec7c: 6704 beqs 4ec82 <rtems_rfs_rtems_eval_for_make+0x3ac><== NEVER TAKEN
4ec7e: 4282 clrl %d2
4ec80: 6002 bras 4ec84 <rtems_rfs_rtems_eval_for_make+0x3ae>
4ec82: 7405 moveq #5,%d2 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
ino, *name);
rtems_rfs_inode_close (fs, &inode);
4ec84: 486e ffce pea %fp@(-50)
4ec88: 2f0a movel %a2,%sp@-
4ec8a: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4ec90: 2f0a movel %a2,%sp@-
4ec92: 4eba f370 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
return rc;
4ec96: 4fef 000c lea %sp@(12),%sp
}
4ec9a: 2002 movel %d2,%d0
4ec9c: 4cee 3cfc ffa4 moveml %fp@(-92),%d2-%d7/%a2-%a5
4eca2: 4e5e unlk %fp <== NOT EXECUTED
0004eca6 <rtems_rfs_rtems_eval_path>:
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
4eca6: 4e56 ffa4 linkw %fp,#-92
4ecaa: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
4ecae: 286e 0014 moveal %fp@(20),%a4
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4ecb2: 2e0e movel %fp,%d7
4ecb4: 2c0e movel %fp,%d6
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ecb6: 47ee ffd2 lea %fp@(-46),%a3
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
4ecba: 2a3c 0004 6a68 movel #289384,%d5
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4ecc0: 5987 subql #4,%d7
4ecc2: 5186 subql #8,%d6
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4ecc4: 206c 0010 moveal %a4@(16),%a0
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4ecc8: 2d54 fff8 movel %a4@,%fp@(-8)
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4eccc: 2468 0034 moveal %a0@(52),%a2
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
4ecd0: 242e 000c movel %fp@(12),%d2
4ecd4: 2a6e 0008 moveal %fp@(8),%a5
path, pathlen, ino);
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
4ecd8: 2f02 movel %d2,%sp@-
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = 0;
4ecda: 42ae fffc clrl %fp@(-4)
path, pathlen, ino);
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
4ecde: 2f0d movel %a5,%sp@-
4ece0: 4eb9 0004 537e jsr 4537e <rtems_filesystem_prefix_separators>
path += stripped;
pathlen -= stripped;
rtems_rfs_rtems_lock (fs);
4ece6: 2f2a 007c movel %a2@(124),%sp@-
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
4ecea: dbc0 addal %d0,%a5
pathlen -= stripped;
4ecec: 9480 subl %d0,%d2
rtems_rfs_rtems_lock (fs);
4ecee: 4eba f532 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
4ecf2: 4fef 000c lea %sp@(12),%sp
4ecf6: 6002 bras 4ecfa <rtems_rfs_rtems_eval_path+0x54>
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
4ecf8: 2a44 moveal %d4,%a5
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ecfa: 4878 0001 pea 1 <ADD>
4ecfe: 2f0b movel %a3,%sp@-
4ed00: 2f2e fff8 movel %fp@(-8),%sp@-
4ed04: 2f0a movel %a2,%sp@-
4ed06: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
4ed0c: 4fef 0010 lea %sp@(16),%sp
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ed10: 2600 movel %d0,%d3
if (rc > 0)
4ed12: 6f14 bles 4ed28 <rtems_rfs_rtems_eval_path+0x82> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4ed14: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ed16: 4eba f2ec jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: opening inode", rc);
4ed1a: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4ed20: 588f addql #4,%sp <== NOT EXECUTED
4ed22: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ed24: 2083 movel %d3,%a0@ <== NOT EXECUTED
4ed26: 605e bras 4ed86 <rtems_rfs_rtems_eval_path+0xe0> <== NOT EXECUTED
}
/*
* Is this the end of the pathname we where given ?
*/
if ((*path == '\0') || (pathlen == 0))
4ed28: 4a15 tstb %a5@
4ed2a: 6700 01f6 beqw 4ef22 <rtems_rfs_rtems_eval_path+0x27c>
4ed2e: 4a82 tstl %d2
4ed30: 6700 01f0 beqw 4ef22 <rtems_rfs_rtems_eval_path+0x27c>
break;
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
4ed34: 206b 000c moveal %a3@(12),%a0
4ed38: 4280 clrl %d0
4ed3a: 1028 0002 moveb %a0@(2),%d0
4ed3e: e188 lsll #8,%d0
4ed40: 0280 0000 f000 andil #61440,%d0
4ed46: 0c80 0000 4000 cmpil #16384,%d0
4ed4c: 6612 bnes 4ed60 <rtems_rfs_rtems_eval_path+0xba>
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
4ed4e: 4878 0001 pea 1 <ADD>
4ed52: 2f0b movel %a3,%sp@-
4ed54: 4eb9 0004 f2f0 jsr 4f2f0 <rtems_rfs_rtems_eval_perms>
break;
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
4ed5a: 508f addql #8,%sp
4ed5c: 4a00 tstb %d0
4ed5e: 6706 beqs 4ed66 <rtems_rfs_rtems_eval_path+0xc0> <== NEVER TAKEN
4ed60: 280d movel %a5,%d4
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
4ed62: 4283 clrl %d3
4ed64: 602a bras 4ed90 <rtems_rfs_rtems_eval_path+0xea>
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
4ed66: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
4ed68: 7c0d moveq #13,%d6 <== NOT EXECUTED
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
4ed6a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ed6c: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4ed72: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ed74: 4eba f28e jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
4ed78: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4ed7e: 2240 moveal %d0,%a1 <== NOT EXECUTED
4ed80: 2286 movel %d6,%a1@ <== NOT EXECUTED
4ed82: 4fef 000c lea %sp@(12),%sp
4ed86: 74ff moveq #-1,%d2
4ed88: 6000 01d4 braw 4ef5e <rtems_rfs_rtems_eval_path+0x2b8>
while (!rtems_filesystem_is_separator (*path) &&
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
{
path++;
pathlen--;
4ed8c: 5382 subql #1,%d2
4ed8e: 2600 movel %d0,%d3
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
4ed90: 2044 moveal %d4,%a0
4ed92: 2245 moveal %d5,%a1
4ed94: 1010 moveb %a0@,%d0
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
{
path++;
pathlen--;
4ed96: 2d44 ffcc movel %d4,%fp@(-52)
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
4ed9a: 49c0 extbl %d0
4ed9c: 2f00 movel %d0,%sp@-
4ed9e: 4e91 jsr %a1@
4eda0: 588f addql #4,%sp
4eda2: 4a80 tstl %d0
4eda4: 6618 bnes 4edbe <rtems_rfs_rtems_eval_path+0x118>
4eda6: 206e ffcc moveal %fp@(-52),%a0
4edaa: 5284 addql #1,%d4
4edac: 4a10 tstb %a0@
4edae: 670e beqs 4edbe <rtems_rfs_rtems_eval_path+0x118><== NEVER TAKEN
(*path != '\0') && pathlen &&
4edb0: 4a82 tstl %d2
4edb2: 670a beqs 4edbe <rtems_rfs_rtems_eval_path+0x118><== NEVER TAKEN
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
4edb4: 2003 movel %d3,%d0
4edb6: 5280 addql #1,%d0
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
(*path != '\0') && pathlen &&
4edb8: b0aa 0018 cmpl %a2@(24),%d0
4edbc: 65ce bcss 4ed8c <rtems_rfs_rtems_eval_path+0xe6> <== ALWAYS TAKEN
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
4edbe: 2f02 movel %d2,%sp@-
4edc0: 2f2e ffcc movel %fp@(-52),%sp@-
4edc4: 4eb9 0004 537e jsr 4537e <rtems_filesystem_prefix_separators>
path += stripped;
4edca: 282e ffcc movel %fp@(-52),%d4
pathlen -= stripped;
node_len += stripped;
4edce: 2240 moveal %d0,%a1
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
4edd0: d880 addl %d0,%d4
pathlen -= stripped;
4edd2: 9480 subl %d0,%d2
node_len += stripped;
4edd4: d3c3 addal %d3,%a1
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
4edd6: 508f addql #8,%sp
4edd8: 722e moveq #46,%d1
4edda: 1015 moveb %a5@,%d0
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
pathlen -= stripped;
node_len += stripped;
4eddc: 2d49 ffcc movel %a1,%fp@(-52)
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
4ede0: 49c0 extbl %d0
4ede2: b280 cmpl %d0,%d1
4ede4: 662c bnes 4ee12 <rtems_rfs_rtems_eval_path+0x16c>
4ede6: 102d 0001 moveb %a5@(1),%d0
4edea: 670e beqs 4edfa <rtems_rfs_rtems_eval_path+0x154>
4edec: 49c0 extbl %d0
4edee: 2045 moveal %d5,%a0
4edf0: 2f00 movel %d0,%sp@-
4edf2: 4e90 jsr %a0@
4edf4: 588f addql #4,%sp
4edf6: 4a80 tstl %d0
4edf8: 6718 beqs 4ee12 <rtems_rfs_rtems_eval_path+0x16c><== ALWAYS TAKEN
{
if (*path)
4edfa: 2244 moveal %d4,%a1
4edfc: 4a11 tstb %a1@
4edfe: 6700 0122 beqw 4ef22 <rtems_rfs_rtems_eval_path+0x27c>
{
rtems_rfs_inode_close (fs, &inode);
4ee02: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ee04: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ee06: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
continue;
4ee0c: 508f addql #8,%sp <== NOT EXECUTED
4ee0e: 6000 fee8 braw 4ecf8 <rtems_rfs_rtems_eval_path+0x52> <== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (node))
4ee12: 722e moveq #46,%d1
4ee14: 1015 moveb %a5@,%d0
4ee16: 49c0 extbl %d0
4ee18: b280 cmpl %d0,%d1
4ee1a: 6600 00a0 bnew 4eebc <rtems_rfs_rtems_eval_path+0x216>
4ee1e: 102d 0001 moveb %a5@(1),%d0
4ee22: 49c0 extbl %d0
4ee24: b280 cmpl %d0,%d1
4ee26: 6600 0094 bnew 4eebc <rtems_rfs_rtems_eval_path+0x216>
4ee2a: 102d 0002 moveb %a5@(2),%d0
4ee2e: 670e beqs 4ee3e <rtems_rfs_rtems_eval_path+0x198><== ALWAYS TAKEN
4ee30: 49c0 extbl %d0 <== NOT EXECUTED
4ee32: 2045 moveal %d5,%a0 <== NOT EXECUTED
4ee34: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4ee36: 4e90 jsr %a0@ <== NOT EXECUTED
4ee38: 588f addql #4,%sp <== NOT EXECUTED
4ee3a: 4a80 tstl %d0 <== NOT EXECUTED
4ee3c: 677e beqs 4eebc <rtems_rfs_rtems_eval_path+0x216><== NOT EXECUTED
{
/*
* If we are at root inode of the file system we have a crossmount path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
4ee3e: 7001 moveq #1,%d0
4ee40: b0ae fff8 cmpl %fp@(-8),%d0
4ee44: 664a bnes 4ee90 <rtems_rfs_rtems_eval_path+0x1ea>
{
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
4ee46: 486e ffd2 pea %fp@(-46)
4ee4a: 2f0a movel %a2,%sp@-
4ee4c: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4ee52: 2f0a movel %a2,%sp@-
4ee54: 4eba f1ae jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
*pathloc = pathloc->mt_entry->mt_point_node;
4ee58: 4878 0014 pea 14 <OPER2>
4ee5c: 222c 0010 movel %a4@(16),%d1
4ee60: 5081 addql #8,%d1
4ee62: 2f01 movel %d1,%sp@-
4ee64: 2f0c movel %a4,%sp@-
4ee66: 4eb9 0005 b134 jsr 5b134 <memcpy>
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
4ee6c: 206c 000c moveal %a4@(12),%a0
4ee70: 2f0c movel %a4,%sp@-
4ee72: 2f2e 0010 movel %fp@(16),%sp@-
4ee76: 226e ffcc moveal %fp@(-52),%a1
4ee7a: 4871 2800 pea %a1@(00000000,%d2:l)
4ee7e: 9889 subl %a1,%d4
4ee80: 2f04 movel %d4,%sp@-
4ee82: 2050 moveal %a0@,%a0
4ee84: 4e90 jsr %a0@
4ee86: 4fef 0028 lea %sp@(40),%sp
4ee8a: 2400 movel %d0,%d2
4ee8c: 6000 00d0 braw 4ef5e <rtems_rfs_rtems_eval_path+0x2b8>
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
4ee90: 2f07 movel %d7,%sp@-
4ee92: 2f06 movel %d6,%sp@-
4ee94: 4878 0002 pea 2 <DOUBLE_FLOAT>
4ee98: 4879 0006 8e09 pea 68e09 <_rodata_start+0x1a9>
4ee9e: 2f0b movel %a3,%sp@-
4eea0: 2f0a movel %a2,%sp@-
4eea2: 4eb9 0005 62e2 jsr 562e2 <rtems_rfs_dir_lookup_ino>
if (rc > 0)
4eea8: 4fef 0018 lea %sp@(24),%sp
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
4eeac: 2600 movel %d0,%d3
if (rc > 0)
4eeae: 6f44 bles 4eef4 <rtems_rfs_rtems_eval_path+0x24e><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
4eeb0: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4eeb2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4eeb4: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
4eeba: 6052 bras 4ef0e <rtems_rfs_rtems_eval_path+0x268><== NOT EXECUTED
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4eebc: 2f07 movel %d7,%sp@-
4eebe: 2f06 movel %d6,%sp@-
4eec0: 2f03 movel %d3,%sp@-
4eec2: 2f0d movel %a5,%sp@-
4eec4: 2f0b movel %a3,%sp@-
4eec6: 2f0a movel %a2,%sp@-
4eec8: 4eb9 0005 62e2 jsr 562e2 <rtems_rfs_dir_lookup_ino>
node, node_len - stripped, &ino, &doff);
if (rc > 0)
4eece: 4fef 0018 lea %sp@(24),%sp
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
4eed2: 2600 movel %d0,%d3
node, node_len - stripped, &ino, &doff);
if (rc > 0)
4eed4: 6f1e bles 4eef4 <rtems_rfs_rtems_eval_path+0x24e>
{
rtems_rfs_inode_close (fs, &inode);
4eed6: 2f0b movel %a3,%sp@-
4eed8: 2f0a movel %a2,%sp@-
4eeda: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4eee0: 2f0a movel %a2,%sp@-
4eee2: 4eba f120 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
return ((errno = rc) == 0) ? 0 : -1;
4eee6: 4eb9 0005 a88c jsr 5a88c <__errno>
4eeec: 2240 moveal %d0,%a1
4eeee: 2283 movel %d3,%a1@
4eef0: 6000 fe90 braw 4ed82 <rtems_rfs_rtems_eval_path+0xdc>
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
4eef4: 2f0b movel %a3,%sp@-
4eef6: 4bf9 0004 d876 lea 4d876 <rtems_rfs_inode_close>,%a5
4eefc: 2f0a movel %a2,%sp@-
4eefe: 4e95 jsr %a5@
if (rc > 0)
4ef00: 508f addql #8,%sp
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
4ef02: 2600 movel %d0,%d3
if (rc > 0)
4ef04: 6f00 fdf2 blew 4ecf8 <rtems_rfs_rtems_eval_path+0x52>
{
rtems_rfs_inode_close (fs, &inode);
4ef08: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4ef0a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ef0c: 4e95 jsr %a5@ <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4ef0e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4ef10: 4eba f0f2 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
4ef14: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4ef1a: 2040 moveal %d0,%a0 <== NOT EXECUTED
4ef1c: 2083 movel %d3,%a0@ <== NOT EXECUTED
4ef1e: 6000 fe62 braw 4ed82 <rtems_rfs_rtems_eval_path+0xdc> <== NOT EXECUTED
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
4ef22: 28ae fff8 movel %fp@(-8),%a4@
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
4ef26: 260e movel %fp,%d3
4ef28: 0683 ffff ffd2 addil #-46,%d3
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
4ef2e: 296e fffc 0004 movel %fp@(-4),%a4@(4)
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
4ef34: 2f03 movel %d3,%sp@-
4ef36: 2f0c movel %a4,%sp@-
4ef38: 4eb9 0004 f330 jsr 4f330 <rtems_rfs_rtems_set_handlers>
4ef3e: 508f addql #8,%sp
4ef40: 4a00 tstb %d0
4ef42: 6704 beqs 4ef48 <rtems_rfs_rtems_eval_path+0x2a2><== NEVER TAKEN
4ef44: 4282 clrl %d2
4ef46: 6002 bras 4ef4a <rtems_rfs_rtems_eval_path+0x2a4>
4ef48: 7405 moveq #5,%d2 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4ef4a: 2f03 movel %d3,%sp@-
4ef4c: 2f0a movel %a2,%sp@-
4ef4e: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
4ef54: 2f0a movel %a2,%sp@-
4ef56: 4eba f0ac jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);
return rc;
4ef5a: 4fef 000c lea %sp@(12),%sp
}
4ef5e: 2002 movel %d2,%d0
4ef60: 4cee 3cfc ffa4 moveml %fp@(-92),%d2-%d7/%a2-%a5
4ef66: 4e5e unlk %fp <== NOT EXECUTED
0004f1fc <rtems_rfs_rtems_fchmod>:
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
4f1fc: 4e56 ffcc linkw %fp,#-52 <== NOT EXECUTED
4f200: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4f204: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
4f208: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4f20c: 2410 movel %a0@,%d2 <== NOT EXECUTED
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f20e: 47ee ffda lea %fp@(-38),%a3 <== NOT EXECUTED
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4f212: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
4f216: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
4f21a: 4eba f006 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f21e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4f222: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f224: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4f226: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f228: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
4f22e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4f232: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
4f234: 6712 beqs 4f248 <rtems_rfs_rtems_fchmod+0x4c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4f236: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f238: 4eba edca jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
4f23c: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4f242: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f244: 2082 movel %d2,%a0@ <== NOT EXECUTED
4f246: 6058 bras 4f2a0 <rtems_rfs_rtems_fchmod+0xa4> <== NOT EXECUTED
}
imode = rtems_rfs_inode_get_mode (&inode);
4f248: 206b 000c moveal %a3@(12),%a0 <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4f24c: 4280 clrl %d0 <== NOT EXECUTED
4f24e: 1028 0002 moveb %a0@(2),%d0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4f252: 222e 000c movel %fp@(12),%d1 <== NOT EXECUTED
4f256: e188 lsll #8,%d0 <== NOT EXECUTED
4f258: 0281 0000 0fff andil #4095,%d1 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4f25e: 0280 0000 f000 andil #61440,%d0 <== NOT EXECUTED
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4f264: 8081 orl %d1,%d0 <== NOT EXECUTED
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
4f266: 2200 movel %d0,%d1 <== NOT EXECUTED
4f268: e089 lsrl #8,%d1 <== NOT EXECUTED
4f26a: 1141 0002 moveb %d1,%a0@(2) <== NOT EXECUTED
4f26e: 206e ffe6 moveal %fp@(-26),%a0 <== NOT EXECUTED
4f272: 1140 0003 moveb %d0,%a0@(3) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4f276: 7001 moveq #1,%d0 <== NOT EXECUTED
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
4f278: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f27a: 1d40 ffea moveb %d0,%fp@(-22) <== NOT EXECUTED
4f27e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f280: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
4f286: 508f addql #8,%sp <== NOT EXECUTED
4f288: 41fa ed7a lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
4f28c: 2640 moveal %d0,%a3 <== NOT EXECUTED
if (rc > 0)
4f28e: 4a80 tstl %d0 <== NOT EXECUTED
4f290: 6f14 bles 4f2a6 <rtems_rfs_rtems_fchmod+0xaa> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4f292: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f294: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
4f296: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4f29c: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f29e: 208b movel %a3,%a0@ <== NOT EXECUTED
4f2a0: 588f addql #4,%sp <== NOT EXECUTED
4f2a2: 70ff moveq #-1,%d0 <== NOT EXECUTED
4f2a4: 6008 bras 4f2ae <rtems_rfs_rtems_fchmod+0xb2> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4f2a6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f2a8: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
4f2aa: 588f addql #4,%sp <== NOT EXECUTED
4f2ac: 4280 clrl %d0 <== NOT EXECUTED
}
4f2ae: 4cee 0c04 ffcc moveml %fp@(-52),%d2/%a2-%a3 <== NOT EXECUTED
4f2b4: 4e5e unlk %fp <== NOT EXECUTED
0004f2b8 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
4f2b8: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4f2bc: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
4f2c0: 2068 0028 moveal %a0@(40),%a0 <== NOT EXECUTED
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
4f2c4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4f2c6: 2f28 0034 movel %a0@(52),%sp@- <== NOT EXECUTED
4f2ca: 4eb9 0005 6044 jsr 56044 <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
4f2d0: 588f addql #4,%sp <== NOT EXECUTED
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4f2d2: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
4f2d4: 670e beqs 4f2e4 <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
4f2d6: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4f2dc: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f2de: 70ff moveq #-1,%d0 <== NOT EXECUTED
4f2e0: 2082 movel %d2,%a0@ <== NOT EXECUTED
4f2e2: 6002 bras 4f2e6 <rtems_rfs_rtems_fdatasync+0x2e> <== NOT EXECUTED
return 0;
4f2e4: 4280 clrl %d0 <== NOT EXECUTED
}
4f2e6: 242e fffc movel %fp@(-4),%d2 <== NOT EXECUTED
4f2ea: 4e5e unlk %fp <== NOT EXECUTED
...
00059cf6 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
59cf6: 4e56 fff4 linkw %fp,#-12
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
59cfa: 206e 0008 moveal %fp@(8),%a0
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
59cfe: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
59d02: 2668 001c moveal %a0@(28),%a3
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
59d06: 206b 001a moveal %a3@(26),%a0
59d0a: 2468 0090 moveal %a0@(144),%a2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
59d0e: 2f2a 007c movel %a2@(124),%sp@-
59d12: 4eba fc60 jsr %pc@(59974 <rtems_rfs_rtems_lock.isra.1>)
rc = rtems_rfs_file_close (fs, file);
59d16: 2f0b movel %a3,%sp@-
59d18: 2f0a movel %a2,%sp@-
59d1a: 4eb9 0005 735c jsr 5735c <rtems_rfs_file_close>
if (rc > 0)
59d20: 4fef 000c lea %sp@(12),%sp
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
59d24: 2400 movel %d0,%d2
if (rc > 0)
59d26: 6f0c bles 59d34 <rtems_rfs_rtems_file_close+0x3e><== ALWAYS TAKEN
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
59d28: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59d2e: 2040 moveal %d0,%a0 <== NOT EXECUTED
59d30: 2082 movel %d2,%a0@ <== NOT EXECUTED
59d32: 74ff moveq #-1,%d2 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
59d34: 2f0a movel %a2,%sp@-
59d36: 4eba fbde jsr %pc@(59916 <rtems_rfs_rtems_unlock>)
return rc;
}
59d3a: 2002 movel %d2,%d0
59d3c: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
59d42: 4e5e unlk %fp <== NOT EXECUTED
0005990c <rtems_rfs_rtems_file_ioctl>:
static int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
return 0;
}
5990c: 4280 clrl %d0 <== NOT EXECUTED
* @param buffer
*/
static int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
5990e: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
return 0;
}
59912: 4e5e unlk %fp <== NOT EXECUTED
00059a3c <rtems_rfs_rtems_file_lseek>:
*/
static rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
59a3c: 4e56 ffec linkw %fp,#-20
59a40: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
59a44: 246e 0008 moveal %fp@(8),%a2
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
59a48: 266a 001c moveal %a2@(28),%a3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
59a4c: 206b 001a moveal %a3@(26),%a0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
59a50: 2068 0090 moveal %a0@(144),%a0
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
59a54: 2f28 007c movel %a0@(124),%sp@-
59a58: 4eba ff1a jsr %pc@(59974 <rtems_rfs_rtems_lock.isra.1>)
pos = iop->offset;
59a5c: 202a 000c movel %a2@(12),%d0
59a60: 222a 0010 movel %a2@(16),%d1
59a64: 204e moveal %fp,%a0
59a66: 2101 movel %d1,%a0@-
59a68: 2100 movel %d0,%a0@-
rc = rtems_rfs_file_seek (file, pos, &pos);
59a6a: 2f08 movel %a0,%sp@-
59a6c: 2f01 movel %d1,%sp@-
59a6e: 2f00 movel %d0,%sp@-
59a70: 2f0b movel %a3,%sp@-
59a72: 4eb9 0005 7984 jsr 57984 <rtems_rfs_file_seek>
59a78: 226b 001a moveal %a3@(26),%a1
59a7c: 2400 movel %d0,%d2
if (rc)
59a7e: 4fef 0014 lea %sp@(20),%sp
59a82: 41fa fe92 lea %pc@(59916 <rtems_rfs_rtems_unlock>),%a0
59a86: 6718 beqs 59aa0 <rtems_rfs_rtems_file_lseek+0x64><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
59a88: 2f29 0090 movel %a1@(144),%sp@- <== NOT EXECUTED
59a8c: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
59a8e: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59a94: 588f addql #4,%sp <== NOT EXECUTED
59a96: 2040 moveal %d0,%a0 <== NOT EXECUTED
59a98: 2082 movel %d2,%a0@ <== NOT EXECUTED
59a9a: 70ff moveq #-1,%d0 <== NOT EXECUTED
59a9c: 72ff moveq #-1,%d1 <== NOT EXECUTED
59a9e: 6010 bras 59ab0 <rtems_rfs_rtems_file_lseek+0x74><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
59aa0: 2f29 0090 movel %a1@(144),%sp@-
59aa4: 4e90 jsr %a0@
return iop->offset;
59aa6: 588f addql #4,%sp
59aa8: 202a 000c movel %a2@(12),%d0
59aac: 222a 0010 movel %a2@(16),%d1
}
59ab0: 4cee 0c04 ffec moveml %fp@(-20),%d2/%a2-%a3
59ab6: 4e5e unlk %fp <== NOT EXECUTED
00059d46 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
59d46: 4e56 fff0 linkw %fp,#-16
59d4a: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
59d4e: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
59d52: 206b 0028 moveal %a3@(40),%a0
59d56: 2468 0034 moveal %a0@(52),%a2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: path:%s ino:%" PRId32 " flags:%04" PRIx32 " mode:%04" PRIx32 "\n",
pathname, ino, flags, mode);
rtems_rfs_rtems_lock (fs);
59d5a: 2f2a 007c movel %a2@(124),%sp@-
59d5e: 4eba fc14 jsr %pc@(59974 <rtems_rfs_rtems_lock.isra.1>)
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
59d62: 486e fffc pea %fp@(-4)
59d66: 42a7 clrl %sp@-
59d68: 2f2b 0018 movel %a3@(24),%sp@-
59d6c: 2f0a movel %a2,%sp@-
59d6e: 4eb9 0005 7d0a jsr 57d0a <rtems_rfs_file_open>
if (rc > 0)
59d74: 4fef 0014 lea %sp@(20),%sp
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
59d78: 2400 movel %d0,%d2
if (rc > 0)
59d7a: 6f16 bles 59d92 <rtems_rfs_rtems_file_open+0x4c> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
59d7c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59d7e: 4eba fb96 jsr %pc@(59916 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
59d82: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59d88: 588f addql #4,%sp <== NOT EXECUTED
59d8a: 2040 moveal %d0,%a0 <== NOT EXECUTED
59d8c: 70ff moveq #-1,%d0 <== NOT EXECUTED
59d8e: 2082 movel %d2,%a0@ <== NOT EXECUTED
59d90: 6030 bras 59dc2 <rtems_rfs_rtems_file_open+0x7c> <== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
59d92: 206e fffc moveal %fp@(-4),%a0
59d96: 2068 001a moveal %a0@(26),%a0
59d9a: 4868 007c pea %a0@(124)
59d9e: 2f28 0090 movel %a0@(144),%sp@-
59da2: 4eb9 0005 4f90 jsr 54f90 <rtems_rfs_block_get_size>
rtems_rfs_rtems_set_iop_file_handle (iop, file);
59da8: 276e fffc 001c movel %fp@(-4),%a3@(28)
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
59dae: 2740 0004 movel %d0,%a3@(4)
59db2: 2741 0008 movel %d1,%a3@(8)
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
59db6: 2f0a movel %a2,%sp@-
59db8: 4eba fb5c jsr %pc@(59916 <rtems_rfs_rtems_unlock>)
return 0;
59dbc: 4fef 000c lea %sp@(12),%sp
59dc0: 4280 clrl %d0
}
59dc2: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
59dc8: 4e5e unlk %fp <== NOT EXECUTED
00059c10 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
59c10: 4e56 ffd8 linkw %fp,#-40
59c14: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
59c18: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
59c1c: 246b 001c moveal %a3@(28),%a2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
59c20: 206a 001a moveal %a2@(26),%a0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
59c24: 2068 0090 moveal %a0@(144),%a0
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
59c28: 2f28 007c movel %a0@(124),%sp@-
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
59c2c: 282e 0010 movel %fp@(16),%d4
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
59c30: 4eba fd42 jsr %pc@(59974 <rtems_rfs_rtems_lock.isra.1>)
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
59c34: 206a 001a moveal %a2@(26),%a0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
59c38: 242b 000c movel %a3@(12),%d2
59c3c: 262b 0010 movel %a3@(16),%d3
59c40: 4868 007c pea %a0@(124)
59c44: 2f28 0090 movel %a0@(144),%sp@-
if (pos < rtems_rfs_file_size (file))
59c48: 2a02 movel %d2,%d5
59c4a: 2c03 movel %d3,%d6
59c4c: 4eb9 0005 4f90 jsr 54f90 <rtems_rfs_block_get_size>
59c52: 4fef 000c lea %sp@(12),%sp
59c56: 9c81 subl %d1,%d6
59c58: 9b80 subxl %d0,%d5
59c5a: 6562 bcss 59cbe <rtems_rfs_rtems_file_read+0xae> <== ALWAYS TAKEN
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
uint8_t* data = buffer;
ssize_t read = 0;
59c5c: 4282 clrl %d2 <== NOT EXECUTED
59c5e: 607e bras 59cde <rtems_rfs_rtems_file_read+0xce> <== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
59c60: 4878 0001 pea 1 <ADD>
59c64: 2f06 movel %d6,%sp@-
59c66: 2f0a movel %a2,%sp@-
59c68: 4e95 jsr %a5@
if (rc > 0)
59c6a: 4fef 000c lea %sp@(12),%sp
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
59c6e: 2600 movel %d0,%d3
if (rc > 0)
59c70: 6e3e bgts 59cb0 <rtems_rfs_rtems_file_read+0xa0> <== NEVER TAKEN
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
59c72: 202e fffc movel %fp@(-4),%d0
59c76: 6766 beqs 59cde <rtems_rfs_rtems_file_read+0xce> <== NEVER TAKEN
break;
if (size > count)
59c78: b880 cmpl %d0,%d4
59c7a: 6404 bccs 59c80 <rtems_rfs_rtems_file_read+0x70> <== ALWAYS TAKEN
size = count;
59c7c: 2d44 fffc movel %d4,%fp@(-4) <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
59c80: 262e fffc movel %fp@(-4),%d3
data += size;
count -= size;
59c84: 9883 subl %d3,%d4
read += size;
59c86: d483 addl %d3,%d2
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
59c88: 206a 000a moveal %a2@(10),%a0
59c8c: 2f03 movel %d3,%sp@-
59c8e: 2068 001e moveal %a0@(30),%a0
59c92: d1ea 0012 addal %a2@(18),%a0
59c96: 2f08 movel %a0,%sp@-
59c98: 2f05 movel %d5,%sp@-
data += size;
59c9a: da83 addl %d3,%d5
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
59c9c: 4e94 jsr %a4@
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
59c9e: 4878 0001 pea 1 <ADD>
59ca2: 2f03 movel %d3,%sp@-
59ca4: 2f0a movel %a2,%sp@-
59ca6: 4e93 jsr %a3@
if (rc > 0)
59ca8: 4fef 0018 lea %sp@(24),%sp
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
59cac: 2600 movel %d0,%d3
if (rc > 0)
59cae: 6f2a bles 59cda <rtems_rfs_rtems_file_read+0xca> <== ALWAYS TAKEN
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
59cb0: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59cb6: 74ff moveq #-1,%d2 <== NOT EXECUTED
59cb8: 2040 moveal %d0,%a0 <== NOT EXECUTED
59cba: 2083 movel %d3,%a0@ <== NOT EXECUTED
59cbc: 6020 bras 59cde <rtems_rfs_rtems_file_read+0xce> <== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
59cbe: 2c0e movel %fp,%d6
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
59cc0: 4282 clrl %d2
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
59cc2: 5986 subql #4,%d6
59cc4: 4bf9 0005 75ca lea 575ca <rtems_rfs_file_io_start>,%a5
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
59cca: 49f9 0005 b134 lea 5b134 <memcpy>,%a4
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
59cd0: 47f9 0005 7790 lea 57790 <rtems_rfs_file_io_end>,%a3
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
59cd6: 2a2e 000c movel %fp@(12),%d5
{
while (count)
59cda: 4a84 tstl %d4
59cdc: 6682 bnes 59c60 <rtems_rfs_rtems_file_read+0x50>
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
59cde: 206a 001a moveal %a2@(26),%a0
59ce2: 2f28 0090 movel %a0@(144),%sp@-
59ce6: 4eba fc2e jsr %pc@(59916 <rtems_rfs_rtems_unlock>)
return read;
}
59cea: 2002 movel %d2,%d0
59cec: 4cee 3c7c ffd8 moveml %fp@(-40),%d2-%d6/%a2-%a5
59cf2: 4e5e unlk %fp <== NOT EXECUTED
00059aba <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
59aba: 4e56 ffd4 linkw %fp,#-44
59abe: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
59ac2: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
59ac6: 246b 001c moveal %a3@(28),%a2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
59aca: 206a 001a moveal %a2@(26),%a0
.fpathconf_h = rtems_filesystem_default_fpathconf,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.rmnod_h = rtems_rfs_rtems_rmnod
};
59ace: 2068 0090 moveal %a0@(144),%a0
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
59ad2: 2f28 007c movel %a0@(124),%sp@-
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
59ad6: 282e 0010 movel %fp@(16),%d4
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
59ada: 4eba fe98 jsr %pc@(59974 <rtems_rfs_rtems_lock.isra.1>)
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
59ade: 206a 001a moveal %a2@(26),%a0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
59ae2: 242b 000c movel %a3@(12),%d2
59ae6: 262b 0010 movel %a3@(16),%d3
59aea: 4868 007c pea %a0@(124)
59aee: 2f28 0090 movel %a0@(144),%sp@-
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
59af2: 2a02 movel %d2,%d5
59af4: 2c03 movel %d3,%d6
59af6: 4eb9 0005 4f90 jsr 54f90 <rtems_rfs_block_get_size>
59afc: 4fef 000c lea %sp@(12),%sp
59b00: 9c81 subl %d1,%d6
59b02: 9b80 subxl %d0,%d5
59b04: 653a bcss 59b40 <rtems_rfs_rtems_file_write+0x86>
{
rc = rtems_rfs_file_set_size (file, pos + 1);
59b06: 4280 clrl %d0
59b08: 7201 moveq #1,%d1
59b0a: d283 addl %d3,%d1
59b0c: d182 addxl %d2,%d0
59b0e: 2f01 movel %d1,%sp@-
59b10: 2f00 movel %d0,%sp@-
59b12: 2f0a movel %a2,%sp@-
59b14: 4eb9 0005 7a0c jsr 57a0c <rtems_rfs_file_set_size>
if (rc)
59b1a: 4fef 000c lea %sp@(12),%sp
* more.
*/
if (pos >= rtems_rfs_file_size (file))
{
rc = rtems_rfs_file_set_size (file, pos + 1);
59b1e: 2a00 movel %d0,%d5
if (rc)
59b20: 671e beqs 59b40 <rtems_rfs_rtems_file_write+0x86><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
59b22: 206a 001a moveal %a2@(26),%a0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
59b26: 74ff moveq #-1,%d2 <== NOT EXECUTED
if (pos >= rtems_rfs_file_size (file))
{
rc = rtems_rfs_file_set_size (file, pos + 1);
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
59b28: 2f28 0090 movel %a0@(144),%sp@- <== NOT EXECUTED
59b2c: 4eba fde8 jsr %pc@(59916 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
59b30: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59b36: 588f addql #4,%sp <== NOT EXECUTED
59b38: 2040 moveal %d0,%a0 <== NOT EXECUTED
59b3a: 2085 movel %d5,%a0@ <== NOT EXECUTED
59b3c: 6000 00c6 braw 59c04 <rtems_rfs_rtems_file_write+0x14a><== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
59b40: 486a 000e pea %a2@(14)
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
59b44: 2e0e movel %fp,%d7
59b46: 5987 subql #4,%d7
59b48: 2c3c 0005 75ca movel #357834,%d6
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
59b4e: 4bf9 0005 b134 lea 5b134 <memcpy>,%a5
data += size;
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
59b54: 49f9 0005 7790 lea 57790 <rtems_rfs_file_io_end>,%a4
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
59b5a: 2f03 movel %d3,%sp@-
59b5c: 2f02 movel %d2,%sp@-
59b5e: 206a 001a moveal %a2@(26),%a0
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
const uint8_t* data = buffer;
ssize_t write = 0;
59b62: 4282 clrl %d2
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
59b64: 2f28 0090 movel %a0@(144),%sp@-
59b68: 4eb9 0005 4ebe jsr 54ebe <rtems_rfs_block_get_bpos>
const void* buffer,
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
const uint8_t* data = buffer;
59b6e: 262e 000c movel %fp@(12),%d3
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
59b72: 4fef 0010 lea %sp@(16),%sp
59b76: 605e bras 59bd6 <rtems_rfs_rtems_file_write+0x11c>
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
59b78: 42a7 clrl %sp@-
59b7a: 2046 moveal %d6,%a0
59b7c: 2f07 movel %d7,%sp@-
rtems_rfs_file_set_bpos (file, pos);
while (count)
{
size_t size = count;
59b7e: 2d44 fffc movel %d4,%fp@(-4)
rc = rtems_rfs_file_io_start (file, &size, false);
59b82: 2f0a movel %a2,%sp@-
59b84: 4e90 jsr %a0@
if (rc)
59b86: 4fef 000c lea %sp@(12),%sp
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
59b8a: 2a00 movel %d0,%d5
if (rc)
59b8c: 663a bnes 59bc8 <rtems_rfs_rtems_file_write+0x10e><== NEVER TAKEN
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
59b8e: b8ae fffc cmpl %fp@(-4),%d4
59b92: 6404 bccs 59b98 <rtems_rfs_rtems_file_write+0xde><== NEVER TAKEN
size = count;
59b94: 2d44 fffc movel %d4,%fp@(-4)
memcpy (rtems_rfs_file_data (file), data, size);
59b98: 206a 000a moveal %a2@(10),%a0
59b9c: 2f2e fffc movel %fp@(-4),%sp@-
59ba0: 2f03 movel %d3,%sp@-
59ba2: 2068 001e moveal %a0@(30),%a0
59ba6: d1ea 0012 addal %a2@(18),%a0
59baa: 2f08 movel %a0,%sp@-
59bac: 4e95 jsr %a5@
data += size;
59bae: 202e fffc movel %fp@(-4),%d0
59bb2: d680 addl %d0,%d3
count -= size;
59bb4: 9880 subl %d0,%d4
write += size;
59bb6: d480 addl %d0,%d2
rc = rtems_rfs_file_io_end (file, size, false);
59bb8: 42a7 clrl %sp@-
59bba: 2f00 movel %d0,%sp@-
59bbc: 2f0a movel %a2,%sp@-
59bbe: 4e94 jsr %a4@
if (rc)
59bc0: 4fef 0018 lea %sp@(24),%sp
data += size;
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
59bc4: 2a00 movel %d0,%d5
if (rc)
59bc6: 670e beqs 59bd6 <rtems_rfs_rtems_file_write+0x11c><== ALWAYS TAKEN
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
59bc8: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
59bce: 74ff moveq #-1,%d2 <== NOT EXECUTED
59bd0: 2040 moveal %d0,%a0 <== NOT EXECUTED
59bd2: 2085 movel %d5,%a0@ <== NOT EXECUTED
59bd4: 6004 bras 59bda <rtems_rfs_rtems_file_write+0x120><== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
59bd6: 4a84 tstl %d4
59bd8: 669e bnes 59b78 <rtems_rfs_rtems_file_write+0xbe>
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
59bda: 206a 001a moveal %a2@(26),%a0
59bde: 4868 007c pea %a0@(124)
59be2: 2f28 0090 movel %a0@(144),%sp@-
59be6: 4eb9 0005 4f90 jsr 54f90 <rtems_rfs_block_get_size>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
59bec: 206a 001a moveal %a2@(26),%a0
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
59bf0: 2740 0004 movel %d0,%a3@(4)
59bf4: 2741 0008 movel %d1,%a3@(8)
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
59bf8: 2f28 0090 movel %a0@(144),%sp@-
59bfc: 4eba fd18 jsr %pc@(59916 <rtems_rfs_rtems_unlock>)
return write;
59c00: 4fef 000c lea %sp@(12),%sp
}
59c04: 2002 movel %d2,%d0
59c06: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
59c0c: 4e5e unlk %fp <== NOT EXECUTED
0004ef6a <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
4ef6a: 4e56 ffc0 linkw %fp,#-64
4ef6e: 206e 0008 moveal %fp@(8),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4ef72: 2268 0010 moveal %a0@(16),%a1
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
4ef76: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4ef7a: 2410 movel %a0@,%d2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ef7c: 49ee ffda lea %fp@(-38),%a4
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4ef80: 2669 0034 moveal %a1@(52),%a3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
4ef84: 2f2b 007c movel %a3@(124),%sp@-
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
4ef88: 246e 000c moveal %fp@(12),%a2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
4ef8c: 4eba f294 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4ef90: 4878 0001 pea 1 <ADD>
4ef94: 2f0c movel %a4,%sp@-
4ef96: 2f02 movel %d2,%sp@-
4ef98: 2f0b movel %a3,%sp@-
4ef9a: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc)
4efa0: 4fef 0014 lea %sp@(20),%sp
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4efa4: 2400 movel %d0,%d2
if (rc)
4efa6: 670a beqs 4efb2 <rtems_rfs_rtems_fstat+0x48> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4efa8: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4efaa: 4eba f058 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
4efae: 6000 022a braw 4f1da <rtems_rfs_rtems_fstat+0x270> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
}
mode = rtems_rfs_inode_get_mode (&inode);
4efb2: 286c 000c moveal %a4@(12),%a4
4efb6: 4282 clrl %d2
4efb8: 142c 0002 moveb %a4@(2),%d2
4efbc: 4280 clrl %d0
4efbe: 102c 0003 moveb %a4@(3),%d0
4efc2: e18a lsll #8,%d2
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
4efc4: 8480 orl %d0,%d2
4efc6: 2002 movel %d2,%d0
4efc8: 0280 0000 f000 andil #61440,%d0
4efce: 0c80 0000 2000 cmpil #8192,%d0
4efd4: 6708 beqs 4efde <rtems_rfs_rtems_fstat+0x74> <== NEVER TAKEN
4efd6: 0c80 0000 6000 cmpil #24576,%d0
4efdc: 6620 bnes 4effe <rtems_rfs_rtems_fstat+0x94> <== ALWAYS TAKEN
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
4efde: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4efe2: 4bfa f0cc lea %pc@(4e0b0 <rtems_rfs_inode_get_block.isra.9>),%a5<== NOT EXECUTED
4efe6: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4efe8: 4e95 jsr %a5@ <== NOT EXECUTED
4efea: 508f addql #8,%sp <== NOT EXECUTED
4efec: 2600 movel %d0,%d3 <== NOT EXECUTED
4efee: 42a7 clrl %sp@- <== NOT EXECUTED
4eff0: 2f0c movel %a4,%sp@- <== NOT EXECUTED
4eff2: 4e95 jsr %a5@ <== NOT EXECUTED
4eff4: 508f addql #8,%sp <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
4eff6: 2540 0016 movel %d0,%a2@(22) <== NOT EXECUTED
4effa: 2543 001a movel %d3,%a2@(26) <== NOT EXECUTED
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
4effe: 206b 000c moveal %a3@(12),%a0
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
4f002: 49ee ffda lea %fp@(-38),%a4
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
4f006: 2010 movel %a0@,%d0
4f008: 2228 0004 movel %a0@(4),%d1
buf->st_ino = rtems_rfs_inode_ino (&inode);
4f00c: 256e ffe2 0008 movel %fp@(-30),%a2@(8)
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
4f012: 2480 movel %d0,%a2@
4f014: 2541 0004 movel %d1,%a2@(4)
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
4f018: 2f02 movel %d2,%sp@-
4f01a: 4eb9 0004 f3cc jsr 4f3cc <rtems_rfs_rtems_mode>
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
4f020: 206c 000c moveal %a4@(12),%a0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
4f024: 4281 clrl %d1
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
4f026: 2540 000c movel %d0,%a2@(12)
4f02a: 4280 clrl %d0
4f02c: 1010 moveb %a0@,%d0
4f02e: 1228 0001 moveb %a0@(1),%d1
4f032: e188 lsll #8,%d0
4f034: 8081 orl %d1,%d0
if (links == 0xffff)
4f036: 3200 movew %d0,%d1
links = 0;
4f038: 0c81 0000 ffff cmpil #65535,%d1
4f03e: 56c1 sne %d1
4f040: 4881 extw %d1
4f042: c081 andl %d1,%d0
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
4f044: 4281 clrl %d1
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
4f046: 3540 0010 movew %d0,%a2@(16)
4f04a: 4280 clrl %d0
4f04c: 1028 0006 moveb %a0@(6),%d0
4f050: 1228 0007 moveb %a0@(7),%d1
4f054: e188 lsll #8,%d0
4f056: 8081 orl %d1,%d0
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
4f058: 7218 moveq #24,%d1
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
4f05a: 3540 0012 movew %d0,%a2@(18)
4f05e: 4280 clrl %d0
4f060: 1028 0004 moveb %a0@(4),%d0
4f064: e3a8 lsll %d1,%d0
4f066: 4281 clrl %d1
4f068: 1228 0005 moveb %a0@(5),%d1
4f06c: 4841 swap %d1
4f06e: 4241 clrw %d1
4f070: 8081 orl %d1,%d0
4f072: 4240 clrw %d0
4f074: 4840 swap %d0
4f076: 3540 0014 movew %d0,%a2@(20)
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
4f07a: 2eae ffe2 movel %fp@(-30),%sp@
4f07e: 2f0b movel %a3,%sp@-
4f080: 4eb9 0005 7cde jsr 57cde <rtems_rfs_file_get_shared>
4f086: 242a 000c movel %a2@(12),%d2
4f08a: 2040 moveal %d0,%a0
if (shared)
4f08c: 508f addql #8,%sp
4f08e: 0282 0000 f000 andil #61440,%d2
4f094: 4a80 tstl %d0
4f096: 673a beqs 4f0d2 <rtems_rfs_rtems_fstat+0x168> <== ALWAYS TAKEN
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
4f098: 2568 0084 0026 movel %a0@(132),%a2@(38) <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
4f09e: 2568 0088 002e movel %a0@(136),%a2@(46) <== NOT EXECUTED
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
4f0a4: 2568 008c 0036 movel %a0@(140),%a2@(54) <== NOT EXECUTED
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
4f0aa: 2568 007c 0042 movel %a0@(124),%a2@(66) <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
4f0b0: 0c82 0000 a000 cmpil #40960,%d2 <== NOT EXECUTED
4f0b6: 660a bnes 4f0c2 <rtems_rfs_rtems_fstat+0x158> <== NOT EXECUTED
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
4f0b8: 4280 clrl %d0 <== NOT EXECUTED
4f0ba: 3028 0082 movew %a0@(130),%d0 <== NOT EXECUTED
4f0be: 6000 00dc braw 4f19c <rtems_rfs_rtems_fstat+0x232> <== NOT EXECUTED
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
4f0c2: 4868 007c pea %a0@(124) <== NOT EXECUTED
4f0c6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f0c8: 4eb9 0005 4f90 jsr 54f90 <rtems_rfs_block_get_size> <== NOT EXECUTED
4f0ce: 6000 00e0 braw 4f1b0 <rtems_rfs_rtems_fstat+0x246> <== NOT EXECUTED
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
4f0d2: 206c 000c moveal %a4@(12),%a0
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
4f0d6: 4280 clrl %d0
4f0d8: 1028 0010 moveb %a0@(16),%d0
4f0dc: 7218 moveq #24,%d1
4f0de: e3a8 lsll %d1,%d0
4f0e0: 4281 clrl %d1
4f0e2: 1228 0011 moveb %a0@(17),%d1
4f0e6: 4841 swap %d1
4f0e8: 4241 clrw %d1
4f0ea: 8081 orl %d1,%d0
4f0ec: 4281 clrl %d1
4f0ee: 1228 0013 moveb %a0@(19),%d1
4f0f2: 8081 orl %d1,%d0
4f0f4: 1228 0012 moveb %a0@(18),%d1
4f0f8: e189 lsll #8,%d1
4f0fa: 8081 orl %d1,%d0
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
4f0fc: 7218 moveq #24,%d1
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
4f0fe: 2540 0026 movel %d0,%a2@(38)
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
4f102: 4280 clrl %d0
4f104: 1028 0014 moveb %a0@(20),%d0
4f108: e3a8 lsll %d1,%d0
4f10a: 4281 clrl %d1
4f10c: 1228 0015 moveb %a0@(21),%d1
4f110: 4841 swap %d1
4f112: 4241 clrw %d1
4f114: 8081 orl %d1,%d0
4f116: 4281 clrl %d1
4f118: 1228 0017 moveb %a0@(23),%d1
4f11c: 8081 orl %d1,%d0
4f11e: 1228 0016 moveb %a0@(22),%d1
4f122: e189 lsll #8,%d1
4f124: 8081 orl %d1,%d0
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
4f126: 7218 moveq #24,%d1
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
4f128: 2540 002e movel %d0,%a2@(46)
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
4f12c: 4280 clrl %d0
4f12e: 1028 0018 moveb %a0@(24),%d0
4f132: e3a8 lsll %d1,%d0
4f134: 4281 clrl %d1
4f136: 1228 0019 moveb %a0@(25),%d1
4f13a: 4841 swap %d1
4f13c: 4241 clrw %d1
4f13e: 8081 orl %d1,%d0
4f140: 4281 clrl %d1
4f142: 1228 001b moveb %a0@(27),%d1
4f146: 8081 orl %d1,%d0
4f148: 1228 001a moveb %a0@(26),%d1
4f14c: e189 lsll #8,%d1
4f14e: 8081 orl %d1,%d0
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
4f150: 7218 moveq #24,%d1
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
4f152: 2540 0036 movel %d0,%a2@(54)
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
4f156: 4280 clrl %d0
4f158: 1028 000c moveb %a0@(12),%d0
4f15c: e3a8 lsll %d1,%d0
4f15e: 4281 clrl %d1
4f160: 1228 000d moveb %a0@(13),%d1
4f164: 4841 swap %d1
4f166: 4241 clrw %d1
4f168: 8081 orl %d1,%d0
4f16a: 4281 clrl %d1
4f16c: 1228 000f moveb %a0@(15),%d1
4f170: 8081 orl %d1,%d0
4f172: 1228 000e moveb %a0@(14),%d1
4f176: e189 lsll #8,%d1
4f178: 8081 orl %d1,%d0
4f17a: 2540 0042 movel %d0,%a2@(66)
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
4f17e: 0c82 0000 a000 cmpil #40960,%d2
4f184: 6620 bnes 4f1a6 <rtems_rfs_rtems_fstat+0x23c>
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
4f186: 4280 clrl %d0
4f188: 1028 000a moveb %a0@(10),%d0
4f18c: 4281 clrl %d1
4f18e: 1228 000b moveb %a0@(11),%d1
4f192: e188 lsll #8,%d0
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
4f194: 8081 orl %d1,%d0
4f196: 0280 0000 ffff andil #65535,%d0
4f19c: 42aa 001e clrl %a2@(30)
4f1a0: 2540 0022 movel %d0,%a2@(34)
4f1a4: 6014 bras 4f1ba <rtems_rfs_rtems_fstat+0x250>
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
4f1a6: 2f0c movel %a4,%sp@-
4f1a8: 2f0b movel %a3,%sp@-
4f1aa: 4eb9 0004 dec4 jsr 4dec4 <rtems_rfs_inode_get_size>
4f1b0: 508f addql #8,%sp
4f1b2: 2540 001e movel %d0,%a2@(30)
4f1b6: 2541 0022 movel %d1,%a2@(34)
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
4f1ba: 256b 0008 003e movel %a3@(8),%a2@(62)
rc = rtems_rfs_inode_close (fs, &inode);
4f1c0: 486e ffda pea %fp@(-38)
4f1c4: 2f0b movel %a3,%sp@-
4f1c6: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
if (rc > 0)
4f1cc: 508f addql #8,%sp
4f1ce: 41fa ee34 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
rc = rtems_rfs_inode_close (fs, &inode);
4f1d2: 2400 movel %d0,%d2
if (rc > 0)
4f1d4: 6f14 bles 4f1ea <rtems_rfs_rtems_fstat+0x280> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4f1d6: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4f1d8: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: closing inode", rc);
4f1da: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4f1e0: 588f addql #4,%sp <== NOT EXECUTED
4f1e2: 2040 moveal %d0,%a0 <== NOT EXECUTED
4f1e4: 70ff moveq #-1,%d0 <== NOT EXECUTED
4f1e6: 2082 movel %d2,%a0@ <== NOT EXECUTED
4f1e8: 6008 bras 4f1f2 <rtems_rfs_rtems_fstat+0x288> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4f1ea: 2f0b movel %a3,%sp@-
4f1ec: 4e90 jsr %a0@
return 0;
4f1ee: 588f addql #4,%sp
4f1f0: 4280 clrl %d0
}
4f1f2: 4cee 3c0c ffc0 moveml %fp@(-64),%d2-%d3/%a2-%a5
4f1f8: 4e5e unlk %fp <== NOT EXECUTED
0004e154 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
4e154: 4e56 fff0 linkw %fp,#-16
4e158: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
4e15c: 4878 0004 pea 4 <CONTEXT_ARG>
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
4e160: 266e 0008 moveal %fp@(8),%a3
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
4e164: 4eb9 0004 5af0 jsr 45af0 <malloc>
if (!rtems)
4e16a: 588f addql #4,%sp
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
4e16c: 2440 moveal %d0,%a2
if (!rtems)
4e16e: 4a80 tstl %d0
4e170: 660e bnes 4e180 <rtems_rfs_rtems_initialise+0x2c><== ALWAYS TAKEN
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
4e172: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e178: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e17a: 700c moveq #12,%d0 <== NOT EXECUTED
4e17c: 2080 movel %d0,%a0@ <== NOT EXECUTED
4e17e: 6024 bras 4e1a4 <rtems_rfs_rtems_initialise+0x50><== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
4e180: 2f00 movel %d0,%sp@-
rtems = malloc (sizeof (rtems_rfs_rtems_private));
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
4e182: 4292 clrl %a2@
rc = rtems_rfs_mutex_create (&rtems->access);
4e184: 4eb9 0005 9210 jsr 59210 <rtems_rfs_mutex_create>
if (rc > 0)
4e18a: 588f addql #4,%sp
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
4e18c: 2400 movel %d0,%d2
if (rc > 0)
4e18e: 6f18 bles 4e1a8 <rtems_rfs_rtems_initialise+0x54><== ALWAYS TAKEN
{
free (rtems);
4e190: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e192: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
4e198: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e19e: 588f addql #4,%sp <== NOT EXECUTED
4e1a0: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e1a2: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e1a4: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e1a6: 6070 bras 4e218 <rtems_rfs_rtems_initialise+0xc4><== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
4e1a8: 2f12 movel %a2@,%sp@-
4e1aa: 4eba ff50 jsr %pc@(4e0fc <rtems_rfs_mutex_lock.isra.15>)
if (rc > 0)
4e1ae: 588f addql #4,%sp
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
4e1b0: 2400 movel %d0,%d2
if (rc > 0)
4e1b2: 6f1e bles 4e1d2 <rtems_rfs_rtems_initialise+0x7e><== ALWAYS TAKEN
{
rtems_rfs_mutex_destroy (&rtems->access);
4e1b4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e1b6: 4eb9 0005 9274 jsr 59274 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
4e1bc: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e1be: 4eb9 0004 54d0 jsr 454d0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
4e1c4: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e1ca: 508f addql #8,%sp <== NOT EXECUTED
4e1cc: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e1ce: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e1d0: 60d2 bras 4e1a4 <rtems_rfs_rtems_initialise+0x50><== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, 0, &fs);
4e1d2: 486e fffc pea %fp@(-4)
4e1d6: 42a7 clrl %sp@-
4e1d8: 2f0a movel %a2,%sp@-
4e1da: 2f2b 0070 movel %a3@(112),%sp@-
4e1de: 4eb9 0005 807c jsr 5807c <rtems_rfs_fs_open>
if (rc)
4e1e4: 4fef 0010 lea %sp@(16),%sp
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, 0, &fs);
4e1e8: 2400 movel %d0,%d2
if (rc)
4e1ea: 66a4 bnes 4e190 <rtems_rfs_rtems_initialise+0x3c><== NEVER TAKEN
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
4e1ec: 7201 moveq #1,%d1
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
4e1ee: 41f9 0006 c79e lea 6c79e <rtems_rfs_rtems_dir_handlers>,%a0
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
4e1f4: 202e fffc movel %fp@(-4),%d0
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
4e1f8: 2741 001c movel %d1,%a3@(28)
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
4e1fc: 223c 0006 addc movel #437724,%d1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
4e202: 2740 0034 movel %d0,%a3@(52)
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
4e206: 2748 0024 movel %a0,%a3@(36)
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
4e20a: 2741 0028 movel %d1,%a3@(40)
rtems_rfs_rtems_unlock (fs);
4e20e: 2f00 movel %d0,%sp@-
4e210: 4eba fdf2 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
return 0;
4e214: 588f addql #4,%sp
4e216: 4280 clrl %d0
}
4e218: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4e21e: 4e5e unlk %fp <== NOT EXECUTED
0004e34a <rtems_rfs_rtems_link>:
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
4e34a: 4e56 fff0 linkw %fp,#-16
4e34e: 206e 0008 moveal %fp@(8),%a0
4e352: 48d7 041c moveml %d2-%d4/%a2,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
4e356: 2268 0010 moveal %a0@(16),%a1
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
4e35a: 2810 movel %a0@,%d4
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
4e35c: 206e 000c moveal %fp@(12),%a0
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
4e360: 2469 0034 moveal %a1@(52),%a2
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
4e364: 2610 movel %a0@,%d3
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
4e366: 2f2a 007c movel %a2@(124),%sp@-
*/
static int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
4e36a: 242e 0010 movel %fp@(16),%d2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
4e36e: 4eba feb2 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
4e372: 2f02 movel %d2,%sp@-
4e374: 4eb9 0005 bf54 jsr 5bf54 <strlen>
4e37a: 4297 clrl %sp@
4e37c: 2f04 movel %d4,%sp@-
4e37e: 2f03 movel %d3,%sp@-
4e380: 2f00 movel %d0,%sp@-
4e382: 2f02 movel %d2,%sp@-
4e384: 2f0a movel %a2,%sp@-
4e386: 4eb9 0005 889c jsr 5889c <rtems_rfs_link>
if (rc)
4e38c: 4fef 001c lea %sp@(28),%sp
4e390: 41fa fc72 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
4e394: 2400 movel %d0,%d2
if (rc)
4e396: 6714 beqs 4e3ac <rtems_rfs_rtems_link+0x62> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e398: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e39a: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("link: linking", rc);
4e39c: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e3a2: 588f addql #4,%sp <== NOT EXECUTED
4e3a4: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e3a6: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e3a8: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e3aa: 6008 bras 4e3b4 <rtems_rfs_rtems_link+0x6a> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e3ac: 2f0a movel %a2,%sp@-
4e3ae: 4e90 jsr %a0@
return 0;
4e3b0: 588f addql #4,%sp
4e3b2: 4280 clrl %d0
}
4e3b4: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4e3ba: 4e5e unlk %fp <== NOT EXECUTED
00059974 <rtems_rfs_rtems_lock.isra.1>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
59974: 4e56 0000 linkw %fp,#0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
59978: 206e 0008 moveal %fp@(8),%a0
5997c: 2f02 movel %d2,%sp@-
5997e: 42a7 clrl %sp@-
59980: 42a7 clrl %sp@-
59982: 2f10 movel %a0@,%sp@-
59984: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
5998a: 4fef 000c lea %sp@(12),%sp
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
5998e: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
59990: 672c beqs 599be <rtems_rfs_rtems_lock.isra.1+0x4a><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
59992: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
59996: 42a7 clrl %sp@- <== NOT EXECUTED
59998: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
5999e: 508f addql #8,%sp <== NOT EXECUTED
599a0: 4a00 tstb %d0 <== NOT EXECUTED
599a2: 671a beqs 599be <rtems_rfs_rtems_lock.isra.1+0x4a><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
599a4: 2f02 movel %d2,%sp@- <== NOT EXECUTED
599a6: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
599ac: 2f00 movel %d0,%sp@- <== NOT EXECUTED
599ae: 4879 0006 adb6 pea 6adb6 <ramdisk_ops+0xbcc> <== NOT EXECUTED
599b4: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
599ba: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
}
599be: 242e fffc movel %fp@(-4),%d2
599c2: 4e5e unlk %fp <== NOT EXECUTED
00059682 <rtems_rfs_rtems_lock.isra.3>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
59682: 4e56 0000 linkw %fp,#0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
59686: 206e 0008 moveal %fp@(8),%a0
5968a: 2f02 movel %d2,%sp@-
5968c: 42a7 clrl %sp@-
5968e: 42a7 clrl %sp@-
59690: 2f10 movel %a0@,%sp@-
59692: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
59698: 4fef 000c lea %sp@(12),%sp
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
5969c: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
5969e: 672c beqs 596cc <rtems_rfs_rtems_lock.isra.3+0x4a><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
596a0: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
596a4: 42a7 clrl %sp@- <== NOT EXECUTED
596a6: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
596ac: 508f addql #8,%sp <== NOT EXECUTED
596ae: 4a00 tstb %d0 <== NOT EXECUTED
596b0: 671a beqs 596cc <rtems_rfs_rtems_lock.isra.3+0x4a><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
596b2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
596b4: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
596ba: 2f00 movel %d0,%sp@- <== NOT EXECUTED
596bc: 4879 0006 adb6 pea 6adb6 <ramdisk_ops+0xbcc> <== NOT EXECUTED
596c2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
596c8: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
}
596cc: 242e fffc movel %fp@(-4),%d2
596d0: 4e5e unlk %fp <== NOT EXECUTED
0004e784 <rtems_rfs_rtems_mknod>:
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
4e784: 4e56 ffb4 linkw %fp,#-76
4e788: 206e 0018 moveal %fp@(24),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e78c: 2268 0010 moveal %a0@(16),%a1
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
4e790: 48d7 0cfc moveml %d2-%d7/%a2-%a3,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e794: 2469 0034 moveal %a1@(52),%a2
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e798: 2810 movel %a0@,%d4
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
4e79a: 2f2a 007c movel %a2@(124),%sp@-
static int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
4e79e: 242e 0008 movel %fp@(8),%d2
4e7a2: 262e 000c movel %fp@(12),%d3
4e7a6: 2c2e 0010 movel %fp@(16),%d6
4e7aa: 2a2e 0014 movel %fp@(20),%d5
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
4e7ae: 4eba fa72 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
rtems_rfs_rtems_imode (mode),
4e7b2: 2f03 movel %d3,%sp@-
4e7b4: 4eb9 0004 f3c0 jsr 4f3c0 <rtems_rfs_rtems_imode>
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4e7ba: 2f02 movel %d2,%sp@-
rtems_rfs_rtems_imode (mode),
4e7bc: 3e00 movew %d0,%d7
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4e7be: 4eb9 0005 bf54 jsr 5bf54 <strlen>
4e7c4: 588f addql #4,%sp
4e7c6: 486e fffc pea %fp@(-4)
4e7ca: 42a7 clrl %sp@-
4e7cc: 42a7 clrl %sp@-
4e7ce: 4878 0001 pea 1 <ADD>
4e7d2: 3f07 movew %d7,%sp@-
4e7d4: 4267 clrw %sp@-
4e7d6: 2f00 movel %d0,%sp@-
4e7d8: 2f02 movel %d2,%sp@-
4e7da: 2f04 movel %d4,%sp@-
4e7dc: 2f0a movel %a2,%sp@-
4e7de: 4eb9 0004 dbd0 jsr 4dbd0 <rtems_rfs_inode_create>
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
4e7e4: 4fef 002c lea %sp@(44),%sp
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
4e7e8: 2400 movel %d0,%d2
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
4e7ea: 6f0a bles 4e7f6 <rtems_rfs_rtems_mknod+0x72>
{
rtems_rfs_rtems_unlock (fs);
4e7ec: 2f0a movel %a2,%sp@-
4e7ee: 4eba f814 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>)
4e7f2: 6000 00c2 braw 4e8b6 <rtems_rfs_rtems_mknod+0x132>
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e7f6: 4878 0001 pea 1 <ADD>
4e7fa: 240e movel %fp,%d2
4e7fc: 0682 ffff ffd6 addil #-42,%d2
4e802: 2f02 movel %d2,%sp@-
4e804: 2f2e fffc movel %fp@(-4),%sp@-
4e808: 2f0a movel %a2,%sp@-
4e80a: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
4e810: 4fef 0010 lea %sp@(16),%sp
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e814: 2800 movel %d0,%d4
if (rc > 0)
4e816: 6f18 bles 4e830 <rtems_rfs_rtems_mknod+0xac> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e818: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e81a: 4eba f7e8 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: inode open", rc);
4e81e: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e824: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e826: 2084 movel %d4,%a0@ <== NOT EXECUTED
4e828: 588f addql #4,%sp
4e82a: 70ff moveq #-1,%d0
4e82c: 6000 009e braw 4e8cc <rtems_rfs_rtems_mknod+0x148>
}
if (S_ISDIR(mode) || S_ISREG(mode))
4e830: 0283 0000 f000 andil #61440,%d3
4e836: 0c83 0000 4000 cmpil #16384,%d3
4e83c: 675e beqs 4e89c <rtems_rfs_rtems_mknod+0x118>
4e83e: 0c83 0000 8000 cmpil #32768,%d3
4e844: 6756 beqs 4e89c <rtems_rfs_rtems_mknod+0x118> <== ALWAYS TAKEN
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
4e846: 0c83 0000 2000 cmpil #8192,%d3 <== NOT EXECUTED
4e84c: 6708 beqs 4e856 <rtems_rfs_rtems_mknod+0xd2> <== NOT EXECUTED
4e84e: 0c83 0000 6000 cmpil #24576,%d3 <== NOT EXECUTED
4e854: 6624 bnes 4e87a <rtems_rfs_rtems_mknod+0xf6> <== NOT EXECUTED
{
int major;
int minor;
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_rfs_inode_set_block (&inode, 0, major);
4e856: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4e858: 240e movel %fp,%d2 <== NOT EXECUTED
4e85a: 0682 ffff ffd6 addil #-42,%d2 <== NOT EXECUTED
4e860: 47fa f6be lea %pc@(4df20 <rtems_rfs_inode_set_block>),%a3<== NOT EXECUTED
4e864: 42a7 clrl %sp@- <== NOT EXECUTED
4e866: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e868: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
4e86a: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4e86c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4e870: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e872: 4e93 jsr %a3@ <== NOT EXECUTED
if (S_ISDIR(mode) || S_ISREG(mode))
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
{
4e874: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4e878: 6022 bras 4e89c <rtems_rfs_rtems_mknod+0x118> <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
4e87a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
4e87c: 7416 moveq #22,%d2 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
4e87e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e880: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
4e886: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e888: 4eba f77a jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
4e88c: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e892: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
4e896: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e898: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e89a: 608e bras 4e82a <rtems_rfs_rtems_mknod+0xa6> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
4e89c: 486e ffd6 pea %fp@(-42)
4e8a0: 2f0a movel %a2,%sp@-
4e8a2: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
if (rc > 0)
4e8a8: 508f addql #8,%sp
4e8aa: 41fa f758 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
4e8ae: 2400 movel %d0,%d2
if (rc > 0)
4e8b0: 6f12 bles 4e8c4 <rtems_rfs_rtems_mknod+0x140> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e8b2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e8b4: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
4e8b6: 4eb9 0005 a88c jsr 5a88c <__errno>
4e8bc: 2040 moveal %d0,%a0
4e8be: 2082 movel %d2,%a0@
4e8c0: 6000 ff66 braw 4e828 <rtems_rfs_rtems_mknod+0xa4>
}
rtems_rfs_rtems_unlock (fs);
4e8c4: 2f0a movel %a2,%sp@-
4e8c6: 4e90 jsr %a0@
return 0;
4e8c8: 588f addql #4,%sp
4e8ca: 4280 clrl %d0
}
4e8cc: 4cee 0cfc ffb4 moveml %fp@(-76),%d2-%d7/%a2-%a3
4e8d2: 4e5e unlk %fp <== NOT EXECUTED
0004e6ba <rtems_rfs_rtems_node_type>:
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
4e6ba: 4e56 ffc8 linkw %fp,#-56
4e6be: 206e 0008 moveal %fp@(8),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e6c2: 2268 0010 moveal %a0@(16),%a1
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
4e6c6: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e6ca: 2410 movel %a0@,%d2
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e6cc: 47ee ffda lea %fp@(-38),%a3
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e6d0: 2469 0034 moveal %a1@(52),%a2
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
4e6d4: 2f2a 007c movel %a2@(124),%sp@-
4e6d8: 4eba fb48 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e6dc: 4878 0001 pea 1 <ADD>
4e6e0: 2f0b movel %a3,%sp@-
4e6e2: 2f02 movel %d2,%sp@-
4e6e4: 2f0a movel %a2,%sp@-
4e6e6: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
4e6ec: 4fef 0014 lea %sp@(20),%sp
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e6f0: 2400 movel %d0,%d2
if (rc > 0)
4e6f2: 6f12 bles 4e706 <rtems_rfs_rtems_node_type+0x4c> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e6f4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e6f6: 4eba f90c jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
4e6fa: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e700: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e702: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e704: 6066 bras 4e76c <rtems_rfs_rtems_node_type+0xb2> <== NOT EXECUTED
* system. All directory entries are links to an inode. A link such as a HARD
* link is actually the normal path to a regular file, directory, device
* etc's inode. Links to inodes can be considered "the real" one, yet they
* are all links.
*/
mode = rtems_rfs_inode_get_mode (&inode);
4e706: 206b 000c moveal %a3@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
4e70a: 4280 clrl %d0
4e70c: 1028 0002 moveb %a0@(2),%d0
4e710: e188 lsll #8,%d0
if (RTEMS_RFS_S_ISDIR (mode))
4e712: 0280 0000 f000 andil #61440,%d0
4e718: 0c80 0000 4000 cmpil #16384,%d0
4e71e: 671a beqs 4e73a <rtems_rfs_rtems_node_type+0x80>
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
4e720: 0c80 0000 a000 cmpil #40960,%d0
4e726: 6716 beqs 4e73e <rtems_rfs_rtems_node_type+0x84>
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
4e728: 0c80 0000 6000 cmpil #24576,%d0
4e72e: 6712 beqs 4e742 <rtems_rfs_rtems_node_type+0x88> <== NEVER TAKEN
4e730: 0c80 0000 2000 cmpil #8192,%d0
4e736: 660e bnes 4e746 <rtems_rfs_rtems_node_type+0x8c> <== ALWAYS TAKEN
4e738: 6008 bras 4e742 <rtems_rfs_rtems_node_type+0x88> <== NOT EXECUTED
* etc's inode. Links to inodes can be considered "the real" one, yet they
* are all links.
*/
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISDIR (mode))
type = RTEMS_FILESYSTEM_DIRECTORY;
4e73a: 7401 moveq #1,%d2
4e73c: 600a bras 4e748 <rtems_rfs_rtems_node_type+0x8e>
else if (RTEMS_RFS_S_ISLNK (mode))
type = RTEMS_FILESYSTEM_SYM_LINK;
4e73e: 7404 moveq #4,%d2
4e740: 6006 bras 4e748 <rtems_rfs_rtems_node_type+0x8e>
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
type = RTEMS_FILESYSTEM_DEVICE;
4e742: 7402 moveq #2,%d2 <== NOT EXECUTED
4e744: 6002 bras 4e748 <rtems_rfs_rtems_node_type+0x8e> <== NOT EXECUTED
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
4e746: 7405 moveq #5,%d2
rc = rtems_rfs_inode_close (fs, &inode);
4e748: 486e ffda pea %fp@(-38)
4e74c: 2f0a movel %a2,%sp@-
4e74e: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
if (rc > 0)
4e754: 508f addql #8,%sp
4e756: 41fa f8ac lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
type = RTEMS_FILESYSTEM_DEVICE;
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
rc = rtems_rfs_inode_close (fs, &inode);
4e75a: 2600 movel %d0,%d3
if (rc > 0)
4e75c: 6f14 bles 4e772 <rtems_rfs_rtems_node_type+0xb8> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e75e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e760: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
4e762: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e768: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e76a: 2083 movel %d3,%a0@ <== NOT EXECUTED
4e76c: 588f addql #4,%sp <== NOT EXECUTED
4e76e: 74ff moveq #-1,%d2 <== NOT EXECUTED
4e770: 6006 bras 4e778 <rtems_rfs_rtems_node_type+0xbe> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e772: 2f0a movel %a2,%sp@-
4e774: 4e90 jsr %a0@
return type;
4e776: 588f addql #4,%sp
}
4e778: 2002 movel %d2,%d0
4e77a: 4cee 0c0c ffc8 moveml %fp@(-56),%d2-%d3/%a2-%a3
4e780: 4e5e unlk %fp <== NOT EXECUTED
0004e234 <rtems_rfs_rtems_rename>:
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
4e234: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED
4e238: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
4e23c: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
4e240: 48d7 047c moveml %d2-%d6/%a2,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
4e244: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
rtems_rfs_ino new_parent;
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
4e248: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
4e24c: 2811 movel %a1@,%d4 <== NOT EXECUTED
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
4e24e: 226e 0010 moveal %fp@(16),%a1 <== NOT EXECUTED
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
4e252: 2410 movel %a0@,%d2 <== NOT EXECUTED
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
4e254: 2c11 movel %a1@,%d6 <== NOT EXECUTED
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
4e256: 2a28 0004 movel %a0@(4),%d5 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))
printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
ino, doff, new_parent, new_name);
rtems_rfs_rtems_lock (fs);
4e25a: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
static int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
4e25e: 262e 0014 movel %fp@(20),%d3 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))
printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
ino, doff, new_parent, new_name);
rtems_rfs_rtems_lock (fs);
4e262: 4eba ffbe jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)<== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, strlen (new_name), new_parent, ino, true);
4e266: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4e268: 4eb9 0005 bf54 jsr 5bf54 <strlen> <== NOT EXECUTED
4e26e: 7201 moveq #1,%d1 <== NOT EXECUTED
4e270: 2e81 movel %d1,%sp@ <== NOT EXECUTED
4e272: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e274: 2f06 movel %d6,%sp@- <== NOT EXECUTED
4e276: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4e278: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4e27a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e27c: 4eb9 0005 889c jsr 5889c <rtems_rfs_link> <== NOT EXECUTED
if (rc)
4e282: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, strlen (new_name), new_parent, ino, true);
4e286: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc)
4e288: 6712 beqs 4e29c <rtems_rfs_rtems_rename+0x68> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e28a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e28c: 4eba fd76 jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: linking", rc);
4e290: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e296: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e298: 2083 movel %d3,%a0@ <== NOT EXECUTED
4e29a: 602c bras 4e2c8 <rtems_rfs_rtems_rename+0x94> <== NOT EXECUTED
/*
* Unlink all inodes even directories with the dir option as false because a
* directory may not be empty.
*/
rc = rtems_rfs_unlink (fs, old_parent, ino, doff,
4e29c: 4878 0002 pea 2 <DOUBLE_FLOAT> <== NOT EXECUTED
4e2a0: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4e2a2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e2a4: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4e2a6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e2a8: 4eb9 0005 8a4a jsr 58a4a <rtems_rfs_unlink> <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
4e2ae: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
4e2b2: 41fa fd50 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
/*
* Unlink all inodes even directories with the dir option as false because a
* directory may not be empty.
*/
rc = rtems_rfs_unlink (fs, old_parent, ino, doff,
4e2b6: 2400 movel %d0,%d2 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
4e2b8: 6714 beqs 4e2ce <rtems_rfs_rtems_rename+0x9a> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e2ba: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e2bc: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: unlinking", rc);
4e2be: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e2c4: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e2c6: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e2c8: 588f addql #4,%sp <== NOT EXECUTED
4e2ca: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e2cc: 6008 bras 4e2d6 <rtems_rfs_rtems_rename+0xa2> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e2ce: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e2d0: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
4e2d2: 588f addql #4,%sp <== NOT EXECUTED
4e2d4: 4280 clrl %d0 <== NOT EXECUTED
}
4e2d6: 4cee 047c ffe8 moveml %fp@(-24),%d2-%d6/%a2 <== NOT EXECUTED
4e2dc: 4e5e unlk %fp <== NOT EXECUTED
0004e3be <rtems_rfs_rtems_rmnod>:
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
4e3be: 4e56 fff0 linkw %fp,#-16 <== NOT EXECUTED
4e3c2: 206e 000c moveal %fp@(12),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e3c6: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
4e3ca: 48d7 041c moveml %d2-%d4/%a2,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e3ce: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
4e3d2: 226e 0008 moveal %fp@(8),%a1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e3d6: 2610 movel %a0@,%d3 <== NOT EXECUTED
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
4e3d8: 2411 movel %a1@,%d2 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
4e3da: 2828 0004 movel %a0@(4),%d4 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RMNOD))
printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
4e3de: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
4e3e2: 4eba fe3e jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)<== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
4e3e6: 42a7 clrl %sp@- <== NOT EXECUTED
4e3e8: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4e3ea: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4e3ec: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e3ee: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e3f0: 4eb9 0005 8a4a jsr 58a4a <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
4e3f6: 4fef 0018 lea %sp@(24),%sp <== NOT EXECUTED
4e3fa: 41fa fc08 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
4e3fe: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
4e400: 6714 beqs 4e416 <rtems_rfs_rtems_rmnod+0x58> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e402: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e404: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("rmnod: unlinking", rc);
4e406: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e40c: 588f addql #4,%sp <== NOT EXECUTED
4e40e: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e410: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e412: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e414: 6008 bras 4e41e <rtems_rfs_rtems_rmnod+0x60> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e416: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e418: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
4e41a: 588f addql #4,%sp <== NOT EXECUTED
4e41c: 4280 clrl %d0 <== NOT EXECUTED
}
4e41e: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 <== NOT EXECUTED
4e424: 4e5e unlk %fp <== NOT EXECUTED
0004f330 <rtems_rfs_rtems_set_handlers>:
4f330: 4280 clrl %d0
4f332: 4281 clrl %d1
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
4f334: 4e56 0000 linkw %fp,#0
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
4f338: 226e 000c moveal %fp@(12),%a1
4f33c: 2269 000c moveal %a1@(12),%a1
4f340: 1029 0002 moveb %a1@(2),%d0
4f344: 1229 0003 moveb %a1@(3),%d1
4f348: e188 lsll #8,%d0
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
4f34a: 206e 0008 moveal %fp@(8),%a0
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
4f34e: 8081 orl %d1,%d0
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
4f350: 42a8 0008 clrl %a0@(8)
if (RTEMS_RFS_S_ISDIR (mode))
4f354: 2200 movel %d0,%d1
4f356: 0281 0000 f000 andil #61440,%d1
4f35c: 0c81 0000 4000 cmpil #16384,%d1
4f362: 6608 bnes 4f36c <rtems_rfs_rtems_set_handlers+0x3c>
loc->handlers = rtems_rfs_rtems_handlers (dir);
4f364: 203c 0006 c79e movel #444318,%d0
4f36a: 6016 bras 4f382 <rtems_rfs_rtems_set_handlers+0x52>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
4f36c: 0c81 0000 2000 cmpil #8192,%d1
4f372: 6708 beqs 4f37c <rtems_rfs_rtems_set_handlers+0x4c><== NEVER TAKEN
4f374: 0c81 0000 6000 cmpil #24576,%d1
4f37a: 660e bnes 4f38a <rtems_rfs_rtems_set_handlers+0x5a><== ALWAYS TAKEN
loc->handlers = rtems_rfs_rtems_handlers (device);
4f37c: 203c 0006 c766 movel #444262,%d0 <== NOT EXECUTED
4f382: 2140 0008 movel %d0,%a0@(8)
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
4f386: 7001 moveq #1,%d0
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
4f388: 6032 bras 4f3bc <rtems_rfs_rtems_set_handlers+0x8c>
else if (RTEMS_RFS_S_ISLNK (mode))
4f38a: 0c81 0000 a000 cmpil #40960,%d1
4f390: 6608 bnes 4f39a <rtems_rfs_rtems_set_handlers+0x6a>
loc->handlers = rtems_rfs_rtems_handlers (link);
4f392: 203c 0006 ae24 movel #437796,%d0
4f398: 60e8 bras 4f382 <rtems_rfs_rtems_set_handlers+0x52>
else if (RTEMS_RFS_S_ISREG (mode))
4f39a: 0c81 0000 8000 cmpil #32768,%d1
4f3a0: 6608 bnes 4f3aa <rtems_rfs_rtems_set_handlers+0x7a><== NEVER TAKEN
loc->handlers = rtems_rfs_rtems_handlers (file);
4f3a2: 203c 0006 c7d6 movel #444374,%d0
4f3a8: 60d8 bras 4f382 <rtems_rfs_rtems_set_handlers+0x52>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
4f3aa: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4f3ac: 4879 0006 ae5c pea 6ae5c <rtems_rfs_rtems_link_handlers+0x38><== NOT EXECUTED
4f3b2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
return false;
4f3b8: 508f addql #8,%sp <== NOT EXECUTED
4f3ba: 4200 clrb %d0 <== NOT EXECUTED
}
return true;
}
4f3bc: 4e5e unlk %fp <== NOT EXECUTED
0004df74 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
4df74: 4e56 fff8 linkw %fp,#-8 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4df78: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
4df7c: 2068 0010 moveal %a0@(16),%a0 <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
4df80: 2f0b movel %a3,%sp@- <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4df82: 2668 0034 moveal %a0@(52),%a3 <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
4df86: 2f0a movel %a2,%sp@- <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
4df88: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4df8c: 486e fff8 pea %fp@(-8) <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
4df90: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
4df94: 2f0b movel %a3,%sp@- <== NOT EXECUTED
4df96: 4eb9 0004 d5a6 jsr 4d5a6 <rtems_rfs_group_usage> <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
4df9c: 24ab 0008 movel %a3@(8),%a2@ <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
4dfa0: 206b 000c moveal %a3@(12),%a0 <== NOT EXECUTED
4dfa4: 2568 0024 0004 movel %a0@(36),%a2@(4) <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
4dfaa: 2028 001c movel %a0@(28),%d0 <== NOT EXECUTED
4dfae: 2540 000c movel %d0,%a2@(12) <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
4dfb2: 202b 0004 movel %a3@(4),%d0 <== NOT EXECUTED
4dfb6: 90ae fff8 subl %fp@(-8),%d0 <== NOT EXECUTED
4dfba: 2540 0014 movel %d0,%a2@(20) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
4dfbe: 2540 001c movel %d0,%a2@(28) <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
4dfc2: 202b 0010 movel %a3@(16),%d0 <== NOT EXECUTED
4dfc6: 2540 0020 movel %d0,%a2@(32) <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
4dfca: 90ae fffc subl %fp@(-4),%d0 <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
4dfce: 2553 0030 movel %a3@,%a2@(48) <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
4dfd2: 256b 0018 0034 movel %a3@(24),%a2@(52) <== NOT EXECUTED
return 0;
}
4dfd8: 266e fff4 moveal %fp@(-12),%a3 <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
4dfdc: 2540 0024 movel %d0,%a2@(36) <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
4dfe0: 2540 0028 movel %d0,%a2@(40) <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
4dfe4: 203c 2809 2001 movel #671686657,%d0 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
4dfea: 42aa 0008 clrl %a2@(8) <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
4dfee: 2540 002c movel %d0,%a2@(44) <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
4dff2: 4280 clrl %d0 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
4dff4: 42aa 0010 clrl %a2@(16) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
4dff8: 42aa 0018 clrl %a2@(24) <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
4dffc: 246e fff0 moveal %fp@(-16),%a2 <== NOT EXECUTED
4e000: 4e5e unlk %fp <== NOT EXECUTED
0004e492 <rtems_rfs_rtems_symlink>:
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
4e492: 4e56 ffe8 linkw %fp,#-24
4e496: 206e 0008 moveal %fp@(8),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
4e49a: 2268 0010 moveal %a0@(16),%a1
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
4e49e: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
4e4a2: 2a10 movel %a0@,%d5
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
link_name, strlen (link_name),
4e4a4: 47f9 0005 bf54 lea 5bf54 <strlen>,%a3
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
4e4aa: 2469 0034 moveal %a1@(52),%a2
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
4e4ae: 2f2a 007c movel %a2@(124),%sp@-
static int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
4e4b2: 242e 0010 movel %fp@(16),%d2
4e4b6: 262e 000c movel %fp@(12),%d3
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
4e4ba: 4eba fd66 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
link_name, strlen (link_name),
4e4be: 2f03 movel %d3,%sp@-
4e4c0: 4e93 jsr %a3@
4e4c2: 2800 movel %d0,%d4
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
4e4c4: 2e82 movel %d2,%sp@
4e4c6: 4e93 jsr %a3@
4e4c8: 2e85 movel %d5,%sp@
4e4ca: 42a7 clrl %sp@-
4e4cc: 42a7 clrl %sp@-
4e4ce: 2f04 movel %d4,%sp@-
4e4d0: 2f03 movel %d3,%sp@-
4e4d2: 2f00 movel %d0,%sp@-
4e4d4: 2f02 movel %d2,%sp@-
4e4d6: 2f0a movel %a2,%sp@-
4e4d8: 4eb9 0005 8dd0 jsr 58dd0 <rtems_rfs_symlink>
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
4e4de: 4fef 0024 lea %sp@(36),%sp
4e4e2: 41fa fb20 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
4e4e6: 2400 movel %d0,%d2
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
4e4e8: 6714 beqs 4e4fe <rtems_rfs_rtems_symlink+0x6c> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e4ea: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e4ec: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("symlink: linking", rc);
4e4ee: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e4f4: 588f addql #4,%sp <== NOT EXECUTED
4e4f6: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e4f8: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e4fa: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e4fc: 6008 bras 4e506 <rtems_rfs_rtems_symlink+0x74> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e4fe: 2f0a movel %a2,%sp@-
4e500: 4e90 jsr %a0@
return 0;
4e502: 588f addql #4,%sp
4e504: 4280 clrl %d0
}
4e506: 4cee 0c3c ffe8 moveml %fp@(-24),%d2-%d5/%a2-%a3
4e50c: 4e5e unlk %fp <== NOT EXECUTED
0004e2e0 <rtems_rfs_rtems_unlink>:
*/
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
4e2e0: 4e56 fff0 linkw %fp,#-16
4e2e4: 226e 0008 moveal %fp@(8),%a1
4e2e8: 48d7 041c moveml %d2-%d4/%a2,%sp@
4e2ec: 206e 000c moveal %fp@(12),%a0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
4e2f0: 2469 0010 moveal %a1@(16),%a2
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
4e2f4: 2411 movel %a1@,%d2
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
4e2f6: 2610 movel %a0@,%d3
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
4e2f8: 2828 0004 movel %a0@(4),%d4
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
4e2fc: 246a 0034 moveal %a2@(52),%a2
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
int rc;
rtems_rfs_rtems_lock (fs);
4e300: 2f2a 007c movel %a2@(124),%sp@-
4e304: 4eba ff1c jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))
printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
parent, doff, ino);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
4e308: 42a7 clrl %sp@-
4e30a: 2f04 movel %d4,%sp@-
4e30c: 2f03 movel %d3,%sp@-
4e30e: 2f02 movel %d2,%sp@-
4e310: 2f0a movel %a2,%sp@-
4e312: 4eb9 0005 8a4a jsr 58a4a <rtems_rfs_unlink>
if (rc)
4e318: 4fef 0018 lea %sp@(24),%sp
4e31c: 41fa fce6 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))
printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
parent, doff, ino);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
4e320: 2400 movel %d0,%d2
if (rc)
4e322: 6714 beqs 4e338 <rtems_rfs_rtems_unlink+0x58> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
4e324: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e326: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
4e328: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e32e: 588f addql #4,%sp <== NOT EXECUTED
4e330: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e332: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e334: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e336: 6008 bras 4e340 <rtems_rfs_rtems_unlink+0x60> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e338: 2f0a movel %a2,%sp@-
4e33a: 4e90 jsr %a0@
return 0;
4e33c: 588f addql #4,%sp
4e33e: 4280 clrl %d0
}
4e340: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4e346: 4e5e unlk %fp <== NOT EXECUTED
0004e004 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
4e004: 4e56 0000 linkw %fp,#0
4e008: 206e 0008 moveal %fp@(8),%a0
4e00c: 2f0a movel %a2,%sp@-
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
4e00e: 2468 007c moveal %a0@(124),%a2
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
4e012: 2f02 movel %d2,%sp@-
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
4e014: 2f08 movel %a0,%sp@-
4e016: 4eb9 0005 60d2 jsr 560d2 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
4e01c: 2f12 movel %a2@,%sp@-
4e01e: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
4e024: 508f addql #8,%sp
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
4e026: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
4e028: 672c beqs 4e056 <rtems_rfs_rtems_unlock+0x52> <== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4e02a: 4878 0004 pea 4 <CONTEXT_ARG> <== NOT EXECUTED
4e02e: 42a7 clrl %sp@- <== NOT EXECUTED
4e030: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
4e036: 508f addql #8,%sp <== NOT EXECUTED
4e038: 4a00 tstb %d0 <== NOT EXECUTED
4e03a: 671a beqs 4e056 <rtems_rfs_rtems_unlock+0x52> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
4e03c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4e03e: 4eb9 0004 5080 jsr 45080 <rtems_status_text> <== NOT EXECUTED
4e044: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4e046: 4879 0006 ad90 pea 6ad90 <ramdisk_ops+0xba6> <== NOT EXECUTED
4e04c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
4e052: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_mutex_unlock (&rtems->access);
}
4e056: 242e fff8 movel %fp@(-8),%d2
4e05a: 246e fffc moveal %fp@(-4),%a2
4e05e: 4e5e unlk %fp <== NOT EXECUTED
0004e510 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
4e510: 4e56 ffc4 linkw %fp,#-60 <== NOT EXECUTED
4e514: 206e 0008 moveal %fp@(8),%a0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e518: 2268 0010 moveal %a0@(16),%a1 <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
4e51c: 48d7 043c moveml %d2-%d5/%a2,%sp@ <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
4e520: 2a10 movel %a0@,%d5 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e522: 280e movel %fp,%d4 <== NOT EXECUTED
4e524: 0684 ffff ffda addil #-38,%d4 <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
4e52a: 2469 0034 moveal %a1@(52),%a2 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
4e52e: 2f2a 007c movel %a2@(124),%sp@- <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
4e532: 262e 000c movel %fp@(12),%d3 <== NOT EXECUTED
4e536: 242e 0010 movel %fp@(16),%d2 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
4e53a: 4eba fce6 jsr %pc@(4e222 <rtems_rfs_rtems_lock.isra.16>)<== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e53e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
4e542: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4e544: 2f05 movel %d5,%sp@- <== NOT EXECUTED
4e546: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e548: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
4e54e: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4e552: 2a00 movel %d0,%d5 <== NOT EXECUTED
if (rc)
4e554: 6712 beqs 4e568 <rtems_rfs_rtems_utime+0x58> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e556: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e558: 4eba faaa jsr %pc@(4e004 <rtems_rfs_rtems_unlock>) <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: read inode", rc);
4e55c: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e562: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e564: 2085 movel %d5,%a0@ <== NOT EXECUTED
4e566: 606a bras 4e5d2 <rtems_rfs_rtems_utime+0xc2> <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4e568: 206e ffe6 moveal %fp@(-26),%a0 <== NOT EXECUTED
4e56c: 7218 moveq #24,%d1 <== NOT EXECUTED
4e56e: 2003 movel %d3,%d0 <== NOT EXECUTED
4e570: e2a8 lsrl %d1,%d0 <== NOT EXECUTED
4e572: 1140 0010 moveb %d0,%a0@(16) <== NOT EXECUTED
4e576: 2003 movel %d3,%d0 <== NOT EXECUTED
4e578: 4240 clrw %d0 <== NOT EXECUTED
4e57a: 4840 swap %d0 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4e57c: 1142 0017 moveb %d2,%a0@(23) <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4e580: 1143 0013 moveb %d3,%a0@(19) <== NOT EXECUTED
4e584: 1140 0011 moveb %d0,%a0@(17) <== NOT EXECUTED
4e588: 2003 movel %d3,%d0 <== NOT EXECUTED
4e58a: e088 lsrl #8,%d0 <== NOT EXECUTED
4e58c: 1140 0012 moveb %d0,%a0@(18) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4e590: 7001 moveq #1,%d0 <== NOT EXECUTED
4e592: 1d40 ffea moveb %d0,%fp@(-22) <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4e596: 2002 movel %d2,%d0 <== NOT EXECUTED
4e598: e2a8 lsrl %d1,%d0 <== NOT EXECUTED
4e59a: 1140 0014 moveb %d0,%a0@(20) <== NOT EXECUTED
4e59e: 2002 movel %d2,%d0 <== NOT EXECUTED
4e5a0: 4240 clrw %d0 <== NOT EXECUTED
4e5a2: 4840 swap %d0 <== NOT EXECUTED
4e5a4: 1140 0015 moveb %d0,%a0@(21) <== NOT EXECUTED
4e5a8: 2002 movel %d2,%d0 <== NOT EXECUTED
4e5aa: e088 lsrl #8,%d0 <== NOT EXECUTED
4e5ac: 1140 0016 moveb %d0,%a0@(22) <== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
4e5b0: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4e5b2: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e5b4: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
4e5ba: 508f addql #8,%sp <== NOT EXECUTED
4e5bc: 41fa fa46 lea %pc@(4e004 <rtems_rfs_rtems_unlock>),%a0<== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
4e5c0: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc)
4e5c2: 6714 beqs 4e5d8 <rtems_rfs_rtems_utime+0xc8> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
4e5c4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e5c6: 4e90 jsr %a0@ <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: closing inode", rc);
4e5c8: 4eb9 0005 a88c jsr 5a88c <__errno> <== NOT EXECUTED
4e5ce: 2040 moveal %d0,%a0 <== NOT EXECUTED
4e5d0: 2082 movel %d2,%a0@ <== NOT EXECUTED
4e5d2: 588f addql #4,%sp <== NOT EXECUTED
4e5d4: 70ff moveq #-1,%d0 <== NOT EXECUTED
4e5d6: 6008 bras 4e5e0 <rtems_rfs_rtems_utime+0xd0> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
4e5d8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4e5da: 4e90 jsr %a0@ <== NOT EXECUTED
return 0;
4e5dc: 588f addql #4,%sp <== NOT EXECUTED
4e5de: 4280 clrl %d0 <== NOT EXECUTED
}
4e5e0: 4cee 043c ffc4 moveml %fp@(-60),%d2-%d5/%a2 <== NOT EXECUTED
4e5e6: 4e5e unlk %fp <== NOT EXECUTED
0004c506 <rtems_rfs_rup_quotient>:
* Return a rounded up integer quotient given a dividend and divisor. That is:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
4c506: 4e56 0000 linkw %fp,#0
4c50a: 202e 0008 movel %fp@(8),%d0
4c50e: 222e 000c movel %fp@(12),%d1
4c512: 2f02 movel %d2,%sp@-
if (dividend == 0)
4c514: 4a80 tstl %d0
4c516: 670a beqs 4c522 <rtems_rfs_rup_quotient+0x1c> <== NEVER TAKEN
return 1;
return ((dividend - 1) / divisor) + 1;
4c518: 5380 subql #1,%d0
4c51a: 4c41 0000 remul %d1,%d0,%d0
4c51e: 5280 addql #1,%d0
4c520: 6002 bras 4c524 <rtems_rfs_rup_quotient+0x1e>
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
4c522: 7001 moveq #1,%d0 <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
}
4c524: 241f movel %sp@+,%d2
4c526: 4e5e unlk %fp <== NOT EXECUTED
00055aa8 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
55aa8: 4e56 ffe8 linkw %fp,#-24
55aac: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
55ab0: 286e 0008 moveal %fp@(8),%a4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
55ab4: 246c 0008 moveal %a4@(8),%a2
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55ab8: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
55abc: 266e 000c moveal %fp@(12),%a3
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55ac0: 42a7 clrl %sp@-
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
55ac2: 242e 0010 movel %fp@(16),%d2
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55ac6: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55acc: 508f addql #8,%sp
55ace: 4a00 tstb %d0
55ad0: 677a beqs 55b4c <rtems_rfs_scan_chain+0xa4> <== ALWAYS TAKEN
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
55ad2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
55ad4: 2f13 movel %a3@,%sp@- <== NOT EXECUTED
55ad6: 4879 0006 b3bf pea 6b3bf <CSWTCH.1+0x119> <== NOT EXECUTED
55adc: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55ae2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
55ae6: 6064 bras 55b4c <rtems_rfs_scan_chain+0xa4> <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55ae8: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
55aec: 2043 moveal %d3,%a0
55aee: 42a7 clrl %sp@-
55af0: 4e90 jsr %a0@
55af2: 508f addql #8,%sp
55af4: 4a00 tstb %d0
55af6: 670e beqs 55b06 <rtems_rfs_scan_chain+0x5e> <== ALWAYS TAKEN
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
55af8: 2f2a 0036 movel %a2@(54),%sp@- <== NOT EXECUTED
55afc: 4879 0006 b3ee pea 6b3ee <CSWTCH.1+0x148> <== NOT EXECUTED
55b02: 4e95 jsr %a5@ <== NOT EXECUTED
55b04: 508f addql #8,%sp <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
55b06: b4aa 0036 cmpl %a2@(54),%d2
55b0a: 663a bnes 55b46 <rtems_rfs_scan_chain+0x9e>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55b0c: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
55b10: 42a7 clrl %sp@-
55b12: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55b18: 508f addql #8,%sp
55b1a: 4a00 tstb %d0
55b1c: 6712 beqs 55b30 <rtems_rfs_scan_chain+0x88> <== ALWAYS TAKEN
printf (": found block=%" PRIuPTR "\n",
55b1e: 2f2a 0036 movel %a2@(54),%sp@- <== NOT EXECUTED
55b22: 4879 0006 b3f3 pea 6b3f3 <CSWTCH.1+0x14d> <== NOT EXECUTED
55b28: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
55b2e: 508f addql #8,%sp <== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
55b30: 5393 subql #1,%a3@
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
55b32: 2f0a movel %a2,%sp@-
55b34: 4eb9 0004 99e4 jsr 499e4 <_Chain_Extract>
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
55b3a: 588f addql #4,%sp
55b3c: 200a movel %a2,%d0
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
55b3e: 42aa 0004 clrl %a2@(4)
55b42: 4292 clrl %a2@
55b44: 6038 bras 55b7e <rtems_rfs_scan_chain+0xd6>
true);
if ((rc > 0) && (rrc == 0))
rrc = rc;
return rrc;
}
55b46: 246a 0004 moveal %a2@(4),%a2
55b4a: 600c bras 55b58 <rtems_rfs_scan_chain+0xb0>
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
55b4c: 4bf9 0005 b318 lea 5b318 <printf>,%a5
55b52: 263c 0004 f3d8 movel #324568,%d3
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
55b58: b9ca cmpal %a2,%a4
55b5a: 668c bnes 55ae8 <rtems_rfs_scan_chain+0x40>
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
55b5c: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b>
55b60: 42a7 clrl %sp@-
55b62: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
55b68: 508f addql #8,%sp
55b6a: 4a00 tstb %d0
55b6c: 670e beqs 55b7c <rtems_rfs_scan_chain+0xd4> <== ALWAYS TAKEN
printf (": not found\n");
55b6e: 4879 0006 b406 pea 6b406 <CSWTCH.1+0x160> <== NOT EXECUTED
55b74: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
55b7a: 588f addql #4,%sp <== NOT EXECUTED
return NULL;
55b7c: 4280 clrl %d0
}
55b7e: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
55b84: 4e5e unlk %fp <== NOT EXECUTED
000546c0 <rtems_rfs_search_map_for_clear_bit.constprop.1>:
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
546c0: 4e56 ffbc linkw %fp,#-68
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
546c4: 206e 0010 moveal %fp@(16),%a0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
546c8: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
546cc: 4210 clrb %a0@
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
546ce: 246e 0008 moveal %fp@(8),%a2
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
546d2: 486e fffc pea %fp@(-4)
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
546d6: 242e 0014 movel %fp@(20),%d2
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
546da: 2f0a movel %a2,%sp@-
546dc: 4eba ff96 jsr %pc@(54674 <rtems_rfs_bitmap_load_map>)
if (rc > 0)
546e0: 508f addql #8,%sp
546e2: 4a80 tstl %d0
546e4: 6e00 0166 bgtw 5484c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18c>
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
546e8: 206e 000c moveal %fp@(12),%a0
end_bit = test_bit + (window * direction);
546ec: 2202 movel %d2,%d1
546ee: 760b moveq #11,%d3
546f0: e7a9 lsll %d3,%d1
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
546f2: 2010 movel %a0@,%d0
end_bit = test_bit + (window * direction);
546f4: d280 addl %d0,%d1
if (end_bit < 0)
546f6: 6b0e bmis 54706 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x46>
end_bit = 0;
else if (end_bit >= control->size)
546f8: 206a 000c moveal %a2@(12),%a0
546fc: b1c1 cmpal %d1,%a0
546fe: 6208 bhis 54708 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48><== NEVER TAKEN
end_bit = control->size - 1;
54700: 2208 movel %a0,%d1
54702: 5381 subql #1,%d1
54704: 6002 bras 54708 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
*/
test_bit = *bit;
end_bit = test_bit + (window * direction);
if (end_bit < 0)
end_bit = 0;
54706: 4281 clrl %d1
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
54708: 2c00 movel %d0,%d6
5470a: 7e0a moveq #10,%d7
5470c: eea6 asrl %d7,%d6
if (end_bit < 0)
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
5470e: 2a00 movel %d0,%d5
54710: ea85 asrl #5,%d5
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
54712: 781f moveq #31,%d4
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
54714: 761f moveq #31,%d3
search_bits = &control->search_bits[search_index];
54716: e58e lsll #2,%d6
54718: 226a 0014 moveal %a2@(20),%a1
5471c: d3c6 addal %d6,%a1
map_bits = &map[map_index];
5471e: 2c05 movel %d5,%d6
54720: e58e lsll #2,%d6
54722: 206e fffc moveal %fp@(-4),%a0
54726: d1c6 addal %d6,%a0
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
54728: 2c02 movel %d2,%d6
5472a: e58e lsll #2,%d6
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
5472c: c880 andl %d0,%d4
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
5472e: c685 andl %d5,%d3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
54730: 2a46 moveal %d6,%a5
54732: 4a82 tstl %d2
54734: 6f04 bles 5473a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x7a>
54736: 4286 clrl %d6
54738: 600c bras 54746 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x86>
5473a: 7c1f moveq #31,%d6
5473c: 6008 bras 54746 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x86>
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
5473e: 761f moveq #31,%d3 <== NOT EXECUTED
54740: 6010 bras 54752 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x92><== NOT EXECUTED
54742: 4283 clrl %d3 <== NOT EXECUTED
54744: 600c bras 54752 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x92><== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
54746: 2e02 movel %d2,%d7
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
54748: 387c 0001 moveaw #1,%a4
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
5474c: eb8f lsll #5,%d7
5474e: 2d47 ffe8 movel %d7,%fp@(-24)
/*
* If any bit is clear find that bit and then search the map element. If
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
54752: 2d51 fff8 movel %a1@,%fp@(-8)
54756: 6700 00ac beqw 54804 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
5475a: 2e05 movel %d5,%d7
5475c: de82 addl %d2,%d7
5475e: eb8f lsll #5,%d7
54760: 2d44 fff0 movel %d4,%fp@(-16)
54764: de86 addl %d6,%d7
54766: 6000 008e braw 547f6 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x136>
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
5476a: 280c movel %a4,%d4
5476c: e7ac lsll %d3,%d4
5476e: 2d44 fff4 movel %d4,%fp@(-12)
54772: c8ae fff8 andl %fp@(-8),%d4
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
54776: 675c beqs 547d4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x114>
54778: 2d43 ffe4 movel %d3,%fp@(-28)
5477c: 282e fff0 movel %fp@(-16),%d4
54780: 6048 bras 547ca <rtems_rfs_search_map_for_clear_bit.constprop.1+0x10a>
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
54782: 260c movel %a4,%d3
54784: e9ab lsll %d4,%d3
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
54786: 2d50 fff0 movel %a0@,%fp@(-16)
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
5478a: 2643 moveal %d3,%a3
5478c: c6ae fff0 andl %fp@(-16),%d3
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
54790: 6730 beqs 547c2 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x102>
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
54792: 220b movel %a3,%d1
54794: 4681 notl %d1
54796: c2ae fff0 andl %fp@(-16),%d1
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
5479a: 2081 movel %d1,%a0@
if (rtems_rfs_bitmap_match(*map_bits,
5479c: 6608 bnes 547a6 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe6>
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
5479e: 222e fff4 movel %fp@(-12),%d1
547a2: 4681 notl %d1
547a4: c391 andl %d1,%a1@
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
547a6: 53aa 0010 subql #1,%a2@(16)
*bit = test_bit;
547aa: 206e 000c moveal %fp@(12),%a0
547ae: 2080 movel %d0,%a0@
*found = true;
547b0: 206e 0010 moveal %fp@(16),%a0
547b4: 10bc 0001 moveb #1,%a0@
rtems_rfs_buffer_mark_dirty (control->buffer);
547b8: 2052 moveal %a2@,%a0
547ba: 10bc 0001 moveb #1,%a0@
547be: 6000 008a braw 5484a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18a>
return 0;
}
if (test_bit == end_bit)
547c2: b280 cmpl %d0,%d1
547c4: 670a beqs 547d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x110>
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
547c6: d882 addl %d2,%d4
547c8: d082 addl %d2,%d0
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
547ca: 761f moveq #31,%d3
547cc: b684 cmpl %d4,%d3
547ce: 64b2 bccs 54782 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc2><== ALWAYS TAKEN
547d0: 262e ffe4 movel %fp@(-28),%d3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
547d4: d1cd addal %a5,%a0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
547d6: da82 addl %d2,%d5
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
547d8: 2007 movel %d7,%d0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
547da: d682 addl %d2,%d3
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
547dc: 4a82 tstl %d2
547de: 6c06 bges 547e6 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x126>
547e0: b287 cmpl %d7,%d1
547e2: 6d0a blts 547ee <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12e><== NEVER TAKEN
547e4: 604c bras 54832 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x172>
|| ((direction > 0) && (test_bit >= end_bit)))
547e6: 4a82 tstl %d2
547e8: 6704 beqs 547ee <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12e><== NEVER TAKEN
547ea: b287 cmpl %d7,%d1
547ec: 6f44 bles 54832 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x172><== NEVER TAKEN
547ee: deae ffe8 addl %fp@(-24),%d7
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
547f2: 2d46 fff0 movel %d6,%fp@(-16)
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
547f6: 781f moveq #31,%d4
547f8: b883 cmpl %d3,%d4
547fa: 6400 ff6e bccw 5476a <rtems_rfs_search_map_for_clear_bit.constprop.1+0xaa>
547fe: 282e fff0 movel %fp@(-16),%d4 <== NOT EXECUTED
54802: 6030 bras 54834 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x174><== NOT EXECUTED
*
* Align test_bit either up or down depending on the direction to next 32
* bit boundary.
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
54804: 7ee0 moveq #-32,%d7 <== NOT EXECUTED
54806: c087 andl %d7,%d0 <== NOT EXECUTED
if (direction > 0)
54808: 4a82 tstl %d2 <== NOT EXECUTED
5480a: 6f0e bles 5481a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15a><== NOT EXECUTED
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
5480c: 7e20 moveq #32,%d7 <== NOT EXECUTED
5480e: 9e83 subl %d3,%d7 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
54810: 2607 movel %d7,%d3 <== NOT EXECUTED
map_offset = 0;
54812: 4284 clrl %d4 <== NOT EXECUTED
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
54814: eb8b lsll #5,%d3 <== NOT EXECUTED
54816: d083 addl %d3,%d0 <== NOT EXECUTED
54818: 600c bras 54826 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x166><== NOT EXECUTED
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
5481a: 2e03 movel %d3,%d7 <== NOT EXECUTED
5481c: 5287 addql #1,%d7 <== NOT EXECUTED
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
5481e: 781f moveq #31,%d4 <== NOT EXECUTED
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
54820: eb8b lsll #5,%d3 <== NOT EXECUTED
54822: 4683 notl %d3 <== NOT EXECUTED
54824: d083 addl %d3,%d0 <== NOT EXECUTED
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
54826: 4c02 7800 mulsl %d2,%d7 <== NOT EXECUTED
map_index += direction * bits_skipped;
5482a: da87 addl %d7,%d5 <== NOT EXECUTED
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
5482c: 41f0 7c00 lea %a0@(00000000,%d7:l:4),%a0 <== NOT EXECUTED
54830: 6002 bras 54834 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x174><== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
54832: 2806 movel %d6,%d4
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
54834: d3cd addal %a5,%a1
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
54836: 4a82 tstl %d2
54838: 6e0a bgts 54844 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x184>
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
5483a: 670e beqs 5484a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18a><== NEVER TAKEN
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
}
while (((direction < 0) && (test_bit >= end_bit))
5483c: b280 cmpl %d0,%d1
5483e: 6f00 fefe blew 5473e <rtems_rfs_search_map_for_clear_bit.constprop.1+0x7e>
54842: 6006 bras 5484a <rtems_rfs_search_map_for_clear_bit.constprop.1+0x18a>
|| ((direction > 0) && (test_bit <= end_bit)));
54844: b280 cmpl %d0,%d1
54846: 6c00 fefa bgew 54742 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x82>
return 0;
5484a: 4280 clrl %d0
}
5484c: 4cee 3cfc ffbc moveml %fp@(-68),%d2-%d7/%a2-%a5
54852: 4e5e unlk %fp <== NOT EXECUTED
00058dd0 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
58dd0: 4e56 ff54 linkw %fp,#-172
58dd4: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
58dd8: 42a7 clrl %sp@-
58dda: 4878 0002 pea 2 <DOUBLE_FLOAT>
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
58dde: 246e 0008 moveal %fp@(8),%a2
58de2: 242e 000c movel %fp@(12),%d2
58de6: 2c2e 0014 movel %fp@(20),%d6
58dea: 262e 0018 movel %fp@(24),%d3
58dee: 2a2e 0024 movel %fp@(36),%d5
58df2: 3e2e 001e movew %fp@(30),%d7
58df6: 386e 0022 moveaw %fp@(34),%a4
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
58dfa: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
58e00: 508f addql #8,%sp
58e02: 4a00 tstb %d0
58e04: 6758 beqs 58e5e <rtems_rfs_symlink+0x8e> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
58e06: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58e08: 4879 0006 c6cf pea 6c6cf <CSWTCH.1+0x1429> <== NOT EXECUTED
58e0e: 2642 moveal %d2,%a3 <== NOT EXECUTED
for (c = 0; c < length; c++)
58e10: 4284 clrl %d4 <== NOT EXECUTED
printf ("%c", name[c]);
58e12: 4bf9 0005 b358 lea 5b358 <putchar>,%a5 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
58e18: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
58e1e: 508f addql #8,%sp <== NOT EXECUTED
58e20: 600c bras 58e2e <rtems_rfs_symlink+0x5e> <== NOT EXECUTED
58e22: 5284 addql #1,%d4 <== NOT EXECUTED
printf ("%c", name[c]);
58e24: 101b moveb %a3@+,%d0 <== NOT EXECUTED
58e26: 49c0 extbl %d0 <== NOT EXECUTED
58e28: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58e2a: 4e95 jsr %a5@ <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
58e2c: 588f addql #4,%sp <== NOT EXECUTED
58e2e: b8ae 0010 cmpl %fp@(16),%d4 <== NOT EXECUTED
58e32: 6dee blts 58e22 <rtems_rfs_symlink+0x52> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
58e34: 4879 0006 c6f4 pea 6c6f4 <CSWTCH.1+0x144e> <== NOT EXECUTED
58e3a: 2646 moveal %d6,%a3 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
58e3c: 4284 clrl %d4 <== NOT EXECUTED
printf ("%c", link[c]);
58e3e: 4bf9 0005 b358 lea 5b358 <putchar>,%a5 <== NOT EXECUTED
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
58e44: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
58e4a: 588f addql #4,%sp <== NOT EXECUTED
58e4c: 600c bras 58e5a <rtems_rfs_symlink+0x8a> <== NOT EXECUTED
58e4e: 5284 addql #1,%d4 <== NOT EXECUTED
printf ("%c", link[c]);
58e50: 101b moveb %a3@+,%d0 <== NOT EXECUTED
58e52: 49c0 extbl %d0 <== NOT EXECUTED
58e54: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58e56: 4e95 jsr %a5@ <== NOT EXECUTED
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
for (c = 0; c < link_length; c++)
58e58: 588f addql #4,%sp <== NOT EXECUTED
58e5a: b684 cmpl %d4,%d3 <== NOT EXECUTED
58e5c: 6ef0 bgts 58e4e <rtems_rfs_symlink+0x7e> <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
58e5e: b6aa 0008 cmpl %a2@(8),%d3
58e62: 6400 01c2 bccw 59026 <rtems_rfs_symlink+0x256>
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
58e66: 2f02 movel %d2,%sp@-
58e68: 4eb9 0005 bf54 jsr 5bf54 <strlen>
58e6e: 588f addql #4,%sp
58e70: 486e fff8 pea %fp@(-8)
58e74: 3f0c movew %a4,%sp@-
58e76: 4267 clrw %sp@-
58e78: 3f07 movew %d7,%sp@-
58e7a: 4267 clrw %sp@-
58e7c: 4878 0001 pea 1 <ADD>
58e80: 2f3c 0000 a1ff movel #41471,%sp@-
58e86: 2f00 movel %d0,%sp@-
58e88: 2f02 movel %d2,%sp@-
58e8a: 2f05 movel %d5,%sp@-
58e8c: 2f0a movel %a2,%sp@-
58e8e: 4eb9 0004 dbd0 jsr 4dbd0 <rtems_rfs_inode_create>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
58e94: 4fef 0024 lea %sp@(36),%sp
}
if (link_length >= rtems_rfs_fs_block_size (fs))
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
58e98: 2400 movel %d0,%d2
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
58e9a: 6e00 018c bgtw 59028 <rtems_rfs_symlink+0x258>
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
58e9e: 4878 0001 pea 1 <ADD>
58ea2: 280e movel %fp,%d4
58ea4: 0684 ffff ffc8 addil #-56,%d4
58eaa: 2f04 movel %d4,%sp@-
58eac: 2f2e fff8 movel %fp@(-8),%sp@-
58eb0: 2f0a movel %a2,%sp@-
58eb2: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc > 0)
58eb8: 4fef 0010 lea %sp@(16),%sp
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
58ebc: 2400 movel %d0,%d2
if (rc > 0)
58ebe: 6e00 0168 bgtw 59028 <rtems_rfs_symlink+0x258>
/*
* If the link length is less than the length of data union in the inode
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
58ec2: 7013 moveq #19,%d0
58ec4: b083 cmpl %d3,%d0
58ec6: 6554 bcss 58f1c <rtems_rfs_symlink+0x14c> <== NEVER TAKEN
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
58ec8: 4878 0014 pea 14 <OPER2>
58ecc: 206e ffd4 moveal %fp@(-44),%a0
58ed0: 41e8 001c lea %a0@(28),%a0
58ed4: 42a7 clrl %sp@-
58ed6: 2f08 movel %a0,%sp@-
58ed8: 4eb9 0005 b28c jsr 5b28c <memset>
memcpy (inode.node->data.name, link, link_length);
58ede: 206e ffd4 moveal %fp@(-44),%a0
58ee2: 41e8 001c lea %a0@(28),%a0
58ee6: 2f03 movel %d3,%sp@-
58ee8: 2f06 movel %d6,%sp@-
58eea: 2f08 movel %a0,%sp@-
58eec: 4eb9 0005 b134 jsr 5b134 <memcpy>
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
58ef2: 206e ffd4 moveal %fp@(-44),%a0
rtems_rfs_buffer_mark_dirty (&handle->buffer);
58ef6: 4fef 0018 lea %sp@(24),%sp
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
58efa: 4200 clrb %d0
58efc: 1140 000c moveb %d0,%a0@(12)
58f00: 206e ffd4 moveal %fp@(-44),%a0
58f04: 1140 000d moveb %d0,%a0@(13)
58f08: 206e ffd4 moveal %fp@(-44),%a0
58f0c: 1140 000e moveb %d0,%a0@(14)
58f10: 206e ffd4 moveal %fp@(-44),%a0
58f14: 1140 000f moveb %d0,%a0@(15)
58f18: 6000 00e0 braw 58ffa <rtems_rfs_symlink+0x22a>
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
58f1c: 2a0e movel %fp,%d5 <== NOT EXECUTED
58f1e: 0685 ffff ff7e addil #-130,%d5 <== NOT EXECUTED
58f24: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58f26: 2f04 movel %d4,%sp@- <== NOT EXECUTED
58f28: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58f2a: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
58f30: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
58f34: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
58f36: 6e00 00b6 bgtw 58fee <rtems_rfs_symlink+0x21e> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
58f3a: 486e fffc pea %fp@(-4) <== NOT EXECUTED
58f3e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
58f42: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58f44: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58f46: 4eb9 0005 54be jsr 554be <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
58f4c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
58f50: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
58f52: 6e2e bgts 58f82 <rtems_rfs_symlink+0x1b2> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
58f54: 42a7 clrl %sp@- <== NOT EXECUTED
58f56: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
58f5a: 2e0e movel %fp,%d7 <== NOT EXECUTED
58f5c: 0687 ffff ffee addil #-18,%d7 <== NOT EXECUTED
58f62: 2f07 movel %d7,%sp@- <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
58f64: 4200 clrb %d0 <== NOT EXECUTED
58f66: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58f68: 1d40 ffee moveb %d0,%fp@(-18) <== NOT EXECUTED
handle->bnum = 0;
58f6c: 42ae fff0 clrl %fp@(-16) <== NOT EXECUTED
handle->buffer = NULL;
58f70: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
58f74: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
58f7a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
58f7e: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
58f80: 6f1c bles 58f9e <rtems_rfs_symlink+0x1ce> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
58f82: 2f05 movel %d5,%sp@- <== NOT EXECUTED
58f84: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58f86: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
58f8c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
58f8e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58f90: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
58f96: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
58f9a: 6000 008c braw 59028 <rtems_rfs_symlink+0x258> <== NOT EXECUTED
}
data = rtems_rfs_buffer_data (&buffer);
58f9e: 206e fff4 moveal %fp@(-12),%a0 <== NOT EXECUTED
58fa2: 2428 001e movel %a0@(30),%d2 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
58fa6: 2f2a 0008 movel %a2@(8),%sp@- <== NOT EXECUTED
58faa: 4878 00ff pea ff <DBL_MANT_DIG+0xca> <== NOT EXECUTED
58fae: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58fb0: 4eb9 0005 b28c jsr 5b28c <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
58fb6: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58fb8: 2f06 movel %d6,%sp@- <== NOT EXECUTED
58fba: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58fbc: 4eb9 0005 b134 jsr 5b134 <memcpy> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
58fc2: 2f07 movel %d7,%sp@- <== NOT EXECUTED
58fc4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58fc6: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
58fcc: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
58fd0: 2e85 movel %d5,%sp@ <== NOT EXECUTED
handle->dirty = false;
58fd2: 4200 clrb %d0 <== NOT EXECUTED
58fd4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58fd6: 1d40 ffee moveb %d0,%fp@(-18) <== NOT EXECUTED
handle->bnum = 0;
58fda: 42ae fff0 clrl %fp@(-16) <== NOT EXECUTED
handle->buffer = NULL;
58fde: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
58fe2: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
58fe8: 508f addql #8,%sp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
58fea: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
58fec: 6f0c bles 58ffa <rtems_rfs_symlink+0x22a> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
58fee: 2f04 movel %d4,%sp@- <== NOT EXECUTED
58ff0: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58ff2: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
58ff8: 6028 bras 59022 <rtems_rfs_symlink+0x252> <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
58ffa: 206e ffd4 moveal %fp@(-44),%a0
58ffe: 2003 movel %d3,%d0
59000: e088 lsrl #8,%d0
59002: 1140 000a moveb %d0,%a0@(10)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
59006: 7001 moveq #1,%d0
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
59008: 206e ffd4 moveal %fp@(-44),%a0
5900c: 1143 000b moveb %d3,%a0@(11)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
59010: 1d40 ffd8 moveb %d0,%fp@(-40)
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
59014: 486e ffc8 pea %fp@(-56)
59018: 2f0a movel %a2,%sp@-
5901a: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
59020: 2400 movel %d0,%d2
return rc;
59022: 508f addql #8,%sp
59024: 6002 bras 59028 <rtems_rfs_symlink+0x258>
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
return ENAMETOOLONG;
59026: 745b moveq #91,%d2 <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
59028: 2002 movel %d2,%d0
5902a: 4cee 3cfc ff54 moveml %fp@(-172),%d2-%d7/%a2-%a5
59030: 4e5e unlk %fp <== NOT EXECUTED
00059034 <rtems_rfs_symlink_read>:
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
59034: 4e56 ff64 linkw %fp,#-156
59038: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
5903c: 42a7 clrl %sp@-
5903e: 4878 0004 pea 4 <CONTEXT_ARG>
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
59042: 242e 0008 movel %fp@(8),%d2
59046: 262e 000c movel %fp@(12),%d3
5904a: 266e 0010 moveal %fp@(16),%a3
5904e: 286e 0018 moveal %fp@(24),%a4
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
59052: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
59058: 508f addql #8,%sp
5905a: 4a00 tstb %d0
5905c: 6710 beqs 5906e <rtems_rfs_symlink_read+0x3a> <== ALWAYS TAKEN
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
5905e: 2f03 movel %d3,%sp@- <== NOT EXECUTED
59060: 4879 0006 c6fb pea 6c6fb <CSWTCH.1+0x1455> <== NOT EXECUTED
59066: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
5906c: 508f addql #8,%sp <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
5906e: 4878 0001 pea 1 <ADD>
59072: 45ee ffcc lea %fp@(-52),%a2
59076: 2f0a movel %a2,%sp@-
59078: 2f03 movel %d3,%sp@-
5907a: 2f02 movel %d2,%sp@-
5907c: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc)
59082: 4fef 0010 lea %sp@(16),%sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
59086: 2600 movel %d0,%d3
if (rc)
59088: 6600 0178 bnew 59202 <rtems_rfs_symlink_read+0x1ce>
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
5908c: 206a 000c moveal %a2@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
59090: 4280 clrl %d0
59092: 1028 0002 moveb %a0@(2),%d0
59096: e188 lsll #8,%d0
59098: 0280 0000 f000 andil #61440,%d0
5909e: 0c80 0000 a000 cmpil #40960,%d0
590a4: 6714 beqs 590ba <rtems_rfs_symlink_read+0x86> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
590a6: 2f0a movel %a2,%sp@- <== NOT EXECUTED
return EINVAL;
590a8: 163c 0016 moveb #22,%d3 <== NOT EXECUTED
if (rc)
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
590ac: 2f02 movel %d2,%sp@- <== NOT EXECUTED
590ae: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
return EINVAL;
590b4: 508f addql #8,%sp <== NOT EXECUTED
590b6: 6000 014a braw 59202 <rtems_rfs_symlink_read+0x1ce> <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
590ba: 4281 clrl %d1
590bc: 1228 000a moveb %a0@(10),%d1
590c0: 4280 clrl %d0
590c2: 1028 000b moveb %a0@(11),%d0
590c6: e189 lsll #8,%d1
}
*length = rtems_rfs_inode_get_block_offset (&inode);
590c8: 8280 orl %d0,%d1
590ca: 2881 movel %d1,%a4@
if (size < *length)
590cc: b2ae 0014 cmpl %fp@(20),%d1
590d0: 6312 blss 590e4 <rtems_rfs_symlink_read+0xb0>
{
rtems_rfs_inode_close (fs, &inode);
590d2: 2f0a movel %a2,%sp@-
return EINVAL;
590d4: 7616 moveq #22,%d3
*length = rtems_rfs_inode_get_block_offset (&inode);
if (size < *length)
{
rtems_rfs_inode_close (fs, &inode);
590d6: 2f02 movel %d2,%sp@-
590d8: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
return EINVAL;
590de: 508f addql #8,%sp
590e0: 6000 0120 braw 59202 <rtems_rfs_symlink_read+0x1ce>
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
590e4: 4280 clrl %d0
590e6: 1028 000c moveb %a0@(12),%d0
590ea: 7618 moveq #24,%d3
590ec: e7a8 lsll %d3,%d0
590ee: 4283 clrl %d3
590f0: 1628 000d moveb %a0@(13),%d3
590f4: 4843 swap %d3
590f6: 4243 clrw %d3
590f8: 8083 orl %d3,%d0
590fa: 4283 clrl %d3
590fc: 1628 000f moveb %a0@(15),%d3
59100: 8083 orl %d3,%d0
59102: 1628 000e moveb %a0@(14),%d3
59106: e18b lsll #8,%d3
59108: 8083 orl %d3,%d0
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
5910a: 6616 bnes 59122 <rtems_rfs_symlink_read+0xee> <== NEVER TAKEN
{
memcpy (path, inode.node->data.name, *length);
5910c: 2f01 movel %d1,%sp@-
5910e: 4868 001c pea %a0@(28)
59112: 2f0b movel %a3,%sp@-
59114: 4eb9 0005 b134 jsr 5b134 <memcpy>
5911a: 4fef 000c lea %sp@(12),%sp
5911e: 6000 00ca braw 591ea <rtems_rfs_symlink_read+0x1b6>
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
59122: 280e movel %fp,%d4 <== NOT EXECUTED
59124: 0684 ffff ff82 addil #-126,%d4 <== NOT EXECUTED
5912a: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5912c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
5912e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59130: 4eb9 0005 4fe2 jsr 54fe2 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
59136: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
5913a: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
5913c: 6e00 00a0 bgtw 591de <rtems_rfs_symlink_read+0x1aa> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
59140: 486e fffc pea %fp@(-4) <== NOT EXECUTED
59144: 42a7 clrl %sp@- <== NOT EXECUTED
59146: 42a7 clrl %sp@- <== NOT EXECUTED
59148: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5914a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5914c: 4eb9 0005 540e jsr 5540e <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
59152: 4fef 0014 lea %sp@(20),%sp <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
59156: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
59158: 6e2e bgts 59188 <rtems_rfs_symlink_read+0x154> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
5915a: 42a7 clrl %sp@- <== NOT EXECUTED
5915c: 2f2e fffc movel %fp@(-4),%sp@- <== NOT EXECUTED
59160: 2a0e movel %fp,%d5 <== NOT EXECUTED
59162: 0685 ffff fff2 addil #-14,%d5 <== NOT EXECUTED
59168: 2f05 movel %d5,%sp@- <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
5916a: 4200 clrb %d0 <== NOT EXECUTED
5916c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5916e: 1d40 fff2 moveb %d0,%fp@(-14) <== NOT EXECUTED
handle->bnum = 0;
59172: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
handle->buffer = NULL;
59176: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
5917a: 4eb9 0005 5d00 jsr 55d00 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
59180: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
59184: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
59186: 6f1a bles 591a2 <rtems_rfs_symlink_read+0x16e> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
59188: 2f04 movel %d4,%sp@- <== NOT EXECUTED
5918a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
5918c: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
59192: 2f0a movel %a2,%sp@- <== NOT EXECUTED
59194: 2f02 movel %d2,%sp@- <== NOT EXECUTED
59196: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
5919c: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
591a0: 6060 bras 59202 <rtems_rfs_symlink_read+0x1ce> <== NOT EXECUTED
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
591a2: 2f14 movel %a4@,%sp@- <== NOT EXECUTED
591a4: 206e fff8 moveal %fp@(-8),%a0 <== NOT EXECUTED
591a8: 2f28 001e movel %a0@(30),%sp@- <== NOT EXECUTED
591ac: 2f0b movel %a3,%sp@- <== NOT EXECUTED
591ae: 4eb9 0005 b134 jsr 5b134 <memcpy> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
591b4: 2f05 movel %d5,%sp@- <== NOT EXECUTED
591b6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
591b8: 4eb9 0005 5b88 jsr 55b88 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
591be: 4201 clrb %d1 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
591c0: 2f04 movel %d4,%sp@- <== NOT EXECUTED
591c2: 1d41 fff2 moveb %d1,%fp@(-14) <== NOT EXECUTED
591c6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
handle->bnum = 0;
591c8: 42ae fff4 clrl %fp@(-12) <== NOT EXECUTED
handle->buffer = NULL;
591cc: 42ae fff8 clrl %fp@(-8) <== NOT EXECUTED
591d0: 4eb9 0005 5168 jsr 55168 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
591d6: 4fef 001c lea %sp@(28),%sp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
591da: 2600 movel %d0,%d3 <== NOT EXECUTED
if (rc > 0)
591dc: 6f0c bles 591ea <rtems_rfs_symlink_read+0x1b6> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
591de: 2f0a movel %a2,%sp@- <== NOT EXECUTED
591e0: 2f02 movel %d2,%sp@- <== NOT EXECUTED
591e2: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
591e8: 6016 bras 59200 <rtems_rfs_symlink_read+0x1cc> <== NOT EXECUTED
return rc;
}
}
path[*length] = '\0';
591ea: 2014 movel %a4@,%d0
591ec: 4203 clrb %d3
591ee: 1783 0800 moveb %d3,%a3@(00000000,%d0:l)
rc = rtems_rfs_inode_close (fs, &inode);
591f2: 486e ffcc pea %fp@(-52)
591f6: 2f02 movel %d2,%sp@-
591f8: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close>
591fe: 2600 movel %d0,%d3
return rc;
59200: 508f addql #8,%sp
}
59202: 2003 movel %d3,%d0
59204: 4cee 1c3c ff64 moveml %fp@(-156),%d2-%d5/%a2-%a4
5920a: 4e5e unlk %fp
...
0004f42a <rtems_rfs_trace_clear_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
4f42a: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
4f42e: 2239 0006 e314 movel 6e314 <rtems_rfs_trace_flags+0x4>,%d1 <== NOT EXECUTED
return state;
}
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
4f434: 2f03 movel %d3,%sp@- <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
4f436: 262e 0008 movel %fp@(8),%d3 <== NOT EXECUTED
4f43a: 4683 notl %d3 <== NOT EXECUTED
return state;
}
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
4f43c: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
4f43e: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
4f442: 4682 notl %d2 <== NOT EXECUTED
}
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
4f444: 2039 0006 e310 movel 6e310 <rtems_rfs_trace_flags>,%d0 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
4f44a: c481 andl %d1,%d2 <== NOT EXECUTED
4f44c: c680 andl %d0,%d3 <== NOT EXECUTED
4f44e: 23c2 0006 e314 movel %d2,6e314 <rtems_rfs_trace_flags+0x4> <== NOT EXECUTED
return state;
}
4f454: 241f movel %sp@+,%d2 <== NOT EXECUTED
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
4f456: 23c3 0006 e310 movel %d3,6e310 <rtems_rfs_trace_flags> <== NOT EXECUTED
return state;
}
4f45c: 261f movel %sp@+,%d3 <== NOT EXECUTED
4f45e: 4e5e unlk %fp <== NOT EXECUTED
0004f3fa <rtems_rfs_trace_set_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
4f3fa: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
4f3fe: 2039 0006 e310 movel 6e310 <rtems_rfs_trace_flags>,%d0 <== NOT EXECUTED
return result;
}
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
4f404: 2f02 movel %d2,%sp@- <== NOT EXECUTED
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags |= mask;
4f406: 242e 0008 movel %fp@(8),%d2 <== NOT EXECUTED
4f40a: 8480 orl %d0,%d2 <== NOT EXECUTED
}
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
4f40c: 2239 0006 e314 movel 6e314 <rtems_rfs_trace_flags+0x4>,%d1 <== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
4f412: 23c2 0006 e310 movel %d2,6e310 <rtems_rfs_trace_flags> <== NOT EXECUTED
4f418: 242e 000c movel %fp@(12),%d2 <== NOT EXECUTED
4f41c: 8481 orl %d1,%d2 <== NOT EXECUTED
4f41e: 23c2 0006 e314 movel %d2,6e314 <rtems_rfs_trace_flags+0x4> <== NOT EXECUTED
return state;
}
4f424: 241f movel %sp@+,%d2 <== NOT EXECUTED
4f426: 4e5e unlk %fp <== NOT EXECUTED
0004f462 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
4f462: 4e56 ff30 linkw %fp,#-208 <== NOT EXECUTED
4f466: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ <== NOT EXECUTED
const char* table[] =
4f46a: 4878 0098 pea 98 <DBL_MANT_DIG+0x63> <== NOT EXECUTED
4f46e: 240e movel %fp,%d2 <== NOT EXECUTED
4f470: 4879 0006 b0b6 pea 6b0b6 <rtems_rfs_rtems_link_handlers+0x292><== NOT EXECUTED
4f476: 0682 ffff ff68 addil #-152,%d2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f47c: 7801 moveq #1,%d4 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
4f47e: 47f9 0005 b9a0 lea 5b9a0 <strcmp>,%a3 <== NOT EXECUTED
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
set_value = 1 << t;
else
clear_value = 1 << t;
4f484: 7a01 moveq #1,%d5 <== NOT EXECUTED
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
4f486: 2c2e 000c movel %fp@(12),%d6 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
4f48a: 2846 moveal %d6,%a4 <== NOT EXECUTED
4f48c: 588c addql #4,%a4 <== NOT EXECUTED
{
const char* table[] =
4f48e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
4f490: 7601 moveq #1,%d3 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
4f492: 4eb9 0005 b134 jsr 5b134 <memcpy> <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f498: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
"file-close",
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
4f49c: 4280 clrl %d0 <== NOT EXECUTED
4f49e: 4281 clrl %d1 <== NOT EXECUTED
4f4a0: 2d40 ff58 movel %d0,%fp@(-168) <== NOT EXECUTED
4f4a4: 2d41 ff5c movel %d1,%fp@(-164) <== NOT EXECUTED
"file-open",
"file-close",
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
4f4a8: 2d40 ff60 movel %d0,%fp@(-160) <== NOT EXECUTED
4f4ac: 2d41 ff64 movel %d1,%fp@(-156) <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f4b0: 6000 0142 braw 4f5f4 <rtems_rfs_trace_shell_command+0x192><== NOT EXECUTED
{
if (argv[arg][0] == '-')
4f4b4: 245c moveal %a4@+,%a2 <== NOT EXECUTED
4f4b6: 722d moveq #45,%d1 <== NOT EXECUTED
4f4b8: 1012 moveb %a2@,%d0 <== NOT EXECUTED
4f4ba: 49c0 extbl %d0 <== NOT EXECUTED
4f4bc: b280 cmpl %d0,%d1 <== NOT EXECUTED
4f4be: 6670 bnes 4f530 <rtems_rfs_trace_shell_command+0xce><== NOT EXECUTED
{
switch (argv[arg][1])
4f4c0: 123c 0068 moveb #104,%d1 <== NOT EXECUTED
4f4c4: 102a 0001 moveb %a2@(1),%d0 <== NOT EXECUTED
4f4c8: 49c0 extbl %d0 <== NOT EXECUTED
4f4ca: b280 cmpl %d0,%d1 <== NOT EXECUTED
4f4cc: 670a beqs 4f4d8 <rtems_rfs_trace_shell_command+0x76><== NOT EXECUTED
4f4ce: 123c 006c moveb #108,%d1 <== NOT EXECUTED
4f4d2: b280 cmpl %d0,%d1 <== NOT EXECUTED
4f4d4: 6646 bnes 4f51c <rtems_rfs_trace_shell_command+0xba><== NOT EXECUTED
4f4d6: 6016 bras 4f4ee <rtems_rfs_trace_shell_command+0x8c><== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
4f4d8: 2046 moveal %d6,%a0 <== NOT EXECUTED
4f4da: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4f4dc: 4879 0006 ae80 pea 6ae80 <rtems_rfs_rtems_link_handlers+0x5c><== NOT EXECUTED
4f4e2: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
return 0;
4f4e8: 508f addql #8,%sp <== NOT EXECUTED
4f4ea: 6000 0110 braw 4f5fc <rtems_rfs_trace_shell_command+0x19a><== NOT EXECUTED
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
4f4ee: 2046 moveal %d6,%a0 <== NOT EXECUTED
4f4f0: 47f9 0005 b318 lea 5b318 <printf>,%a3 <== NOT EXECUTED
4f4f6: 45ee ff68 lea %fp@(-152),%a2 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
4f4fa: 240e movel %fp,%d2 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
4f4fc: 2f10 movel %a0@,%sp@- <== NOT EXECUTED
4f4fe: 4879 0006 aea5 pea 6aea5 <rtems_rfs_rtems_link_handlers+0x81><== NOT EXECUTED
4f504: 4e93 jsr %a3@ <== NOT EXECUTED
4f506: 600a bras 4f512 <rtems_rfs_trace_shell_command+0xb0><== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
4f508: 2f1a movel %a2@+,%sp@- <== NOT EXECUTED
4f50a: 4879 0006 aecb pea 6aecb <rtems_rfs_rtems_link_handlers+0xa7><== NOT EXECUTED
4f510: 4e93 jsr %a3@ <== NOT EXECUTED
4f512: 508f addql #8,%sp <== NOT EXECUTED
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
4f514: b48a cmpl %a2,%d2 <== NOT EXECUTED
4f516: 66f0 bnes 4f508 <rtems_rfs_trace_shell_command+0xa6><== NOT EXECUTED
4f518: 6000 00e2 braw 4f5fc <rtems_rfs_trace_shell_command+0x19a><== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
4f51c: 4879 0006 aed1 pea 6aed1 <rtems_rfs_rtems_link_handlers+0xad><== NOT EXECUTED
4f522: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
return 1;
4f528: 588f addql #4,%sp <== NOT EXECUTED
4f52a: 7001 moveq #1,%d0 <== NOT EXECUTED
4f52c: 6000 00d0 braw 4f5fe <rtems_rfs_trace_shell_command+0x19c><== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
4f530: 4879 0006 984e pea 6984e <rtems_filesystem_table+0x4dc> <== NOT EXECUTED
4f536: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f538: 4e93 jsr %a3@ <== NOT EXECUTED
4f53a: 508f addql #8,%sp <== NOT EXECUTED
4f53c: 4a80 tstl %d0 <== NOT EXECUTED
4f53e: 6602 bnes 4f542 <rtems_rfs_trace_shell_command+0xe0><== NOT EXECUTED
set = true;
4f540: 7601 moveq #1,%d3 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
4f542: 4879 0006 aee7 pea 6aee7 <rtems_rfs_rtems_link_handlers+0xc3><== NOT EXECUTED
4f548: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f54a: 4e93 jsr %a3@ <== NOT EXECUTED
4f54c: 508f addql #8,%sp <== NOT EXECUTED
4f54e: 4a80 tstl %d0 <== NOT EXECUTED
4f550: 6764 beqs 4f5b6 <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
4f552: 4879 0006 ca14 pea 6ca14 <_global_impure_ptr+0x54> <== NOT EXECUTED
4f558: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f55a: 4e93 jsr %a3@ <== NOT EXECUTED
4f55c: 508f addql #8,%sp <== NOT EXECUTED
4f55e: 4a80 tstl %d0 <== NOT EXECUTED
4f560: 6708 beqs 4f56a <rtems_rfs_trace_shell_command+0x108><== NOT EXECUTED
4f562: 4bee ff68 lea %fp@(-152),%a5 <== NOT EXECUTED
4f566: 4282 clrl %d2 <== NOT EXECUTED
4f568: 6012 bras 4f57c <rtems_rfs_trace_shell_command+0x11a><== NOT EXECUTED
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
4f56a: 70ff moveq #-1,%d0 <== NOT EXECUTED
4f56c: 72ff moveq #-1,%d1 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
4f56e: 4a03 tstb %d3 <== NOT EXECUTED
4f570: 6748 beqs 4f5ba <rtems_rfs_trace_shell_command+0x158><== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
4f572: 2d40 ff60 movel %d0,%fp@(-160) <== NOT EXECUTED
4f576: 2d41 ff64 movel %d1,%fp@(-156) <== NOT EXECUTED
4f57a: 6046 bras 4f5c2 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
4f57c: 2f1d movel %a5@+,%sp@- <== NOT EXECUTED
4f57e: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4f580: 4e93 jsr %a3@ <== NOT EXECUTED
4f582: 508f addql #8,%sp <== NOT EXECUTED
4f584: 4a80 tstl %d0 <== NOT EXECUTED
4f586: 6624 bnes 4f5ac <rtems_rfs_trace_shell_command+0x14a><== NOT EXECUTED
{
if (set)
set_value = 1 << t;
4f588: 2005 movel %d5,%d0 <== NOT EXECUTED
4f58a: e5a8 lsll %d2,%d0 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
4f58c: 4a03 tstb %d3 <== NOT EXECUTED
4f58e: 670e beqs 4f59e <rtems_rfs_trace_shell_command+0x13c><== NOT EXECUTED
set_value = 1 << t;
4f590: 2d40 ff64 movel %d0,%fp@(-156) <== NOT EXECUTED
4f594: 5bc1 smi %d1 <== NOT EXECUTED
4f596: 49c1 extbl %d1 <== NOT EXECUTED
4f598: 2d41 ff60 movel %d1,%fp@(-160) <== NOT EXECUTED
4f59c: 6024 bras 4f5c2 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
else
clear_value = 1 << t;
4f59e: 2d40 ff5c movel %d0,%fp@(-164) <== NOT EXECUTED
4f5a2: 5bc1 smi %d1 <== NOT EXECUTED
4f5a4: 49c1 extbl %d1 <== NOT EXECUTED
4f5a6: 2d41 ff58 movel %d1,%fp@(-168) <== NOT EXECUTED
4f5aa: 6016 bras 4f5c2 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
4f5ac: 5282 addql #1,%d2 <== NOT EXECUTED
4f5ae: 7026 moveq #38,%d0 <== NOT EXECUTED
4f5b0: b082 cmpl %d2,%d0 <== NOT EXECUTED
4f5b2: 66c8 bnes 4f57c <rtems_rfs_trace_shell_command+0x11a><== NOT EXECUTED
4f5b4: 600c bras 4f5c2 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
4f5b6: 4203 clrb %d3 <== NOT EXECUTED
4f5b8: 6008 bras 4f5c2 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
4f5ba: 2d40 ff58 movel %d0,%fp@(-168) <== NOT EXECUTED
4f5be: 2d41 ff5c movel %d1,%fp@(-164) <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
4f5c2: 242e ff60 movel %fp@(-160),%d2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f5c6: 5284 addql #1,%d4 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
4f5c8: 202e ff64 movel %fp@(-156),%d0 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
4f5cc: 2e2e ff58 movel %fp@(-168),%d7 <== NOT EXECUTED
4f5d0: 4687 notl %d7 <== NOT EXECUTED
4f5d2: 222e ff5c movel %fp@(-164),%d1 <== NOT EXECUTED
4f5d6: 4681 notl %d1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
4f5d8: 84b9 0006 e310 orl 6e310 <rtems_rfs_trace_flags>,%d2 <== NOT EXECUTED
4f5de: 80b9 0006 e314 orl 6e314 <rtems_rfs_trace_flags+0x4>,%d0 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
4f5e4: ce82 andl %d2,%d7 <== NOT EXECUTED
4f5e6: c280 andl %d0,%d1 <== NOT EXECUTED
4f5e8: 23c7 0006 e310 movel %d7,6e310 <rtems_rfs_trace_flags> <== NOT EXECUTED
4f5ee: 23c1 0006 e314 movel %d1,6e314 <rtems_rfs_trace_flags+0x4> <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4f5f4: b8ae 0008 cmpl %fp@(8),%d4 <== NOT EXECUTED
4f5f8: 6d00 feba bltw 4f4b4 <rtems_rfs_trace_shell_command+0x52><== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
4f5fc: 4280 clrl %d0 <== NOT EXECUTED
}
4f5fe: 4cee 3cfc ff30 moveml %fp@(-208),%d2-%d7/%a2-%a5 <== NOT EXECUTED
4f604: 4e5e unlk %fp <== NOT EXECUTED
00058a4a <rtems_rfs_unlink>:
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
58a4a: 4e56 ff98 linkw %fp,#-104
58a4e: 48d7 04fc moveml %d2-%d7/%a2,%sp@
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58a52: 2f3c 0200 0000 movel #33554432,%sp@-
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
58a58: 262e 0008 movel %fp@(8),%d3
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58a5c: 42a7 clrl %sp@-
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
58a5e: 2c2e 000c movel %fp@(12),%d6
58a62: 282e 0010 movel %fp@(16),%d4
58a66: 2e2e 0018 movel %fp@(24),%d7
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58a6a: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
58a70: 508f addql #8,%sp
58a72: 4a00 tstb %d0
58a74: 6714 beqs 58a8a <rtems_rfs_unlink+0x40> <== ALWAYS TAKEN
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
58a76: 2f04 movel %d4,%sp@- <== NOT EXECUTED
58a78: 2f06 movel %d6,%sp@- <== NOT EXECUTED
58a7a: 4879 0006 c521 pea 6c521 <CSWTCH.1+0x127b> <== NOT EXECUTED
58a80: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
58a86: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
58a8a: 4878 0001 pea 1 <ADD>
58a8e: 45ee ffda lea %fp@(-38),%a2
58a92: 2f0a movel %a2,%sp@-
58a94: 2f04 movel %d4,%sp@-
58a96: 2f03 movel %d3,%sp@-
58a98: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc)
58a9e: 4fef 0010 lea %sp@(16),%sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
58aa2: 2400 movel %d0,%d2
if (rc)
58aa4: 6600 031e bnew 58dc4 <rtems_rfs_unlink+0x37a>
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
58aa8: 206a 000c moveal %a2@(12),%a0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
58aac: 4280 clrl %d0
58aae: 1028 0002 moveb %a0@(2),%d0
58ab2: e188 lsll #8,%d0
58ab4: 0280 0000 f000 andil #61440,%d0
58aba: 0c80 0000 4000 cmpil #16384,%d0
58ac0: 57c5 seq %d5
58ac2: 4485 negl %d5
if (dir)
58ac4: 4a05 tstb %d5
58ac6: 677e beqs 58b46 <rtems_rfs_unlink+0xfc> <== ALWAYS TAKEN
{
switch (dir_mode)
58ac8: 4a87 tstl %d7 <== NOT EXECUTED
58aca: 6708 beqs 58ad4 <rtems_rfs_unlink+0x8a> <== NOT EXECUTED
58acc: 7001 moveq #1,%d0 <== NOT EXECUTED
58ace: b087 cmpl %d7,%d0 <== NOT EXECUTED
58ad0: 6674 bnes 58b46 <rtems_rfs_unlink+0xfc> <== NOT EXECUTED
58ad2: 6036 bras 58b0a <rtems_rfs_unlink+0xc0> <== NOT EXECUTED
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58ad4: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
58ada: 42a7 clrl %sp@- <== NOT EXECUTED
58adc: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58ae2: 508f addql #8,%sp <== NOT EXECUTED
58ae4: 4a00 tstb %d0 <== NOT EXECUTED
58ae6: 670e beqs 58af6 <rtems_rfs_unlink+0xac> <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
58ae8: 4879 0006 c54c pea 6c54c <CSWTCH.1+0x12a6> <== NOT EXECUTED
58aee: 4eb9 0005 b412 jsr 5b412 <puts> <== NOT EXECUTED
58af4: 588f addql #4,%sp <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
58af6: 486e ffda pea %fp@(-38) <== NOT EXECUTED
return EISDIR;
58afa: 7415 moveq #21,%d2 <== NOT EXECUTED
switch (dir_mode)
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
58afc: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58afe: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
return EISDIR;
58b04: 508f addql #8,%sp <== NOT EXECUTED
58b06: 6000 02bc braw 58dc4 <rtems_rfs_unlink+0x37a> <== NOT EXECUTED
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
58b0a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
58b0c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58b0e: 4eb9 0005 7162 jsr 57162 <rtems_rfs_dir_empty> <== NOT EXECUTED
if (rc > 0)
58b14: 508f addql #8,%sp <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
58b16: 2400 movel %d0,%d2 <== NOT EXECUTED
if (rc > 0)
58b18: 6f2c bles 58b46 <rtems_rfs_unlink+0xfc> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58b1a: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
58b20: 42a7 clrl %sp@- <== NOT EXECUTED
58b22: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58b28: 508f addql #8,%sp <== NOT EXECUTED
58b2a: 4a00 tstb %d0 <== NOT EXECUTED
58b2c: 6700 0248 beqw 58d76 <rtems_rfs_unlink+0x32c> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
58b30: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58b32: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58b38: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58b3a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58b3c: 4879 0006 c56b pea 6c56b <CSWTCH.1+0x12c5> <== NOT EXECUTED
58b42: 6000 0228 braw 58d6c <rtems_rfs_unlink+0x322> <== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
58b46: 4878 0001 pea 1 <ADD>
58b4a: 45ee ffb4 lea %fp@(-76),%a2
58b4e: 2f0a movel %a2,%sp@-
58b50: 2f06 movel %d6,%sp@-
58b52: 2f03 movel %d3,%sp@-
58b54: 4eb9 0004 d6e0 jsr 4d6e0 <rtems_rfs_inode_open>
if (rc)
58b5a: 4fef 0010 lea %sp@(16),%sp
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
58b5e: 2400 movel %d0,%d2
if (rc)
58b60: 672c beqs 58b8e <rtems_rfs_unlink+0x144> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58b62: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
58b68: 42a7 clrl %sp@- <== NOT EXECUTED
58b6a: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58b70: 508f addql #8,%sp <== NOT EXECUTED
58b72: 4a00 tstb %d0 <== NOT EXECUTED
58b74: 6700 0200 beqw 58d76 <rtems_rfs_unlink+0x32c> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
58b78: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58b7a: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58b80: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58b82: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58b84: 4879 0006 c589 pea 6c589 <CSWTCH.1+0x12e3> <== NOT EXECUTED
58b8a: 6000 01e0 braw 58d6c <rtems_rfs_unlink+0x322> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
58b8e: 2f2e 0014 movel %fp@(20),%sp@-
58b92: 2f04 movel %d4,%sp@-
58b94: 2f0a movel %a2,%sp@-
58b96: 2f03 movel %d3,%sp@-
58b98: 4eb9 0005 6aba jsr 56aba <rtems_rfs_dir_del_entry>
if (rc > 0)
58b9e: 4fef 0010 lea %sp@(16),%sp
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
58ba2: 2400 movel %d0,%d2
if (rc > 0)
58ba4: 6f2c bles 58bd2 <rtems_rfs_unlink+0x188> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58ba6: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
58bac: 42a7 clrl %sp@- <== NOT EXECUTED
58bae: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58bb4: 508f addql #8,%sp <== NOT EXECUTED
58bb6: 4a00 tstb %d0 <== NOT EXECUTED
58bb8: 6700 0160 beqw 58d1a <rtems_rfs_unlink+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
58bbc: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58bbe: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58bc4: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58bc6: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58bc8: 4879 0006 c5b5 pea 6c5b5 <CSWTCH.1+0x130f> <== NOT EXECUTED
58bce: 6000 0140 braw 58d10 <rtems_rfs_unlink+0x2c6> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
58bd2: 206e ffe6 moveal %fp@(-26),%a0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
58bd6: 4280 clrl %d0
58bd8: 1010 moveb %a0@,%d0
58bda: 4282 clrl %d2
58bdc: 1428 0001 moveb %a0@(1),%d2
58be0: e188 lsll #8,%d0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58be2: 2f3c 0200 0000 movel #33554432,%sp@-
58be8: 8480 orl %d0,%d2
if (links == 0xffff)
58bea: 4280 clrl %d0
58bec: 3002 movew %d2,%d0
58bee: 42a7 clrl %sp@-
links = 0;
58bf0: 0c80 0000 ffff cmpil #65535,%d0
58bf6: 56c0 sne %d0
58bf8: 4880 extw %d0
58bfa: c480 andl %d0,%d2
58bfc: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace>
58c02: 508f addql #8,%sp
58c04: 4a00 tstb %d0
58c06: 6716 beqs 58c1e <rtems_rfs_unlink+0x1d4> <== ALWAYS TAKEN
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
58c08: 3f02 movew %d2,%sp@- <== NOT EXECUTED
58c0a: 4267 clrw %sp@- <== NOT EXECUTED
58c0c: 2f04 movel %d4,%sp@- <== NOT EXECUTED
58c0e: 4879 0006 c5e0 pea 6c5e0 <CSWTCH.1+0x133a> <== NOT EXECUTED
58c14: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
58c1a: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
if (links > 1)
58c1e: 4280 clrl %d0
58c20: 7201 moveq #1,%d1
58c22: 3002 movew %d2,%d0
58c24: b280 cmpl %d0,%d1
58c26: 641e bccs 58c46 <rtems_rfs_unlink+0x1fc>
{
links--;
58c28: 5382 subql #1,%d2
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
58c2a: 2002 movel %d2,%d0
58c2c: e088 lsrl #8,%d0
58c2e: 206e ffe6 moveal %fp@(-26),%a0
58c32: 1080 moveb %d0,%a0@
rtems_rfs_buffer_mark_dirty (&handle->buffer);
58c34: 7801 moveq #1,%d4
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
58c36: 206e ffe6 moveal %fp@(-26),%a0
58c3a: 1142 0001 moveb %d2,%a0@(1)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
58c3e: 1d44 ffea moveb %d4,%fp@(-22)
58c42: 6000 0086 braw 58cca <rtems_rfs_unlink+0x280>
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
58c46: 486e ffda pea %fp@(-38)
58c4a: 2f03 movel %d3,%sp@-
58c4c: 4eb9 0004 d8f8 jsr 4d8f8 <rtems_rfs_inode_delete>
if (rc > 0)
58c52: 508f addql #8,%sp
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
58c54: 2400 movel %d0,%d2
if (rc > 0)
58c56: 6f2c bles 58c84 <rtems_rfs_unlink+0x23a> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58c58: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
58c5e: 42a7 clrl %sp@- <== NOT EXECUTED
58c60: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58c66: 508f addql #8,%sp <== NOT EXECUTED
58c68: 4a00 tstb %d0 <== NOT EXECUTED
58c6a: 6700 00ae beqw 58d1a <rtems_rfs_unlink+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
58c6e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58c70: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58c76: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58c78: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58c7a: 4879 0006 c608 pea 6c608 <CSWTCH.1+0x1362> <== NOT EXECUTED
58c80: 6000 008e braw 58d10 <rtems_rfs_unlink+0x2c6> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
58c84: 4a05 tstb %d5
58c86: 6742 beqs 58cca <rtems_rfs_unlink+0x280> <== ALWAYS TAKEN
{
links = rtems_rfs_inode_get_links (&parent_inode);
58c88: 206e ffc0 moveal %fp@(-64),%a0 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
58c8c: 4280 clrl %d0 <== NOT EXECUTED
58c8e: 1010 moveb %a0@,%d0 <== NOT EXECUTED
58c90: 4281 clrl %d1 <== NOT EXECUTED
58c92: 1228 0001 moveb %a0@(1),%d1 <== NOT EXECUTED
if (links == 0xffff)
58c96: 4282 clrl %d2 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
58c98: e188 lsll #8,%d0 <== NOT EXECUTED
58c9a: 8081 orl %d1,%d0 <== NOT EXECUTED
if (links == 0xffff)
58c9c: 3400 movew %d0,%d2 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
58c9e: 3200 movew %d0,%d1 <== NOT EXECUTED
if (links == 0xffff)
58ca0: 0c82 0000 ffff cmpil #65535,%d2 <== NOT EXECUTED
58ca6: 670c beqs 58cb4 <rtems_rfs_unlink+0x26a> <== NOT EXECUTED
if (links > 1)
58ca8: 7801 moveq #1,%d4 <== NOT EXECUTED
58caa: b882 cmpl %d2,%d4 <== NOT EXECUTED
58cac: 6408 bccs 58cb6 <rtems_rfs_unlink+0x26c> <== NOT EXECUTED
links--;
58cae: 2200 movel %d0,%d1 <== NOT EXECUTED
58cb0: 5381 subql #1,%d1 <== NOT EXECUTED
58cb2: 6002 bras 58cb6 <rtems_rfs_unlink+0x26c> <== NOT EXECUTED
links = 0;
58cb4: 4241 clrw %d1 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
58cb6: 2001 movel %d1,%d0 <== NOT EXECUTED
58cb8: e088 lsrl #8,%d0 <== NOT EXECUTED
58cba: 1080 moveb %d0,%a0@ <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
58cbc: 7001 moveq #1,%d0 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
58cbe: 206e ffc0 moveal %fp@(-64),%a0 <== NOT EXECUTED
58cc2: 1141 0001 moveb %d1,%a0@(1) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
58cc6: 1d40 ffc4 moveb %d0,%fp@(-60) <== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
58cca: 4878 0001 pea 1 <ADD>
58cce: 280e movel %fp,%d4
58cd0: 4878 0001 pea 1 <ADD>
58cd4: 0684 ffff ffb4 addil #-76,%d4
58cda: 2f04 movel %d4,%sp@-
58cdc: 4eb9 0004 d9ca jsr 4d9ca <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
58ce2: 4fef 000c lea %sp@(12),%sp
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
58ce6: 2400 movel %d0,%d2
if (rc > 0)
58ce8: 6f4a bles 58d34 <rtems_rfs_unlink+0x2ea> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58cea: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
58cf0: 42a7 clrl %sp@- <== NOT EXECUTED
58cf2: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58cf8: 508f addql #8,%sp <== NOT EXECUTED
58cfa: 4a00 tstb %d0 <== NOT EXECUTED
58cfc: 671c beqs 58d1a <rtems_rfs_unlink+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
58cfe: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58d00: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58d06: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58d08: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58d0a: 4879 0006 c635 pea 6c635 <CSWTCH.1+0x138f> <== NOT EXECUTED
58d10: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
58d16: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
58d1a: 486e ffb4 pea %fp@(-76) <== NOT EXECUTED
58d1e: 45f9 0004 d876 lea 4d876 <rtems_rfs_inode_close>,%a2 <== NOT EXECUTED
58d24: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58d26: 4e92 jsr %a2@ <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
58d28: 486e ffda pea %fp@(-38) <== NOT EXECUTED
58d2c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58d2e: 4e92 jsr %a2@ <== NOT EXECUTED
58d30: 6000 008e braw 58dc0 <rtems_rfs_unlink+0x376> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
58d34: 2f04 movel %d4,%sp@-
58d36: 45f9 0004 d876 lea 4d876 <rtems_rfs_inode_close>,%a2
58d3c: 2f03 movel %d3,%sp@-
58d3e: 4e92 jsr %a2@
if (rc > 0)
58d40: 508f addql #8,%sp
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
58d42: 2400 movel %d0,%d2
if (rc > 0)
58d44: 6f40 bles 58d86 <rtems_rfs_unlink+0x33c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58d46: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
58d4c: 42a7 clrl %sp@- <== NOT EXECUTED
58d4e: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58d54: 508f addql #8,%sp <== NOT EXECUTED
58d56: 4a00 tstb %d0 <== NOT EXECUTED
58d58: 671c beqs 58d76 <rtems_rfs_unlink+0x32c> <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
58d5a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58d5c: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58d62: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58d64: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58d66: 4879 0006 c667 pea 6c667 <CSWTCH.1+0x13c1> <== NOT EXECUTED
58d6c: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
58d72: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
58d76: 486e ffda pea %fp@(-38) <== NOT EXECUTED
58d7a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
58d7c: 4eb9 0004 d876 jsr 4d876 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
58d82: 508f addql #8,%sp <== NOT EXECUTED
58d84: 603e bras 58dc4 <rtems_rfs_unlink+0x37a> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
58d86: 486e ffda pea %fp@(-38)
58d8a: 2f03 movel %d3,%sp@-
58d8c: 4e92 jsr %a2@
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58d8e: 508f addql #8,%sp
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
58d90: 2400 movel %d0,%d2
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
58d92: 6f30 bles 58dc4 <rtems_rfs_unlink+0x37a> <== ALWAYS TAKEN
58d94: 2f3c 0200 0000 movel #33554432,%sp@- <== NOT EXECUTED
58d9a: 42a7 clrl %sp@- <== NOT EXECUTED
58d9c: 4eb9 0004 f3d8 jsr 4f3d8 <rtems_rfs_trace> <== NOT EXECUTED
58da2: 508f addql #8,%sp <== NOT EXECUTED
58da4: 4a00 tstb %d0 <== NOT EXECUTED
58da6: 671c beqs 58dc4 <rtems_rfs_unlink+0x37a> <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
58da8: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58daa: 4eb9 0005 bf38 jsr 5bf38 <strerror> <== NOT EXECUTED
58db0: 2f00 movel %d0,%sp@- <== NOT EXECUTED
58db2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
58db4: 4879 0006 c69b pea 6c69b <CSWTCH.1+0x13f5> <== NOT EXECUTED
58dba: 4eb9 0005 b318 jsr 5b318 <printf> <== NOT EXECUTED
58dc0: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
58dc4: 2002 movel %d2,%d0
58dc6: 4cee 04fc ff98 moveml %fp@(-104),%d2-%d7/%a2
58dcc: 4e5e unlk %fp <== NOT EXECUTED
0004602c <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
4602c: 7003 moveq #3,%d0
*/
void rtems_shutdown_executive(
uint32_t result
)
{
4602e: 4e56 0000 linkw %fp,#0
if ( _System_state_Is_up( _System_state_Get() ) ) {
46032: b0b9 0005 d968 cmpl 5d968 <_System_state_Current>,%d0
46038: 6624 bnes 4605e <rtems_shutdown_executive+0x32>
#if defined(RTEMS_SMP)
_SMP_Request_other_cores_to_shutdown();
#endif
_Per_CPU_Information[0].idle->Wait.return_code = result;
4603a: 2079 0005 d9c4 moveal 5d9c4 <_Per_CPU_Information+0x14>,%a0
46040: 103c 0004 moveb #4,%d0
46044: 216e 0008 0034 movel %fp@(8),%a0@(52)
* if we were running within the same context, it would work.
*
* And we will not return to this thread, so there is no point of
* saving the context.
*/
_Context_Restart_self( &_Thread_BSP_context );
4604a: 4879 0005 d7f4 pea 5d7f4 <_Thread_BSP_context>
46050: 23c0 0005 d968 movel %d0,5d968 <_System_state_Current>
46056: 4eb9 0004 8ba2 jsr 48ba2 <_CPU_Context_Restart_self>
4605c: 588f addql #4,%sp <== NOT EXECUTED
****** AND THEN TO BOOT_CARD() ******
*******************************************************************
*******************************************************************
*******************************************************************/
}
_Internal_error_Occurred(
4605e: 4878 0014 pea 14 <OPER2>
46062: 4878 0001 pea 1 <ADD>
46066: 42a7 clrl %sp@-
46068: 4eb9 0004 6b84 jsr 46b84 <_Internal_error_Occurred>
...
00050b0c <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
50b0c: 4e56 fffc linkw %fp,#-4
50b10: 2f03 movel %d3,%sp@-
50b12: 2f02 movel %d2,%sp@-
50b14: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
50b18: 6776 beqs 50b90 <rtems_signal_send+0x84>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
50b1a: 486e fffc pea %fp@(-4)
50b1e: 2f2e 0008 movel %fp@(8),%sp@-
50b22: 4eb9 0005 4968 jsr 54968 <_Thread_Get>
switch ( location ) {
50b28: 508f addql #8,%sp
50b2a: 4aae fffc tstl %fp@(-4)
50b2e: 6664 bnes 50b94 <rtems_signal_send+0x88>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
50b30: 2240 moveal %d0,%a1
50b32: 2069 00fc moveal %a1@(252),%a0
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
50b36: 4aa8 000a tstl %a0@(10)
50b3a: 674a beqs 50b86 <rtems_signal_send+0x7a>
50b3c: 223c 0000 0700 movel #1792,%d1
if ( asr->is_enabled ) {
50b42: 4a28 0008 tstb %a0@(8)
50b46: 6726 beqs 50b6e <rtems_signal_send+0x62>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
50b48: 40c3 movew %sr,%d3
50b4a: 8283 orl %d3,%d1
50b4c: 46c1 movew %d1,%sr
*signal_set |= signals;
50b4e: 85a8 0012 orl %d2,%a0@(18)
_ISR_Enable( _level );
50b52: 46c3 movew %d3,%sr
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
50b54: 4ab9 0007 57fc tstl 757fc <_Per_CPU_Information+0x8>
50b5a: 6720 beqs 50b7c <rtems_signal_send+0x70>
50b5c: b0b9 0007 5800 cmpl 75800 <_Per_CPU_Information+0xc>,%d0
50b62: 6618 bnes 50b7c <rtems_signal_send+0x70> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
50b64: 7001 moveq #1,%d0
50b66: 13c0 0007 580c moveb %d0,7580c <_Per_CPU_Information+0x18>
50b6c: 600e bras 50b7c <rtems_signal_send+0x70>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
50b6e: 2001 movel %d1,%d0
50b70: 40c1 movew %sr,%d1
50b72: 8081 orl %d1,%d0
50b74: 46c0 movew %d0,%sr
*signal_set |= signals;
50b76: 85a8 0016 orl %d2,%a0@(22)
_ISR_Enable( _level );
50b7a: 46c1 movew %d1,%sr
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
50b7c: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
50b82: 4280 clrl %d0
50b84: 6010 bras 50b96 <rtems_signal_send+0x8a>
}
_Thread_Enable_dispatch();
50b86: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
50b8c: 700b moveq #11,%d0
50b8e: 6006 bras 50b96 <rtems_signal_send+0x8a>
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
50b90: 700a moveq #10,%d0
50b92: 6002 bras 50b96 <rtems_signal_send+0x8a>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
50b94: 7004 moveq #4,%d0
}
50b96: 242e fff4 movel %fp@(-12),%d2
50b9a: 262e fff8 movel %fp@(-8),%d3
50b9e: 4e5e unlk %fp
...
000420a0 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
420a0: 4e56 0000 linkw %fp,#0
420a4: 206e 0008 moveal %fp@(8),%a0
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
420a8: 4aa8 0008 tstl %a0@(8)
420ac: 671c beqs 420ca <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;
420ae: 4878 0010 pea 10 <INVALID_OPERATION>
420b2: 4879 0005 da50 pea 5da50 <Stack_check_Pattern>
420b8: 2068 00b4 moveal %a0@(180),%a0
420bc: 5088 addql #8,%a0
420be: 2f08 movel %a0,%sp@-
420c0: 4eb9 0004 cb64 jsr 4cb64 <memcpy>
420c6: 4fef 000c lea %sp@(12),%sp
}
420ca: 4e5e unlk %fp <== NOT EXECUTED
0004206c <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
4206c: 4e56 0000 linkw %fp,#0
42070: 2f0a movel %a2,%sp@-
42072: 246e 000c moveal %fp@(12),%a2
Stack_check_Initialize();
42076: 4eb9 0004 1ff4 jsr 41ff4 <Stack_check_Initialize>
if (the_thread)
4207c: 4a8a tstl %a2
4207e: 6716 beqs 42096 <rtems_stack_checker_create_extension+0x2a><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
42080: 2f2a 00b0 movel %a2@(176),%sp@-
42084: 4878 00a5 pea a5 <DBL_MANT_DIG+0x70>
42088: 2f2a 00b4 movel %a2@(180),%sp@-
4208c: 4eb9 0004 cbd4 jsr 4cbd4 <memset>
42092: 4fef 000c lea %sp@(12),%sp
return true;
}
42096: 246e fffc moveal %fp@(-4),%a2
4209a: 4e5e unlk %fp
4209c: 7001 moveq #1,%d0 <== NOT EXECUTED
000421dc <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
421dc: 4e56 0000 linkw %fp,#0
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
421e0: 2279 0005 dd50 moveal 5dd50 <_Per_CPU_Information+0xc>,%a1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
421e6: 2069 00b4 moveal %a1@(180),%a0
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
421ea: 2f02 movel %d2,%sp@-
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
421ec: b1ce cmpal %fp,%a0
421ee: 620e bhis 421fe <rtems_stack_checker_is_blown+0x22><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
421f0: 2008 movel %a0,%d0
421f2: d0a9 00b0 addl %a1@(176),%d0
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
421f6: b08e cmpl %fp,%d0
421f8: 54c2 scc %d2
421fa: 4482 negl %d2
421fc: 6002 bras 42200 <rtems_stack_checker_is_blown+0x24>
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
421fe: 4202 clrb %d2 <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
42200: 4ab9 0005 d248 tstl 5d248 <Stack_check_Initialized>
42206: 6720 beqs 42228 <rtems_stack_checker_is_blown+0x4c><== NEVER TAKEN
pattern_ok = (!memcmp(
42208: 4878 0010 pea 10 <INVALID_OPERATION>
4220c: 4879 0005 da50 pea 5da50 <Stack_check_Pattern>
42212: 4868 0008 pea %a0@(8)
42216: 4eb9 0004 cadc jsr 4cadc <memcmp>
4221c: 4fef 000c lea %sp@(12),%sp
42220: 4a80 tstl %d0
42222: 57c0 seq %d0
42224: 4480 negl %d0
42226: 6002 bras 4222a <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;
42228: 7001 moveq #1,%d0 <== NOT EXECUTED
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
4222a: 4a02 tstb %d2
4222c: 6704 beqs 42232 <rtems_stack_checker_is_blown+0x56><== NEVER TAKEN
4222e: 4a00 tstb %d0
42230: 6614 bnes 42246 <rtems_stack_checker_is_blown+0x6a><== ALWAYS TAKEN
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
42232: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
42238: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4223a: 2f39 0005 dd50 movel 5dd50 <_Per_CPU_Information+0xc>,%sp@-<== NOT EXECUTED
42240: 4eb9 0004 20ce jsr 420ce <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
42246: 242e fffc movel %fp@(-4),%d2
4224a: 4e5e unlk %fp
4224c: 4200 clrb %d0 <== NOT EXECUTED
000422b6 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
422b6: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
422ba: 4879 0004 3a40 pea 43a40 <printk_plugin> <== NOT EXECUTED
422c0: 42a7 clrl %sp@- <== NOT EXECUTED
422c2: 4eb9 0004 2250 jsr 42250 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
422c8: 508f addql #8,%sp <== NOT EXECUTED
}
422ca: 4e5e unlk %fp <== NOT EXECUTED
...
00042250 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
42250: 4e56 0000 linkw %fp,#0 <== NOT EXECUTED
42254: 2f0a movel %a2,%sp@- <== NOT EXECUTED
42256: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
4225a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4225c: 242e 0008 movel %fp@(8),%d2 <== NOT EXECUTED
if ( !print )
42260: 4a8a tstl %a2 <== NOT EXECUTED
42262: 6746 beqs 422aa <rtems_stack_checker_report_usage_with_plugin+0x5a><== NOT EXECUTED
return;
print_context = context;
print_handler = print;
(*print)( context, "Stack usage by thread\n");
42264: 4879 0005 af57 pea 5af57 <map.6391+0x12d> <== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
4226a: 23c2 0005 d250 movel %d2,5d250 <print_context> <== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
42270: 2f02 movel %d2,%sp@- <== NOT EXECUTED
{
if ( !print )
return;
print_context = context;
print_handler = print;
42272: 23ca 0005 d24c movel %a2,5d24c <print_handler> <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
42278: 4e92 jsr %a2@ <== NOT EXECUTED
(*print)( context,
4227a: 4879 0005 af6e pea 5af6e <map.6391+0x144> <== NOT EXECUTED
42280: 2f02 movel %d2,%sp@- <== NOT EXECUTED
42282: 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 );
42284: 4879 0004 1ed8 pea 41ed8 <Stack_check_Dump_threads_usage> <== NOT EXECUTED
4228a: 4eb9 0004 6e18 jsr 46e18 <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);
42290: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
42294: 4eb9 0004 1ed8 jsr 41ed8 <Stack_check_Dump_threads_usage> <== NOT EXECUTED
#endif
print_context = NULL;
print_handler = NULL;
4229a: 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;
4229e: 42b9 0005 d250 clrl 5d250 <print_context> <== NOT EXECUTED
print_handler = NULL;
422a4: 42b9 0005 d24c clrl 5d24c <print_handler> <== NOT EXECUTED
}
422aa: 242e fff8 movel %fp@(-8),%d2 <== NOT EXECUTED
422ae: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
422b2: 4e5e unlk %fp <== NOT EXECUTED
00042174 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
42174: 4e56 0000 linkw %fp,#0
42178: 2f0a movel %a2,%sp@-
4217a: 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);
4217e: 222a 00b4 movel %a2@(180),%d1
42182: 5081 addql #8,%d1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
42184: 202a 00b4 movel %a2@(180),%d0
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
42188: 2f02 movel %d2,%sp@-
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
4218a: b08e cmpl %fp,%d0
4218c: 620c bhis 4219a <rtems_stack_checker_switch_extension+0x26><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
4218e: d0aa 00b0 addl %a2@(176),%d0
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
42192: b08e cmpl %fp,%d0
42194: 54c2 scc %d2
42196: 4482 negl %d2
42198: 6002 bras 4219c <rtems_stack_checker_switch_extension+0x28>
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
4219a: 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,
4219c: 4878 0010 pea 10 <INVALID_OPERATION>
421a0: 4879 0005 da50 pea 5da50 <Stack_check_Pattern>
421a6: 2f01 movel %d1,%sp@-
421a8: 4eb9 0004 cadc jsr 4cadc <memcmp>
421ae: 4fef 000c lea %sp@(12),%sp
421b2: 4a80 tstl %d0
421b4: 57c0 seq %d0
421b6: 4480 negl %d0
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
421b8: 4a02 tstb %d2
421ba: 6704 beqs 421c0 <rtems_stack_checker_switch_extension+0x4c><== NEVER TAKEN
421bc: 4a00 tstb %d0
421be: 6610 bnes 421d0 <rtems_stack_checker_switch_extension+0x5c><== ALWAYS TAKEN
Stack_check_report_blown_task( running, pattern_ok );
421c0: 0280 0000 00ff andil #255,%d0 <== NOT EXECUTED
421c6: 2f00 movel %d0,%sp@- <== NOT EXECUTED
421c8: 2f0a movel %a2,%sp@- <== NOT EXECUTED
421ca: 4eb9 0004 20ce jsr 420ce <Stack_check_report_blown_task> <== NOT EXECUTED
}
}
421d0: 242e fff8 movel %fp@(-8),%d2
421d4: 246e fffc moveal %fp@(-4),%a2
421d8: 4e5e unlk %fp <== NOT EXECUTED
0004ba90 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
4ba90: 4e56 ffe8 linkw %fp,#-24 <== NOT EXECUTED
4ba94: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ <== NOT EXECUTED
4ba98: 282e 0008 movel %fp@(8),%d4 <== NOT EXECUTED
4ba9c: 246e 000c moveal %fp@(12),%a2 <== NOT EXECUTED
4baa0: 266e 0010 moveal %fp@(16),%a3 <== NOT EXECUTED
double result;
char *end;
if ( !n )
4baa4: 4a8a tstl %a2 <== NOT EXECUTED
4baa6: 6700 009c beqw 4bb44 <rtems_string_to_double+0xb4> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
errno = 0;
4baaa: 4eb9 0004 db30 jsr 4db30 <__errno> <== NOT EXECUTED
*n = 0;
4bab0: 4281 clrl %d1 <== NOT EXECUTED
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bab2: 2040 moveal %d0,%a0 <== NOT EXECUTED
*n = 0;
4bab4: 4280 clrl %d0 <== NOT EXECUTED
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bab6: 4290 clrl %a0@ <== NOT EXECUTED
*n = 0;
4bab8: 2480 movel %d0,%a2@ <== NOT EXECUTED
4baba: 2541 0004 movel %d1,%a2@(4) <== NOT EXECUTED
result = strtod( s, &end );
4babe: 486e fffc pea %fp@(-4) <== NOT EXECUTED
4bac2: 2f04 movel %d4,%sp@- <== NOT EXECUTED
4bac4: 4eb9 0005 06d4 jsr 506d4 <strtod> <== NOT EXECUTED
if ( endptr )
4baca: 508f addql #8,%sp <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
4bacc: 2400 movel %d0,%d2 <== NOT EXECUTED
4bace: 2601 movel %d1,%d3 <== NOT EXECUTED
if ( endptr )
4bad0: 4a8b tstl %a3 <== NOT EXECUTED
4bad2: 6704 beqs 4bad8 <rtems_string_to_double+0x48> <== NOT EXECUTED
*endptr = end;
4bad4: 26ae fffc movel %fp@(-4),%a3@ <== NOT EXECUTED
if ( end == s )
4bad8: b8ae fffc cmpl %fp@(-4),%d4 <== NOT EXECUTED
4badc: 676a beqs 4bb48 <rtems_string_to_double+0xb8> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bade: 4eb9 0004 db30 jsr 4db30 <__errno> <== NOT EXECUTED
4bae4: 7222 moveq #34,%d1 <== NOT EXECUTED
4bae6: 2040 moveal %d0,%a0 <== NOT EXECUTED
4bae8: b290 cmpl %a0@,%d1 <== NOT EXECUTED
4baea: 664e bnes 4bb3a <rtems_string_to_double+0xaa> <== NOT EXECUTED
4baec: 42a7 clrl %sp@- <== NOT EXECUTED
4baee: 42a7 clrl %sp@- <== NOT EXECUTED
4baf0: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4baf2: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4baf4: 4eb9 0004 26e4 jsr 426e4 <__eqdf2> <== NOT EXECUTED
4bafa: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4bafe: 4a80 tstl %d0 <== NOT EXECUTED
4bb00: 674a beqs 4bb4c <rtems_string_to_double+0xbc> <== NOT EXECUTED
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4bb02: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
4bb06: 2f3c 7fef ffff movel #2146435071,%sp@- <== NOT EXECUTED
4bb0c: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4bb0e: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4bb10: 4eb9 0005 c064 jsr 5c064 <__gtdf2> <== NOT EXECUTED
4bb16: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4bb1a: 4a80 tstl %d0 <== NOT EXECUTED
4bb1c: 6e2e bgts 4bb4c <rtems_string_to_double+0xbc> <== NOT EXECUTED
4bb1e: 4878 ffff pea ffffffff <LESS> <== NOT EXECUTED
4bb22: 2f3c ffef ffff movel #-1048577,%sp@- <== NOT EXECUTED
4bb28: 2f03 movel %d3,%sp@- <== NOT EXECUTED
4bb2a: 2f02 movel %d2,%sp@- <== NOT EXECUTED
4bb2c: 4eb9 0005 c0ac jsr 5c0ac <__ltdf2> <== NOT EXECUTED
4bb32: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED
4bb36: 4a80 tstl %d0 <== NOT EXECUTED
4bb38: 6d12 blts 4bb4c <rtems_string_to_double+0xbc> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
4bb3a: 2482 movel %d2,%a2@ <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4bb3c: 4280 clrl %d0 <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
4bb3e: 2543 0004 movel %d3,%a2@(4) <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4bb42: 600a bras 4bb4e <rtems_string_to_double+0xbe> <== NOT EXECUTED
{
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bb44: 7009 moveq #9,%d0 <== NOT EXECUTED
4bb46: 6006 bras 4bb4e <rtems_string_to_double+0xbe> <== NOT EXECUTED
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bb48: 700b moveq #11,%d0 <== NOT EXECUTED
4bb4a: 6002 bras 4bb4e <rtems_string_to_double+0xbe> <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
4bb4c: 700a moveq #10,%d0 <== NOT EXECUTED
*n = result;
return RTEMS_SUCCESSFUL;
}
4bb4e: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3 <== NOT EXECUTED
4bb54: 4e5e unlk %fp <== NOT EXECUTED
0004bb58 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
4bb58: 4e56 ffec linkw %fp,#-20
4bb5c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bb60: 262e 0008 movel %fp@(8),%d3
4bb64: 246e 000c moveal %fp@(12),%a2
4bb68: 266e 0010 moveal %fp@(16),%a3
float result;
char *end;
if ( !n )
4bb6c: 4a8a tstl %a2
4bb6e: 677e beqs 4bbee <rtems_string_to_float+0x96>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bb70: 4eb9 0004 db30 jsr 4db30 <__errno>
4bb76: 2040 moveal %d0,%a0
4bb78: 4290 clrl %a0@
*n = 0;
4bb7a: 24bc 0000 0000 movel #0,%a2@
result = strtof( s, &end );
4bb80: 486e fffc pea %fp@(-4)
4bb84: 2f03 movel %d3,%sp@-
4bb86: 4eb9 0005 06f4 jsr 506f4 <strtof>
if ( endptr )
4bb8c: 508f addql #8,%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
4bb8e: 2400 movel %d0,%d2
if ( endptr )
4bb90: 4a8b tstl %a3
4bb92: 6704 beqs 4bb98 <rtems_string_to_float+0x40>
*endptr = end;
4bb94: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bb98: b6ae fffc cmpl %fp@(-4),%d3
4bb9c: 6754 beqs 4bbf2 <rtems_string_to_float+0x9a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bb9e: 4eb9 0004 db30 jsr 4db30 <__errno>
4bba4: 7222 moveq #34,%d1
4bba6: 2040 moveal %d0,%a0
4bba8: b290 cmpl %a0@,%d1
4bbaa: 663c bnes 4bbe8 <rtems_string_to_float+0x90>
4bbac: 2f3c 0000 0000 movel #0,%sp@-
4bbb2: 2f02 movel %d2,%sp@-
4bbb4: 4eb9 0004 2708 jsr 42708 <__eqsf2>
4bbba: 508f addql #8,%sp
4bbbc: 4a80 tstl %d0
4bbbe: 6736 beqs 4bbf6 <rtems_string_to_float+0x9e> <== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4bbc0: 2f3c 7f7f ffff movel #2139095039,%sp@-
4bbc6: 2f02 movel %d2,%sp@-
4bbc8: 4eb9 0005 c0f4 jsr 5c0f4 <__gtsf2>
4bbce: 508f addql #8,%sp
4bbd0: 4a80 tstl %d0
4bbd2: 6e22 bgts 4bbf6 <rtems_string_to_float+0x9e> <== NEVER TAKEN
4bbd4: 2f3c ff7f ffff movel #-8388609,%sp@-
4bbda: 2f02 movel %d2,%sp@-
4bbdc: 4eb9 0005 c110 jsr 5c110 <__ltsf2>
4bbe2: 508f addql #8,%sp
4bbe4: 4a80 tstl %d0
4bbe6: 6d0e blts 4bbf6 <rtems_string_to_float+0x9e> <== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
4bbe8: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bbea: 4280 clrl %d0
4bbec: 600a bras 4bbf8 <rtems_string_to_float+0xa0>
{
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bbee: 7009 moveq #9,%d0
4bbf0: 6006 bras 4bbf8 <rtems_string_to_float+0xa0>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bbf2: 700b moveq #11,%d0
4bbf4: 6002 bras 4bbf8 <rtems_string_to_float+0xa0>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
4bbf6: 700a moveq #10,%d0 <== NOT EXECUTED
*n = result;
return RTEMS_SUCCESSFUL;
}
4bbf8: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bbfe: 4e5e unlk %fp
...
0004bc04 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
4bc04: 4e56 ffec linkw %fp,#-20
4bc08: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bc0c: 262e 0008 movel %fp@(8),%d3
4bc10: 246e 000c moveal %fp@(12),%a2
4bc14: 266e 0010 moveal %fp@(16),%a3
long result;
char *end;
if ( !n )
4bc18: 4a8a tstl %a2
4bc1a: 6758 beqs 4bc74 <rtems_string_to_int+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bc1c: 4eb9 0004 db30 jsr 4db30 <__errno>
4bc22: 2040 moveal %d0,%a0
4bc24: 4290 clrl %a0@
*n = 0;
4bc26: 4292 clrl %a2@
result = strtol( s, &end, base );
4bc28: 2f2e 0014 movel %fp@(20),%sp@-
4bc2c: 486e fffc pea %fp@(-4)
4bc30: 2f03 movel %d3,%sp@-
4bc32: 4eb9 0005 08c4 jsr 508c4 <strtol>
if ( endptr )
4bc38: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4bc3c: 2400 movel %d0,%d2
if ( endptr )
4bc3e: 4a8b tstl %a3
4bc40: 6704 beqs 4bc46 <rtems_string_to_int+0x42>
*endptr = end;
4bc42: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bc46: b6ae fffc cmpl %fp@(-4),%d3
4bc4a: 672c beqs 4bc78 <rtems_string_to_int+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bc4c: 4eb9 0004 db30 jsr 4db30 <__errno>
4bc52: 7222 moveq #34,%d1
4bc54: 2040 moveal %d0,%a0
4bc56: b290 cmpl %a0@,%d1
4bc58: 6614 bnes 4bc6e <rtems_string_to_int+0x6a>
4bc5a: 4a82 tstl %d2
4bc5c: 671e beqs 4bc7c <rtems_string_to_int+0x78> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4bc5e: 0c82 7fff ffff cmpil #2147483647,%d2
4bc64: 6716 beqs 4bc7c <rtems_string_to_int+0x78>
4bc66: 0c82 8000 0000 cmpil #-2147483648,%d2
4bc6c: 670e beqs 4bc7c <rtems_string_to_int+0x78> <== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4bc6e: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bc70: 4280 clrl %d0
4bc72: 600a bras 4bc7e <rtems_string_to_int+0x7a>
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bc74: 7009 moveq #9,%d0
4bc76: 6006 bras 4bc7e <rtems_string_to_int+0x7a>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bc78: 700b moveq #11,%d0
4bc7a: 6002 bras 4bc7e <rtems_string_to_int+0x7a>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4bc7c: 700a moveq #10,%d0
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4bc7e: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bc84: 4e5e unlk %fp <== NOT EXECUTED
0004bd28 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
4bd28: 4e56 ffec linkw %fp,#-20
4bd2c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bd30: 262e 0008 movel %fp@(8),%d3
4bd34: 246e 000c moveal %fp@(12),%a2
4bd38: 266e 0010 moveal %fp@(16),%a3
long result;
char *end;
if ( !n )
4bd3c: 4a8a tstl %a2
4bd3e: 6758 beqs 4bd98 <rtems_string_to_long+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bd40: 4eb9 0004 db30 jsr 4db30 <__errno>
4bd46: 2040 moveal %d0,%a0
4bd48: 4290 clrl %a0@
*n = 0;
4bd4a: 4292 clrl %a2@
result = strtol( s, &end, base );
4bd4c: 2f2e 0014 movel %fp@(20),%sp@-
4bd50: 486e fffc pea %fp@(-4)
4bd54: 2f03 movel %d3,%sp@-
4bd56: 4eb9 0005 08c4 jsr 508c4 <strtol>
if ( endptr )
4bd5c: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
4bd60: 2400 movel %d0,%d2
if ( endptr )
4bd62: 4a8b tstl %a3
4bd64: 6704 beqs 4bd6a <rtems_string_to_long+0x42>
*endptr = end;
4bd66: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bd6a: b6ae fffc cmpl %fp@(-4),%d3
4bd6e: 672c beqs 4bd9c <rtems_string_to_long+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bd70: 4eb9 0004 db30 jsr 4db30 <__errno>
4bd76: 7222 moveq #34,%d1
4bd78: 2040 moveal %d0,%a0
4bd7a: b290 cmpl %a0@,%d1
4bd7c: 6614 bnes 4bd92 <rtems_string_to_long+0x6a>
4bd7e: 4a82 tstl %d2
4bd80: 671e beqs 4bda0 <rtems_string_to_long+0x78> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4bd82: 0c82 7fff ffff cmpil #2147483647,%d2
4bd88: 6716 beqs 4bda0 <rtems_string_to_long+0x78>
4bd8a: 0c82 8000 0000 cmpil #-2147483648,%d2
4bd90: 670e beqs 4bda0 <rtems_string_to_long+0x78> <== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
4bd92: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bd94: 4280 clrl %d0
4bd96: 600a bras 4bda2 <rtems_string_to_long+0x7a>
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bd98: 7009 moveq #9,%d0
4bd9a: 6006 bras 4bda2 <rtems_string_to_long+0x7a>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bd9c: 700b moveq #11,%d0
4bd9e: 6002 bras 4bda2 <rtems_string_to_long+0x7a>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4bda0: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4bda2: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bda8: 4e5e unlk %fp <== NOT EXECUTED
0004bc88 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
4bc88: 4e56 ffe8 linkw %fp,#-24
4bc8c: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
4bc90: 282e 0008 movel %fp@(8),%d4
4bc94: 246e 000c moveal %fp@(12),%a2
4bc98: 266e 0010 moveal %fp@(16),%a3
long long result;
char *end;
if ( !n )
4bc9c: 4a8a tstl %a2
4bc9e: 6774 beqs 4bd14 <rtems_string_to_long_long+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bca0: 4eb9 0004 db30 jsr 4db30 <__errno>
4bca6: 2040 moveal %d0,%a0
*n = 0;
4bca8: 4280 clrl %d0
4bcaa: 4281 clrl %d1
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bcac: 4290 clrl %a0@
*n = 0;
4bcae: 2480 movel %d0,%a2@
4bcb0: 2541 0004 movel %d1,%a2@(4)
result = strtoll( s, &end, base );
4bcb4: 2f2e 0014 movel %fp@(20),%sp@-
4bcb8: 486e fffc pea %fp@(-4)
4bcbc: 2f04 movel %d4,%sp@-
4bcbe: 4eb9 0005 08e4 jsr 508e4 <strtoll>
if ( endptr )
4bcc4: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
4bcc8: 2400 movel %d0,%d2
4bcca: 2601 movel %d1,%d3
if ( endptr )
4bccc: 4a8b tstl %a3
4bcce: 6704 beqs 4bcd4 <rtems_string_to_long_long+0x4c>
*endptr = end;
4bcd0: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bcd4: b8ae fffc cmpl %fp@(-4),%d4
4bcd8: 673e beqs 4bd18 <rtems_string_to_long_long+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bcda: 4eb9 0004 db30 jsr 4db30 <__errno>
4bce0: 7222 moveq #34,%d1
4bce2: 2040 moveal %d0,%a0
4bce4: b290 cmpl %a0@,%d1
4bce6: 6622 bnes 4bd0a <rtems_string_to_long_long+0x82>
4bce8: 2002 movel %d2,%d0
4bcea: 8083 orl %d3,%d0
4bcec: 672e beqs 4bd1c <rtems_string_to_long_long+0x94> <== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4bcee: 203c 7fff ffff movel #2147483647,%d0
4bcf4: 72ff moveq #-1,%d1
4bcf6: 9283 subl %d3,%d1
4bcf8: 9182 subxl %d2,%d0
4bcfa: 6720 beqs 4bd1c <rtems_string_to_long_long+0x94>
4bcfc: 203c 8000 0000 movel #-2147483648,%d0
4bd02: 4281 clrl %d1
4bd04: 9283 subl %d3,%d1
4bd06: 9182 subxl %d2,%d0
4bd08: 6712 beqs 4bd1c <rtems_string_to_long_long+0x94> <== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
4bd0a: 4280 clrl %d0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4bd0c: 2482 movel %d2,%a2@
4bd0e: 2543 0004 movel %d3,%a2@(4)
return RTEMS_SUCCESSFUL;
4bd12: 600a bras 4bd1e <rtems_string_to_long_long+0x96>
{
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bd14: 7009 moveq #9,%d0
4bd16: 6006 bras 4bd1e <rtems_string_to_long_long+0x96>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bd18: 700b moveq #11,%d0
4bd1a: 6002 bras 4bd1e <rtems_string_to_long_long+0x96>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4bd1c: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4bd1e: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3
4bd24: 4e5e unlk %fp <== NOT EXECUTED
0004bdc8 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
4bdc8: 4e56 ffec linkw %fp,#-20
4bdcc: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bdd0: 262e 0008 movel %fp@(8),%d3
4bdd4: 246e 000c moveal %fp@(12),%a2
4bdd8: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4bddc: 4a8a tstl %a2
4bdde: 6764 beqs 4be44 <rtems_string_to_unsigned_char+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bde0: 4eb9 0004 db30 jsr 4db30 <__errno>
4bde6: 2040 moveal %d0,%a0
4bde8: 4290 clrl %a0@
*n = 0;
4bdea: 4212 clrb %a2@
result = strtoul( s, &end, base );
4bdec: 2f2e 0014 movel %fp@(20),%sp@-
4bdf0: 486e fffc pea %fp@(-4)
4bdf4: 2f03 movel %d3,%sp@-
4bdf6: 4eb9 0005 0d22 jsr 50d22 <strtoul>
if ( endptr )
4bdfc: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4be00: 2400 movel %d0,%d2
if ( endptr )
4be02: 4a8b tstl %a3
4be04: 6704 beqs 4be0a <rtems_string_to_unsigned_char+0x42>
*endptr = end;
4be06: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4be0a: b6ae fffc cmpl %fp@(-4),%d3
4be0e: 6738 beqs 4be48 <rtems_string_to_unsigned_char+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4be10: 4eb9 0004 db30 jsr 4db30 <__errno>
4be16: 7222 moveq #34,%d1
4be18: 2040 moveal %d0,%a0
4be1a: b290 cmpl %a0@,%d1
4be1c: 660a bnes 4be28 <rtems_string_to_unsigned_char+0x60>
(( result == 0 ) || ( result == ULONG_MAX )))
4be1e: 2002 movel %d2,%d0
4be20: 5380 subql #1,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4be22: 72fd moveq #-3,%d1
4be24: b280 cmpl %d0,%d1
4be26: 6524 bcss 4be4c <rtems_string_to_unsigned_char+0x84><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
4be28: 0c82 0000 00ff cmpil #255,%d2
4be2e: 630e blss 4be3e <rtems_string_to_unsigned_char+0x76>
errno = ERANGE;
4be30: 4eb9 0004 db30 jsr 4db30 <__errno>
4be36: 2040 moveal %d0,%a0
4be38: 7022 moveq #34,%d0
4be3a: 2080 movel %d0,%a0@
4be3c: 600e bras 4be4c <rtems_string_to_unsigned_char+0x84>
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
4be3e: 4280 clrl %d0
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4be40: 1482 moveb %d2,%a2@
return RTEMS_SUCCESSFUL;
4be42: 600a bras 4be4e <rtems_string_to_unsigned_char+0x86>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4be44: 7009 moveq #9,%d0
4be46: 6006 bras 4be4e <rtems_string_to_unsigned_char+0x86>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4be48: 700b moveq #11,%d0
4be4a: 6002 bras 4be4e <rtems_string_to_unsigned_char+0x86>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4be4c: 700a moveq #10,%d0
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4be4e: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4be54: 4e5e unlk %fp <== NOT EXECUTED
0004be58 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
4be58: 4e56 ffec linkw %fp,#-20
4be5c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4be60: 262e 0008 movel %fp@(8),%d3
4be64: 246e 000c moveal %fp@(12),%a2
4be68: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4be6c: 4a8a tstl %a2
4be6e: 674e beqs 4bebe <rtems_string_to_unsigned_int+0x66>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4be70: 4eb9 0004 db30 jsr 4db30 <__errno>
4be76: 2040 moveal %d0,%a0
4be78: 4290 clrl %a0@
*n = 0;
4be7a: 4292 clrl %a2@
result = strtoul( s, &end, base );
4be7c: 2f2e 0014 movel %fp@(20),%sp@-
4be80: 486e fffc pea %fp@(-4)
4be84: 2f03 movel %d3,%sp@-
4be86: 4eb9 0005 0d22 jsr 50d22 <strtoul>
if ( endptr )
4be8c: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4be90: 2400 movel %d0,%d2
if ( endptr )
4be92: 4a8b tstl %a3
4be94: 6704 beqs 4be9a <rtems_string_to_unsigned_int+0x42>
*endptr = end;
4be96: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4be9a: b6ae fffc cmpl %fp@(-4),%d3
4be9e: 6722 beqs 4bec2 <rtems_string_to_unsigned_int+0x6a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bea0: 4eb9 0004 db30 jsr 4db30 <__errno>
4bea6: 7222 moveq #34,%d1
4bea8: 2040 moveal %d0,%a0
4beaa: b290 cmpl %a0@,%d1
4beac: 660a bnes 4beb8 <rtems_string_to_unsigned_int+0x60>
(( result == 0 ) || ( result == ULONG_MAX )))
4beae: 2002 movel %d2,%d0
4beb0: 5380 subql #1,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4beb2: 72fd moveq #-3,%d1
4beb4: b280 cmpl %d0,%d1
4beb6: 650e bcss 4bec6 <rtems_string_to_unsigned_int+0x6e><== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4beb8: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4beba: 4280 clrl %d0
4bebc: 600a bras 4bec8 <rtems_string_to_unsigned_int+0x70>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bebe: 7009 moveq #9,%d0
4bec0: 6006 bras 4bec8 <rtems_string_to_unsigned_int+0x70>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bec2: 700b moveq #11,%d0
4bec4: 6002 bras 4bec8 <rtems_string_to_unsigned_int+0x70>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4bec6: 700a moveq #10,%d0
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
4bec8: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bece: 4e5e unlk %fp
...
0004bf64 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
4bf64: 4e56 ffec linkw %fp,#-20
4bf68: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
4bf6c: 262e 0008 movel %fp@(8),%d3
4bf70: 246e 000c moveal %fp@(12),%a2
4bf74: 266e 0010 moveal %fp@(16),%a3
unsigned long result;
char *end;
if ( !n )
4bf78: 4a8a tstl %a2
4bf7a: 674e beqs 4bfca <rtems_string_to_unsigned_long+0x66>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bf7c: 4eb9 0004 db30 jsr 4db30 <__errno>
4bf82: 2040 moveal %d0,%a0
4bf84: 4290 clrl %a0@
*n = 0;
4bf86: 4292 clrl %a2@
result = strtoul( s, &end, base );
4bf88: 2f2e 0014 movel %fp@(20),%sp@-
4bf8c: 486e fffc pea %fp@(-4)
4bf90: 2f03 movel %d3,%sp@-
4bf92: 4eb9 0005 0d22 jsr 50d22 <strtoul>
if ( endptr )
4bf98: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
4bf9c: 2400 movel %d0,%d2
if ( endptr )
4bf9e: 4a8b tstl %a3
4bfa0: 6704 beqs 4bfa6 <rtems_string_to_unsigned_long+0x42>
*endptr = end;
4bfa2: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bfa6: b6ae fffc cmpl %fp@(-4),%d3
4bfaa: 6722 beqs 4bfce <rtems_string_to_unsigned_long+0x6a>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bfac: 4eb9 0004 db30 jsr 4db30 <__errno>
4bfb2: 7222 moveq #34,%d1
4bfb4: 2040 moveal %d0,%a0
4bfb6: b290 cmpl %a0@,%d1
4bfb8: 660a bnes 4bfc4 <rtems_string_to_unsigned_long+0x60>
(( result == 0 ) || ( result == ULONG_MAX )))
4bfba: 2002 movel %d2,%d0
4bfbc: 5380 subql #1,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bfbe: 72fd moveq #-3,%d1
4bfc0: b280 cmpl %d0,%d1
4bfc2: 650e bcss 4bfd2 <rtems_string_to_unsigned_long+0x6e><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4bfc4: 2482 movel %d2,%a2@
return RTEMS_SUCCESSFUL;
4bfc6: 4280 clrl %d0
4bfc8: 600a bras 4bfd4 <rtems_string_to_unsigned_long+0x70>
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bfca: 7009 moveq #9,%d0
4bfcc: 6006 bras 4bfd4 <rtems_string_to_unsigned_long+0x70>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bfce: 700b moveq #11,%d0
4bfd0: 6002 bras 4bfd4 <rtems_string_to_unsigned_long+0x70>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
4bfd2: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4bfd4: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4bfda: 4e5e unlk %fp
...
0004bed4 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
4bed4: 4e56 ffe4 linkw %fp,#-28
4bed8: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
4bedc: 282e 0008 movel %fp@(8),%d4
4bee0: 246e 000c moveal %fp@(12),%a2
4bee4: 266e 0010 moveal %fp@(16),%a3
unsigned long long result;
char *end;
if ( !n )
4bee8: 4a8a tstl %a2
4beea: 6764 beqs 4bf50 <rtems_string_to_unsigned_long_long+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
4beec: 4eb9 0004 db30 jsr 4db30 <__errno>
4bef2: 2040 moveal %d0,%a0
*n = 0;
4bef4: 4280 clrl %d0
4bef6: 4281 clrl %d1
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
4bef8: 4290 clrl %a0@
*n = 0;
4befa: 2480 movel %d0,%a2@
4befc: 2541 0004 movel %d1,%a2@(4)
result = strtoull( s, &end, base );
4bf00: 2f2e 0014 movel %fp@(20),%sp@-
4bf04: 486e fffc pea %fp@(-4)
4bf08: 2f04 movel %d4,%sp@-
4bf0a: 4eb9 0005 0d44 jsr 50d44 <strtoull>
if ( endptr )
4bf10: 4fef 000c lea %sp@(12),%sp
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
4bf14: 2400 movel %d0,%d2
4bf16: 2601 movel %d1,%d3
if ( endptr )
4bf18: 4a8b tstl %a3
4bf1a: 6704 beqs 4bf20 <rtems_string_to_unsigned_long_long+0x4c>
*endptr = end;
4bf1c: 26ae fffc movel %fp@(-4),%a3@
if ( end == s )
4bf20: b8ae fffc cmpl %fp@(-4),%d4
4bf24: 672e beqs 4bf54 <rtems_string_to_unsigned_long_long+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bf26: 4eb9 0004 db30 jsr 4db30 <__errno>
4bf2c: 7222 moveq #34,%d1
4bf2e: 2040 moveal %d0,%a0
4bf30: b290 cmpl %a0@,%d1
4bf32: 6612 bnes 4bf46 <rtems_string_to_unsigned_long_long+0x72>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4bf34: 70ff moveq #-1,%d0
4bf36: 72ff moveq #-1,%d1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bf38: 78ff moveq #-1,%d4
4bf3a: 7afd moveq #-3,%d5
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4bf3c: d283 addl %d3,%d1
4bf3e: d182 addxl %d2,%d0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4bf40: 9a81 subl %d1,%d5
4bf42: 9980 subxl %d0,%d4
4bf44: 6512 bcss 4bf58 <rtems_string_to_unsigned_long_long+0x84><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
4bf46: 4280 clrl %d0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4bf48: 2482 movel %d2,%a2@
4bf4a: 2543 0004 movel %d3,%a2@(4)
return RTEMS_SUCCESSFUL;
4bf4e: 600a bras 4bf5a <rtems_string_to_unsigned_long_long+0x86>
{
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
4bf50: 7009 moveq #9,%d0
4bf52: 6006 bras 4bf5a <rtems_string_to_unsigned_long_long+0x86>
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
4bf54: 700b moveq #11,%d0
4bf56: 6002 bras 4bf5a <rtems_string_to_unsigned_long_long+0x86>
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
4bf58: 700a moveq #10,%d0
*n = result;
return RTEMS_SUCCESSFUL;
}
4bf5a: 4cee 0c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a3
4bf60: 4e5e unlk %fp <== NOT EXECUTED
00042500 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
42500: 4e56 fe40 linkw %fp,#-448
42504: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
42508: 2e2e 0008 movel %fp@(8),%d7
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
4250c: 2f07 movel %d7,%sp@-
4250e: 4eb9 0004 ff9c jsr 4ff9c <strlen>
42514: 4297 clrl %sp@
42516: 486e ffd4 pea %fp@(-44)
4251a: 42a7 clrl %sp@-
4251c: 2f00 movel %d0,%sp@-
4251e: 2f07 movel %d7,%sp@-
42520: 4eb9 0004 2f74 jsr 42f74 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
42526: 4fef 0014 lea %sp@(20),%sp
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
4252a: 2800 movel %d0,%d4
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
4252c: 6600 01a4 bnew 426d2 <rtems_tarfs_load+0x1d2>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
42530: 202e ffe0 movel %fp@(-32),%d0
42534: 0c80 0005 f8d2 cmpil #391378,%d0
4253a: 6710 beqs 4254c <rtems_tarfs_load+0x4c>
4253c: 0c80 0006 0122 cmpil #393506,%d0
42542: 6708 beqs 4254c <rtems_tarfs_load+0x4c> <== NEVER TAKEN
42544: 6000 018c braw 426d2 <rtems_tarfs_load+0x1d2>
42548: 2443 moveal %d3,%a2
4254a: 6026 bras 42572 <rtems_tarfs_load+0x72>
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
4254c: 2c0e movel %fp,%d6
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
4254e: 2a0e movel %fp,%d5
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
42550: 240e movel %fp,%d2
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
42552: 95ca subal %a2,%a2
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
42554: 0686 ffff ff70 addil #-144,%d6
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
4255a: 0685 ffff ffe8 addil #-24,%d5
42560: 4bee ffd4 lea %fp@(-44),%a5
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
42564: 0682 ffff fe70 addil #-400,%d2
4256a: 2d44 fe6c movel %d4,%fp@(-404)
4256e: 2d47 fe68 movel %d7,%fp@(-408)
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
42572: 260a movel %a2,%d3
42574: 0683 0000 0200 addil #512,%d3
4257a: b6ae 0010 cmpl %fp@(16),%d3
4257e: 6200 0156 bhiw 426d6 <rtems_tarfs_load+0x1d6>
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
42582: 4878 0005 pea 5 <COMPARE>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
42586: d5ee 000c addal %fp@(12),%a2
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
4258a: 4879 0005 f91a pea 5f91a <IMFS_ops+0x48>
42590: 486a 0101 pea %a2@(257)
42594: 4eb9 0004 ffb8 jsr 4ffb8 <strncmp>
4259a: 4fef 000c lea %sp@(12),%sp
4259e: 4a80 tstl %d0
425a0: 6600 0134 bnew 426d6 <rtems_tarfs_load+0x1d6>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
425a4: 4878 0063 pea 63 <DBL_MANT_DIG+0x2e>
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425a8: 47f9 0004 9538 lea 49538 <_rtems_octal2ulong>,%a3
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
425ae: 2f0a movel %a2,%sp@-
425b0: 2f06 movel %d6,%sp@-
425b2: 4eb9 0005 0094 jsr 50094 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
425b8: 1e2a 009c moveb %a2@(156),%d7
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425bc: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
425c0: 486a 0064 pea %a2@(100)
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
425c4: 4200 clrb %d0
425c6: 1d40 ffd3 moveb %d0,%fp@(-45)
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425ca: 4e93 jsr %a3@
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
425cc: 4878 000c pea c <OPER1>
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
425d0: 2800 movel %d0,%d4
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
425d2: 486a 007c pea %a2@(124)
425d6: 4e93 jsr %a3@
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
425d8: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
425dc: 2840 moveal %d0,%a4
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
425de: 486a 0094 pea %a2@(148)
425e2: 4e93 jsr %a3@
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
425e4: 4fef 0020 lea %sp@(32),%sp
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
425e8: 2640 moveal %d0,%a3
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
425ea: 2e8a movel %a2,%sp@
425ec: 4eb9 0004 957e jsr 4957e <_rtems_tar_header_checksum>
425f2: 588f addql #4,%sp
425f4: b7c0 cmpal %d0,%a3
425f6: 6600 00de bnew 426d6 <rtems_tarfs_load+0x1d6>
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
425fa: 7235 moveq #53,%d1
425fc: 0287 0000 00ff andil #255,%d7
42602: b287 cmpl %d7,%d1
42604: 6656 bnes 4265c <rtems_tarfs_load+0x15c>
strcpy(full_filename, mountpoint);
42606: 2f2e fe68 movel %fp@(-408),%sp@-
4260a: 2f02 movel %d2,%sp@-
4260c: 4eb9 0004 fa94 jsr 4fa94 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
42612: 2f02 movel %d2,%sp@-
42614: 4eb9 0004 ff9c jsr 4ff9c <strlen>
4261a: 4fef 000c lea %sp@(12),%sp
4261e: 722f moveq #47,%d1
42620: 41f6 0800 lea %fp@(00000000,%d0:l),%a0
42624: 1028 fe6f moveb %a0@(-401),%d0
42628: 49c0 extbl %d0
4262a: b280 cmpl %d0,%d1
4262c: 6710 beqs 4263e <rtems_tarfs_load+0x13e> <== ALWAYS TAKEN
strcat(full_filename, "/");
4262e: 4879 0005 c7a9 pea 5c7a9 <_rodata_start+0x19> <== NOT EXECUTED
42634: 2f02 movel %d2,%sp@- <== NOT EXECUTED
42636: 4eb9 0004 f974 jsr 4f974 <strcat> <== NOT EXECUTED
4263c: 508f addql #8,%sp <== NOT EXECUTED
strcat(full_filename, filename);
4263e: 2f06 movel %d6,%sp@-
42640: 2f02 movel %d2,%sp@-
42642: 4eb9 0004 f974 jsr 4f974 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
42648: 4878 01ff pea 1ff <DBL_MANT_DIG+0x1ca>
4264c: 2f02 movel %d2,%sp@-
4264e: 4eb9 0004 3720 jsr 43720 <mkdir>
42654: 4fef 0010 lea %sp@(16),%sp
42658: 6000 feee braw 42548 <rtems_tarfs_load+0x48>
* IMFS_create_node was ONLY passed a NULL when we created the
* root node. We added a new IMFS_create_root_node() so this
* path no longer existed. The result was simpler code which
* should not have this path.
*/
else if (linkflag == REGTYPE) {
4265c: 7030 moveq #48,%d0
4265e: b087 cmpl %d7,%d0
42660: 6600 fee6 bnew 42548 <rtems_tarfs_load+0x48>
const char *name;
loc = root_loc;
42664: 4878 0014 pea 14 <OPER2>
42668: 2f0d movel %a5,%sp@-
4266a: 2f05 movel %d5,%sp@-
4266c: 4eb9 0004 eec0 jsr 4eec0 <memcpy>
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
42672: 486e fffc pea %fp@(-4)
42676: 2f05 movel %d5,%sp@-
42678: 2f06 movel %d6,%sp@-
4267a: 4eb9 0004 a0dc jsr 4a0dc <IMFS_evaluate_for_make>
42680: 4fef 0018 lea %sp@(24),%sp
42684: 4a80 tstl %d0
42686: 6636 bnes 426be <rtems_tarfs_load+0x1be> <== NEVER TAKEN
node = IMFS_create_node(
42688: 42a7 clrl %sp@-
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
4268a: 0284 0000 01ff andil #511,%d4
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
42690: 08c4 000f bset #15,%d4
42694: 2f04 movel %d4,%sp@-
42696: 2f2e fffc movel %fp@(-4),%sp@-
4269a: 4878 0006 pea 6 <EXTENDSFDF>
4269e: 2f05 movel %d5,%sp@-
426a0: 4eb9 0004 9abc jsr 49abc <IMFS_create_node>
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
426a6: 222e 000c movel %fp@(12),%d1
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
426aa: 2040 moveal %d0,%a0
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
426ac: d283 addl %d3,%d1
426ae: 4fef 0014 lea %sp@(20),%sp
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
426b2: 214c 0050 movel %a4,%a0@(80)
426b6: 42a8 004c clrl %a0@(76)
node->info.linearfile.direct = &tar_image[offset];
426ba: 2141 0054 movel %d1,%a0@(84)
}
nblocks = (((file_size) + 511) & ~511) / 512;
426be: 200c movel %a4,%d0
426c0: 0680 0000 01ff addil #511,%d0
offset += 512 * nblocks;
426c6: 0280 ffff fe00 andil #-512,%d0
426cc: d680 addl %d0,%d3
426ce: 6000 fe78 braw 42548 <rtems_tarfs_load+0x48>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
426d2: 78ff moveq #-1,%d4
426d4: 6004 bras 426da <rtems_tarfs_load+0x1da>
426d6: 282e fe6c movel %fp@(-404),%d4
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
426da: 2004 movel %d4,%d0
426dc: 4cee 3cfc fe40 moveml %fp@(-448),%d2-%d7/%a2-%a5
426e2: 4e5e unlk %fp
...
0004bc34 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4bc34: 4e56 ffe4 linkw %fp,#-28
4bc38: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@
4bc3c: 262e 0008 movel %fp@(8),%d3
4bc40: 282e 000c movel %fp@(12),%d4
4bc44: 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 )
4bc48: 4a8c tstl %a4
4bc4a: 6700 0104 beqw 4bd50 <rtems_task_mode+0x11c>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
4bc4e: 2679 0005 d9bc moveal 5d9bc <_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;
4bc54: 4a2b 0074 tstb %a3@(116)
4bc58: 57c2 seq %d2
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4bc5a: 246b 00fc moveal %a3@(252),%a2
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4bc5e: 49c2 extbl %d2
4bc60: 0282 0000 0100 andil #256,%d2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4bc66: 4aab 007a tstl %a3@(122)
4bc6a: 6704 beqs 4bc70 <rtems_task_mode+0x3c>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
4bc6c: 08c2 0009 bset #9,%d2
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4bc70: 4a2a 0008 tstb %a2@(8)
4bc74: 57c5 seq %d5
old_mode |= _ISR_Get_level();
4bc76: 4eb9 0004 8c48 jsr 48c48 <_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;
4bc7c: 49c5 extbl %d5
4bc7e: 0285 0000 0400 andil #1024,%d5
4bc84: 8085 orl %d5,%d0
old_mode |= _ISR_Get_level();
4bc86: 8082 orl %d2,%d0
4bc88: 2880 movel %d0,%a4@
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
4bc8a: 0804 0008 btst #8,%d4
4bc8e: 670c beqs 4bc9c <rtems_task_mode+0x68>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
4bc90: 0803 0008 btst #8,%d3
4bc94: 57c0 seq %d0
4bc96: 4480 negl %d0
4bc98: 1740 0074 moveb %d0,%a3@(116)
if ( mask & RTEMS_TIMESLICE_MASK ) {
4bc9c: 0804 0009 btst #9,%d4
4bca0: 671c beqs 4bcbe <rtems_task_mode+0x8a>
if ( _Modes_Is_timeslice(mode_set) ) {
4bca2: 0803 0009 btst #9,%d3
4bca6: 6712 beqs 4bcba <rtems_task_mode+0x86>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4bca8: 41f9 0005 d7e0 lea 5d7e0 <_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;
4bcae: 7001 moveq #1,%d0
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4bcb0: 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;
4bcb4: 2740 007a movel %d0,%a3@(122)
4bcb8: 6004 bras 4bcbe <rtems_task_mode+0x8a>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4bcba: 42ab 007a clrl %a3@(122)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
4bcbe: 7007 moveq #7,%d0
4bcc0: c084 andl %d4,%d0
4bcc2: 6712 beqs 4bcd6 <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 ) );
4bcc4: 40c0 movew %sr,%d0
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
4bcc6: 7207 moveq #7,%d1
4bcc8: 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 ) );
4bcca: 0280 0000 f8ff andil #63743,%d0
4bcd0: e189 lsll #8,%d1
4bcd2: 8081 orl %d1,%d0
4bcd4: 46c0 movew %d0,%sr
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
4bcd6: 0804 000a btst #10,%d4
4bcda: 6740 beqs 4bd1c <rtems_task_mode+0xe8>
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4bcdc: 4281 clrl %d1
4bcde: 122a 0008 moveb %a2@(8),%d1
4bce2: 4282 clrl %d2
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
4bce4: 0803 000a btst #10,%d3
4bce8: 57c0 seq %d0
4bcea: 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 ) {
4bcec: 1400 moveb %d0,%d2
4bcee: b282 cmpl %d2,%d1
4bcf0: 672a beqs 4bd1c <rtems_task_mode+0xe8>
asr->is_enabled = is_asr_enabled;
4bcf2: 1540 0008 moveb %d0,%a2@(8)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
4bcf6: 203c 0000 0700 movel #1792,%d0
4bcfc: 40c1 movew %sr,%d1
4bcfe: 8081 orl %d1,%d0
4bd00: 46c0 movew %d0,%sr
_signals = information->signals_pending;
4bd02: 202a 0016 movel %a2@(22),%d0
information->signals_pending = information->signals_posted;
4bd06: 256a 0012 0016 movel %a2@(18),%a2@(22)
information->signals_posted = _signals;
4bd0c: 2540 0012 movel %d0,%a2@(18)
_ISR_Enable( _level );
4bd10: 46c1 movew %d1,%sr
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
4bd12: 4aaa 0012 tstl %a2@(18)
4bd16: 56c0 sne %d0
4bd18: 4480 negl %d0
4bd1a: 6002 bras 4bd1e <rtems_task_mode+0xea>
4bd1c: 4200 clrb %d0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
4bd1e: 7203 moveq #3,%d1
4bd20: b2b9 0005 d968 cmpl 5d968 <_System_state_Current>,%d1
4bd26: 662c bnes 4bd54 <rtems_task_mode+0x120>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
4bd28: 2079 0005 d9bc moveal 5d9bc <_Per_CPU_Information+0xc>,%a0
if ( are_signals_pending ||
4bd2e: 4a00 tstb %d0
4bd30: 660e bnes 4bd40 <rtems_task_mode+0x10c>
4bd32: b1f9 0005 d9c0 cmpal 5d9c0 <_Per_CPU_Information+0x10>,%a0
4bd38: 671a beqs 4bd54 <rtems_task_mode+0x120>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
4bd3a: 4a28 0074 tstb %a0@(116)
4bd3e: 6714 beqs 4bd54 <rtems_task_mode+0x120> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
4bd40: 7001 moveq #1,%d0
4bd42: 13c0 0005 d9c8 moveb %d0,5d9c8 <_Per_CPU_Information+0x18>
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
4bd48: 4eb9 0004 7b70 jsr 47b70 <_Thread_Dispatch>
4bd4e: 6004 bras 4bd54 <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;
4bd50: 7009 moveq #9,%d0
4bd52: 6002 bras 4bd56 <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;
4bd54: 4280 clrl %d0
}
4bd56: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4bd5c: 4e5e unlk %fp <== NOT EXECUTED
00049500 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
49500: 4e56 fffc linkw %fp,#-4
49504: 2f0a movel %a2,%sp@-
49506: 246e 0010 moveal %fp@(16),%a2
4950a: 2f02 movel %d2,%sp@-
4950c: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
49510: 670c beqs 4951e <rtems_task_set_priority+0x1e>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
49512: 4280 clrl %d0
49514: 1039 0005 f56a moveb 5f56a <rtems_maximum_priority>,%d0
4951a: b082 cmpl %d2,%d0
4951c: 654e bcss 4956c <rtems_task_set_priority+0x6c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4951e: 4a8a tstl %a2
49520: 674e beqs 49570 <rtems_task_set_priority+0x70>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
49522: 486e fffc pea %fp@(-4)
49526: 2f2e 0008 movel %fp@(8),%sp@-
4952a: 4eb9 0004 b5d4 jsr 4b5d4 <_Thread_Get>
switch ( location ) {
49530: 508f addql #8,%sp
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
49532: 2040 moveal %d0,%a0
switch ( location ) {
49534: 4aae fffc tstl %fp@(-4)
49538: 663a bnes 49574 <rtems_task_set_priority+0x74>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
4953a: 24a8 0014 movel %a0@(20),%a2@
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4953e: 4a82 tstl %d2
49540: 6720 beqs 49562 <rtems_task_set_priority+0x62>
the_thread->real_priority = new_priority;
49542: 2142 0018 movel %d2,%a0@(24)
if ( the_thread->resource_count == 0 ||
49546: 4aa8 001c tstl %a0@(28)
4954a: 6706 beqs 49552 <rtems_task_set_priority+0x52>
4954c: b4a8 0014 cmpl %a0@(20),%d2
49550: 6410 bccs 49562 <rtems_task_set_priority+0x62> <== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
49552: 42a7 clrl %sp@-
49554: 2f02 movel %d2,%sp@-
49556: 2f08 movel %a0,%sp@-
49558: 4eb9 0004 b15c jsr 4b15c <_Thread_Change_priority>
4955e: 4fef 000c lea %sp@(12),%sp
}
_Thread_Enable_dispatch();
49562: 4eb9 0004 b5ac jsr 4b5ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
49568: 4280 clrl %d0
4956a: 600a bras 49576 <rtems_task_set_priority+0x76>
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
4956c: 7013 moveq #19,%d0
4956e: 6006 bras 49576 <rtems_task_set_priority+0x76>
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
49570: 7009 moveq #9,%d0
49572: 6002 bras 49576 <rtems_task_set_priority+0x76>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
49574: 7004 moveq #4,%d0
}
49576: 242e fff4 movel %fp@(-12),%d2
4957a: 246e fff8 moveal %fp@(-8),%a2
4957e: 4e5e unlk %fp
...
00044ebc <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
44ebc: 7209 moveq #9,%d1
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
44ebe: 4e56 0000 linkw %fp,#0
44ec2: 202e 0008 movel %fp@(8),%d0
int baud_index;
switch (termios_baud) {
44ec6: b280 cmpl %d0,%d1
44ec8: 6700 00c4 beqw 44f8e <rtems_termios_baud_to_index+0xd2>
44ecc: 6d50 blts 44f1e <rtems_termios_baud_to_index+0x62>
44ece: 123c 0004 moveb #4,%d1
44ed2: b280 cmpl %d0,%d1
44ed4: 6700 00a4 beqw 44f7a <rtems_termios_baud_to_index+0xbe>
44ed8: 6d28 blts 44f02 <rtems_termios_baud_to_index+0x46>
44eda: 123c 0001 moveb #1,%d1
44ede: b280 cmpl %d0,%d1
44ee0: 6700 00dc beqw 44fbe <rtems_termios_baud_to_index+0x102>
44ee4: 6d0a blts 44ef0 <rtems_termios_baud_to_index+0x34>
44ee6: 4a80 tstl %d0
44ee8: 6700 0084 beqw 44f6e <rtems_termios_baud_to_index+0xb2>
44eec: 6000 00cc braw 44fba <rtems_termios_baud_to_index+0xfe>
44ef0: 7202 moveq #2,%d1
44ef2: b280 cmpl %d0,%d1
44ef4: 677c beqs 44f72 <rtems_termios_baud_to_index+0xb6>
44ef6: 123c 0003 moveb #3,%d1
44efa: b280 cmpl %d0,%d1
44efc: 6600 00bc bnew 44fba <rtems_termios_baud_to_index+0xfe>
44f00: 6074 bras 44f76 <rtems_termios_baud_to_index+0xba>
44f02: 7206 moveq #6,%d1
44f04: b280 cmpl %d0,%d1
44f06: 677a beqs 44f82 <rtems_termios_baud_to_index+0xc6>
44f08: 6e74 bgts 44f7e <rtems_termios_baud_to_index+0xc2>
44f0a: 123c 0007 moveb #7,%d1
44f0e: b280 cmpl %d0,%d1
44f10: 6774 beqs 44f86 <rtems_termios_baud_to_index+0xca>
44f12: 123c 0008 moveb #8,%d1
44f16: b280 cmpl %d0,%d1
44f18: 6600 00a0 bnew 44fba <rtems_termios_baud_to_index+0xfe>
44f1c: 606c bras 44f8a <rtems_termios_baud_to_index+0xce>
44f1e: 720e moveq #14,%d1
44f20: b280 cmpl %d0,%d1
44f22: 677e beqs 44fa2 <rtems_termios_baud_to_index+0xe6>
44f24: 6d1c blts 44f42 <rtems_termios_baud_to_index+0x86>
44f26: 123c 000b moveb #11,%d1
44f2a: b280 cmpl %d0,%d1
44f2c: 6768 beqs 44f96 <rtems_termios_baud_to_index+0xda>
44f2e: 6e62 bgts 44f92 <rtems_termios_baud_to_index+0xd6>
44f30: 123c 000c moveb #12,%d1
44f34: b280 cmpl %d0,%d1
44f36: 6762 beqs 44f9a <rtems_termios_baud_to_index+0xde>
44f38: 123c 000d moveb #13,%d1
44f3c: b280 cmpl %d0,%d1
44f3e: 667a bnes 44fba <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44f40: 605c bras 44f9e <rtems_termios_baud_to_index+0xe2>
44f42: 0c80 0000 1002 cmpil #4098,%d0
44f48: 6764 beqs 44fae <rtems_termios_baud_to_index+0xf2>
44f4a: 6e10 bgts 44f5c <rtems_termios_baud_to_index+0xa0>
44f4c: 720f moveq #15,%d1
44f4e: b280 cmpl %d0,%d1
44f50: 6754 beqs 44fa6 <rtems_termios_baud_to_index+0xea>
44f52: 0c80 0000 1001 cmpil #4097,%d0
44f58: 6660 bnes 44fba <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44f5a: 604e bras 44faa <rtems_termios_baud_to_index+0xee>
44f5c: 0c80 0000 1003 cmpil #4099,%d0
44f62: 674e beqs 44fb2 <rtems_termios_baud_to_index+0xf6>
44f64: 0c80 0000 1004 cmpil #4100,%d0
44f6a: 664e bnes 44fba <rtems_termios_baud_to_index+0xfe><== NEVER TAKEN
44f6c: 6048 bras 44fb6 <rtems_termios_baud_to_index+0xfa>
case B0: baud_index = 0; break;
44f6e: 4280 clrl %d0
44f70: 604e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
44f72: 7002 moveq #2,%d0
44f74: 604a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B110: baud_index = 3; break;
44f76: 7003 moveq #3,%d0
44f78: 6046 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B134: baud_index = 4; break;
44f7a: 7004 moveq #4,%d0
44f7c: 6042 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B150: baud_index = 5; break;
44f7e: 7005 moveq #5,%d0
44f80: 603e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B200: baud_index = 6; break;
44f82: 7006 moveq #6,%d0
44f84: 603a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B300: baud_index = 7; break;
44f86: 7007 moveq #7,%d0
44f88: 6036 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B600: baud_index = 8; break;
44f8a: 7008 moveq #8,%d0
44f8c: 6032 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B1200: baud_index = 9; break;
44f8e: 7009 moveq #9,%d0
44f90: 602e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B1800: baud_index = 10; break;
44f92: 700a moveq #10,%d0
44f94: 602a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B2400: baud_index = 11; break;
44f96: 700b moveq #11,%d0
44f98: 6026 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B4800: baud_index = 12; break;
44f9a: 700c moveq #12,%d0
44f9c: 6022 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B9600: baud_index = 13; break;
44f9e: 700d moveq #13,%d0
44fa0: 601e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B19200: baud_index = 14; break;
44fa2: 700e moveq #14,%d0
44fa4: 601a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B38400: baud_index = 15; break;
44fa6: 700f moveq #15,%d0
44fa8: 6016 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B57600: baud_index = 16; break;
44faa: 7010 moveq #16,%d0
44fac: 6012 bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B115200: baud_index = 17; break;
44fae: 7011 moveq #17,%d0
44fb0: 600e bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B230400: baud_index = 18; break;
44fb2: 7012 moveq #18,%d0
44fb4: 600a bras 44fc0 <rtems_termios_baud_to_index+0x104>
case B460800: baud_index = 19; break;
44fb6: 7013 moveq #19,%d0
44fb8: 6006 bras 44fc0 <rtems_termios_baud_to_index+0x104>
default: baud_index = -1; break;
44fba: 70ff moveq #-1,%d0
44fbc: 6002 bras 44fc0 <rtems_termios_baud_to_index+0x104>
{
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
44fbe: 7001 moveq #1,%d0
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
44fc0: 4e5e unlk %fp <== NOT EXECUTED
00043d80 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
43d80: 4e56 fff4 linkw %fp,#-12
43d84: 48d7 1c00 moveml %a2-%a4,%sp@
43d88: 266e 0008 moveal %fp@(8),%a3
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
43d8c: 49f9 0004 59e0 lea 459e0 <rtems_semaphore_obtain>,%a4
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
43d92: 2053 moveal %a3@,%a0
43d94: 2468 0034 moveal %a0@(52),%a2
rtems_status_code sc;
sc = rtems_semaphore_obtain(
43d98: 42a7 clrl %sp@-
43d9a: 42a7 clrl %sp@-
43d9c: 2f39 0005 d71c movel 5d71c <rtems_termios_ttyMutex>,%sp@-
43da2: 4e94 jsr %a4@
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
43da4: 4fef 000c lea %sp@(12),%sp
43da8: 4a80 tstl %d0
43daa: 6600 0084 bnew 43e30 <rtems_termios_close+0xb0>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
43dae: 202a 0008 movel %a2@(8),%d0
43db2: 5380 subql #1,%d0
43db4: 2540 0008 movel %d0,%a2@(8)
43db8: 6600 0120 bnew 43eda <rtems_termios_close+0x15a>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
43dbc: 202a 00cc movel %a2@(204),%d0
43dc0: eb88 lsll #5,%d0
43dc2: 0680 0005 cee4 addil #380644,%d0
43dc8: 2240 moveal %d0,%a1
43dca: 2051 moveal %a1@,%a0
43dcc: 4a88 tstl %a0
43dce: 6706 beqs 43dd6 <rtems_termios_close+0x56>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
43dd0: 2f0a movel %a2,%sp@-
43dd2: 4e90 jsr %a0@
43dd4: 602a bras 43e00 <rtems_termios_close+0x80>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
43dd6: 42a7 clrl %sp@-
43dd8: 42a7 clrl %sp@-
43dda: 2f2a 0018 movel %a2@(24),%sp@-
43dde: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL) {
43de0: 4fef 000c lea %sp@(12),%sp
43de4: 4a80 tstl %d0
43de6: 6648 bnes 43e30 <rtems_termios_close+0xb0> <== NEVER TAKEN
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
43de8: 4aaa 00b4 tstl %a2@(180)
43dec: 6708 beqs 43df6 <rtems_termios_close+0x76>
43dee: 2f0a movel %a2,%sp@-
43df0: 4eba fb4a jsr %pc@(4393c <drainOutput.part.0>)
43df4: 588f addql #4,%sp
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
43df6: 2f2a 0018 movel %a2@(24),%sp@-
43dfa: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
43e00: 588f addql #4,%sp
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43e02: 7002 moveq #2,%d0
43e04: b0aa 00b4 cmpl %a2@(180),%d0
43e08: 662e bnes 43e38 <rtems_termios_close+0xb8>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
43e0a: 4878 0001 pea 1 <ADD>
43e0e: 49f9 0004 5584 lea 45584 <rtems_event_send>,%a4
43e14: 2f2a 00c4 movel %a2@(196),%sp@-
43e18: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL)
43e1a: 508f addql #8,%sp
43e1c: 4a80 tstl %d0
43e1e: 6610 bnes 43e30 <rtems_termios_close+0xb0> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
43e20: 4878 0001 pea 1 <ADD>
43e24: 2f2a 00c8 movel %a2@(200),%sp@-
43e28: 4e94 jsr %a4@
if (sc != RTEMS_SUCCESSFUL)
43e2a: 508f addql #8,%sp
43e2c: 4a80 tstl %d0
43e2e: 6708 beqs 43e38 <rtems_termios_close+0xb8> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
43e30: 2f00 movel %d0,%sp@- <== NOT EXECUTED
43e32: 4eb9 0004 60a0 jsr 460a0 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (tty->device.lastClose)
43e38: 206a 009c moveal %a2@(156),%a0
43e3c: 4a88 tstl %a0
43e3e: 6710 beqs 43e50 <rtems_termios_close+0xd0>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
43e40: 2f0b movel %a3,%sp@-
43e42: 2f2a 0010 movel %a2@(16),%sp@-
43e46: 2f2a 000c movel %a2@(12),%sp@-
43e4a: 4e90 jsr %a0@
43e4c: 4fef 000c lea %sp@(12),%sp
if (tty->forw == NULL) {
43e50: 2252 moveal %a2@,%a1
43e52: 206a 0004 moveal %a2@(4),%a0
43e56: 4a89 tstl %a1
43e58: 660c bnes 43e66 <rtems_termios_close+0xe6>
rtems_termios_ttyTail = tty->back;
43e5a: 23c8 0005 d720 movel %a0,5d720 <rtems_termios_ttyTail>
if ( rtems_termios_ttyTail != NULL ) {
43e60: 6708 beqs 43e6a <rtems_termios_close+0xea>
rtems_termios_ttyTail->forw = NULL;
43e62: 4290 clrl %a0@
43e64: 6004 bras 43e6a <rtems_termios_close+0xea>
}
} else {
tty->forw->back = tty->back;
43e66: 2348 0004 movel %a0,%a1@(4)
}
if (tty->back == NULL) {
43e6a: 226a 0004 moveal %a2@(4),%a1
43e6e: 2052 moveal %a2@,%a0
43e70: 4a89 tstl %a1
43e72: 660e bnes 43e82 <rtems_termios_close+0x102>
rtems_termios_ttyHead = tty->forw;
43e74: 23c8 0005 d724 movel %a0,5d724 <rtems_termios_ttyHead>
if ( rtems_termios_ttyHead != NULL ) {
43e7a: 6708 beqs 43e84 <rtems_termios_close+0x104>
rtems_termios_ttyHead->back = NULL;
43e7c: 42a8 0004 clrl %a0@(4)
43e80: 6002 bras 43e84 <rtems_termios_close+0x104>
}
} else {
tty->back->forw = tty->forw;
43e82: 2288 movel %a0,%a1@
}
rtems_semaphore_delete (tty->isem);
43e84: 2f2a 0014 movel %a2@(20),%sp@-
43e88: 47f9 0004 5944 lea 45944 <rtems_semaphore_delete>,%a3
43e8e: 4e93 jsr %a3@
rtems_semaphore_delete (tty->osem);
43e90: 2f2a 0018 movel %a2@(24),%sp@-
43e94: 4e93 jsr %a3@
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
43e96: 2f2a 008c movel %a2@(140),%sp@-
43e9a: 4e93 jsr %a3@
if ((tty->device.pollRead == NULL) ||
43e9c: 4fef 000c lea %sp@(12),%sp
43ea0: 4aaa 00a0 tstl %a2@(160)
43ea4: 6708 beqs 43eae <rtems_termios_close+0x12e>
43ea6: 7002 moveq #2,%d0
43ea8: b0aa 00b4 cmpl %a2@(180),%d0
43eac: 660c bnes 43eba <rtems_termios_close+0x13a>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
43eae: 2f2a 0068 movel %a2@(104),%sp@-
43eb2: 4eb9 0004 5944 jsr 45944 <rtems_semaphore_delete>
43eb8: 588f addql #4,%sp
free (tty->rawInBuf.theBuf);
43eba: 2f2a 0058 movel %a2@(88),%sp@-
43ebe: 47f9 0004 2b68 lea 42b68 <free>,%a3
43ec4: 4e93 jsr %a3@
free (tty->rawOutBuf.theBuf);
43ec6: 2f2a 007c movel %a2@(124),%sp@-
43eca: 4e93 jsr %a3@
free (tty->cbuf);
43ecc: 2f2a 001c movel %a2@(28),%sp@-
43ed0: 4e93 jsr %a3@
free (tty);
43ed2: 2f0a movel %a2,%sp@-
43ed4: 4e93 jsr %a3@
43ed6: 4fef 0010 lea %sp@(16),%sp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
43eda: 2f39 0005 d71c movel 5d71c <rtems_termios_ttyMutex>,%sp@-
43ee0: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
43ee6: 4cee 1c00 fff4 moveml %fp@(-12),%a2-%a4
43eec: 4280 clrl %d0
43eee: 4e5e unlk %fp <== NOT EXECUTED
000450e2 <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
450e2: 4e56 0000 linkw %fp,#0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
450e6: 202e 000c movel %fp@(12),%d0
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
450ea: 206e 0008 moveal %fp@(8),%a0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
450ee: d1a8 0090 addl %d0,%a0@(144)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
450f2: 7002 moveq #2,%d0
450f4: b0a8 00b4 cmpl %a0@(180),%d0
450f8: 661c bnes 45116 <rtems_termios_dequeue_characters+0x34>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
450fa: 4878 0002 pea 2 <DOUBLE_FLOAT>
450fe: 2f28 00c8 movel %a0@(200),%sp@-
45102: 4eb9 0004 5584 jsr 45584 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
45108: 508f addql #8,%sp
4510a: 4a80 tstl %d0
4510c: 672e beqs 4513c <rtems_termios_dequeue_characters+0x5a><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
4510e: 2f00 movel %d0,%sp@- <== NOT EXECUTED
45110: 4eb9 0004 60a0 jsr 460a0 <rtems_fatal_error_occurred> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
45116: 7005 moveq #5,%d0
45118: b0a8 00cc cmpl %a0@(204),%d0
4511c: 6612 bnes 45130 <rtems_termios_dequeue_characters+0x4e>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
4511e: 2279 0005 cf94 moveal 5cf94 <rtems_termios_linesw+0xb4>,%a1
45124: 4a89 tstl %a1
45126: 6714 beqs 4513c <rtems_termios_dequeue_characters+0x5a><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
45128: 2f08 movel %a0,%sp@-
4512a: 4e91 jsr %a1@
4512c: 588f addql #4,%sp
4512e: 600c bras 4513c <rtems_termios_dequeue_characters+0x5a>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
45130: 2d48 0008 movel %a0,%fp@(8)
}
45134: 4e5e unlk %fp
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
45136: 4ef9 0004 4ec6 jmp 44ec6 <rtems_termios_refill_transmitter>
}
4513c: 4280 clrl %d0
4513e: 4e5e unlk %fp
...
00044c00 <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
44c00: 4e56 ffcc linkw %fp,#-52
44c04: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
44c08: 246e 0008 moveal %fp@(8),%a2
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
44c0c: 202a 00cc movel %a2@(204),%d0
44c10: eb88 lsll #5,%d0
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
44c12: 266e 000c moveal %fp@(12),%a3
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
44c16: 0680 0005 cef0 addil #380656,%d0
44c1c: 2040 moveal %d0,%a0
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
44c1e: 242e 0010 movel %fp@(16),%d2
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
44c22: 4a90 tstl %a0@
44c24: 663c bnes 44c62 <rtems_termios_enqueue_raw_characters+0x62>
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
44c26: 43ea 004a lea %a2@(74),%a1
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
44c2a: 4bf3 2800 lea %a3@(00000000,%d2:l),%a5
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
44c2e: 283c 0000 0700 movel #1792,%d4
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
44c34: 4282 clrl %d2
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44c36: 49ea 0030 lea %a2@(48),%a4
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
44c3a: 2d49 fff4 movel %a1,%fp@(-12)
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
44c3e: 4205 clrb %d5
44c40: 6000 01ee braw 44e30 <rtems_termios_enqueue_raw_characters+0x230>
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
44c44: 202a 00cc movel %a2@(204),%d0
44c48: 5382 subql #1,%d2
44c4a: 2f0a movel %a2,%sp@-
44c4c: 121b moveb %a3@+,%d1
44c4e: eb88 lsll #5,%d0
44c50: 49c1 extbl %d1
44c52: 0680 0005 cef0 addil #380656,%d0
44c58: 2240 moveal %d0,%a1
44c5a: 2f01 movel %d1,%sp@-
44c5c: 2051 moveal %a1@,%a0
44c5e: 4e90 jsr %a0@
44c60: 508f addql #8,%sp
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
44c62: 4a82 tstl %d2
44c64: 66de bnes 44c44 <rtems_termios_enqueue_raw_characters+0x44>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
44c66: 4aaa 00e4 tstl %a2@(228)
44c6a: 6600 01dc bnew 44e48 <rtems_termios_enqueue_raw_characters+0x248>
44c6e: 206a 00dc moveal %a2@(220),%a0
44c72: 4a88 tstl %a0
44c74: 6700 01d2 beqw 44e48 <rtems_termios_enqueue_raw_characters+0x248>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44c78: 2f2a 00e0 movel %a2@(224),%sp@-
44c7c: 486a 0030 pea %a2@(48)
44c80: 4e90 jsr %a0@
tty->tty_rcvwakeup = 1;
44c82: 508f addql #8,%sp
44c84: 7001 moveq #1,%d0
44c86: 2540 00e4 movel %d0,%a2@(228)
44c8a: 6000 01be braw 44e4a <rtems_termios_enqueue_raw_characters+0x24a>
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
44c8e: 202a 00b8 movel %a2@(184),%d0
}
return 0;
}
while (len--) {
c = *buf++;
44c92: 1c1b moveb %a3@+,%d6
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
44c94: 0800 0009 btst #9,%d0
44c98: 6740 beqs 44cda <rtems_termios_enqueue_raw_characters+0xda>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
44c9a: 4283 clrl %d3
44c9c: 162a 004a moveb %a2@(74),%d3
44ca0: 4281 clrl %d1
44ca2: 122a 0049 moveb %a2@(73),%d1
44ca6: 1006 moveb %d6,%d0
44ca8: 49c0 extbl %d0
44caa: b680 cmpl %d0,%d3
44cac: 661e bnes 44ccc <rtems_termios_enqueue_raw_characters+0xcc>
if (c == tty->termios.c_cc[VSTART]) {
44cae: b280 cmpl %d0,%d1
44cb0: 660a bnes 44cbc <rtems_termios_enqueue_raw_characters+0xbc><== ALWAYS TAKEN
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
44cb2: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44cb6: 7210 moveq #16,%d1 <== NOT EXECUTED
44cb8: b380 eorl %d1,%d0 <== NOT EXECUTED
44cba: 6008 bras 44cc4 <rtems_termios_enqueue_raw_characters+0xc4><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
44cbc: 202a 00b8 movel %a2@(184),%d0
44cc0: 7e10 moveq #16,%d7
44cc2: 8087 orl %d7,%d0
44cc4: 2540 00b8 movel %d0,%a2@(184)
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
44cc8: 7a01 moveq #1,%d5
44cca: 6012 bras 44cde <rtems_termios_enqueue_raw_characters+0xde>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
44ccc: b280 cmpl %d0,%d1
44cce: 660a bnes 44cda <rtems_termios_enqueue_raw_characters+0xda><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
44cd0: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44cd4: 72ef moveq #-17,%d1 <== NOT EXECUTED
44cd6: c081 andl %d1,%d0 <== NOT EXECUTED
44cd8: 60ea bras 44cc4 <rtems_termios_enqueue_raw_characters+0xc4><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
44cda: 4a05 tstb %d5
44cdc: 674c beqs 44d2a <rtems_termios_enqueue_raw_characters+0x12a><== ALWAYS TAKEN
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
44cde: 202a 00b8 movel %a2@(184),%d0
44ce2: 7e30 moveq #48,%d7
44ce4: 7220 moveq #32,%d1
44ce6: c087 andl %d7,%d0
44ce8: b280 cmpl %d0,%d1
44cea: 6600 0144 bnew 44e30 <rtems_termios_enqueue_raw_characters+0x230>
/* disable interrupts */
rtems_interrupt_disable(level);
44cee: 2004 movel %d4,%d0 <== NOT EXECUTED
44cf0: 40c3 movew %sr,%d3 <== NOT EXECUTED
44cf2: 8083 orl %d3,%d0 <== NOT EXECUTED
44cf4: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
44cf6: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44cfa: 7edf moveq #-33,%d7 <== NOT EXECUTED
44cfc: c087 andl %d7,%d0 <== NOT EXECUTED
44cfe: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
44d02: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED
44d06: 671c beqs 44d24 <rtems_termios_enqueue_raw_characters+0x124><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
44d08: 202a 0084 movel %a2@(132),%d0 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
44d0c: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44d10: d0aa 007c addl %a2@(124),%d0 <== NOT EXECUTED
44d14: 2f00 movel %d0,%sp@- <== NOT EXECUTED
44d16: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44d1a: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44d1e: 4e90 jsr %a0@ <== NOT EXECUTED
44d20: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
44d24: 46c3 movew %d3,%sr <== NOT EXECUTED
44d26: 6000 0108 braw 44e30 <rtems_termios_enqueue_raw_characters+0x230><== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
44d2a: 222a 0060 movel %a2@(96),%d1
44d2e: 5281 addql #1,%d1
44d30: 202a 0064 movel %a2@(100),%d0
44d34: 4c40 1003 remul %d0,%d3,%d1
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
44d38: 2004 movel %d4,%d0
44d3a: 40c1 movew %sr,%d1
44d3c: 8081 orl %d1,%d0
44d3e: 46c0 movew %d0,%sr
44d40: 2d41 fffc movel %d1,%fp@(-4)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
44d44: 206a 005c moveal %a2@(92),%a0
44d48: 202a 0064 movel %a2@(100),%d0
44d4c: 9088 subl %a0,%d0
44d4e: 2240 moveal %d0,%a1
44d50: d3c3 addal %d3,%a1
% tty->rawInBuf.Size) > tty->highwater) &&
44d52: 2009 movel %a1,%d0
44d54: 2e2a 0064 movel %a2@(100),%d7
44d58: 4c47 0001 remul %d7,%d1,%d0
44d5c: 2d47 fff8 movel %d7,%fp@(-8)
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
44d60: b2aa 00c0 cmpl %a2@(192),%d1
44d64: 6300 008e blsw 44df4 <rtems_termios_enqueue_raw_characters+0x1f4>
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
44d68: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
44d6c: 0800 0000 btst #0,%d0 <== NOT EXECUTED
44d70: 6600 0082 bnew 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
44d74: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44d78: 7e01 moveq #1,%d7 <== NOT EXECUTED
44d7a: 8087 orl %d7,%d0 <== NOT EXECUTED
44d7c: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
44d80: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44d84: 0280 0000 0402 andil #1026,%d0 <== NOT EXECUTED
44d8a: 0c80 0000 0400 cmpil #1024,%d0 <== NOT EXECUTED
44d90: 6634 bnes 44dc6 <rtems_termios_enqueue_raw_characters+0x1c6><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
44d92: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44d96: 0800 0005 btst #5,%d0 <== NOT EXECUTED
44d9a: 6606 bnes 44da2 <rtems_termios_enqueue_raw_characters+0x1a2><== NOT EXECUTED
44d9c: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED
44da0: 6652 bnes 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
44da2: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44da6: 7202 moveq #2,%d1 <== NOT EXECUTED
44da8: 8081 orl %d1,%d0 <== NOT EXECUTED
44daa: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
44dae: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44db2: 2f2e fff4 movel %fp@(-12),%sp@- <== NOT EXECUTED
44db6: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44dba: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44dbe: 4e90 jsr %a0@ <== NOT EXECUTED
44dc0: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44dc4: 602e bras 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
44dc6: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44dca: 0280 0000 0104 andil #260,%d0 <== NOT EXECUTED
44dd0: 0c80 0000 0100 cmpil #256,%d0 <== NOT EXECUTED
44dd6: 661c bnes 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
44dd8: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44ddc: 7e04 moveq #4,%d7 <== NOT EXECUTED
44dde: 8087 orl %d7,%d0 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
44de0: 206a 00ac moveal %a2@(172),%a0 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
44de4: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
44de8: 4a88 tstl %a0 <== NOT EXECUTED
44dea: 6708 beqs 44df4 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
44dec: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44df0: 4e90 jsr %a0@ <== NOT EXECUTED
44df2: 588f addql #4,%sp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
44df4: 222e fffc movel %fp@(-4),%d1
44df8: 46c1 movew %d1,%sr
if (newTail == tty->rawInBuf.Head) {
44dfa: 202a 005c movel %a2@(92),%d0
44dfe: b083 cmpl %d3,%d0
44e00: 6604 bnes 44e06 <rtems_termios_enqueue_raw_characters+0x206><== ALWAYS TAKEN
dropped++;
44e02: 5282 addql #1,%d2 <== NOT EXECUTED
44e04: 602a bras 44e30 <rtems_termios_enqueue_raw_characters+0x230><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
44e06: 206a 0058 moveal %a2@(88),%a0
44e0a: 1186 3800 moveb %d6,%a0@(00000000,%d3:l)
tty->rawInBuf.Tail = newTail;
44e0e: 2543 0060 movel %d3,%a2@(96)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
44e12: 4aaa 00e4 tstl %a2@(228)
44e16: 6618 bnes 44e30 <rtems_termios_enqueue_raw_characters+0x230><== NEVER TAKEN
44e18: 206a 00dc moveal %a2@(220),%a0
44e1c: 4a88 tstl %a0
44e1e: 6710 beqs 44e30 <rtems_termios_enqueue_raw_characters+0x230><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44e20: 2f2a 00e0 movel %a2@(224),%sp@- <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
44e24: 7e01 moveq #1,%d7 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
44e26: 2f0c movel %a4,%sp@- <== NOT EXECUTED
44e28: 4e90 jsr %a0@ <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
44e2a: 508f addql #8,%sp <== NOT EXECUTED
44e2c: 2547 00e4 movel %d7,%a2@(228) <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
44e30: bbcb cmpal %a3,%a5
44e32: 6600 fe5a bnew 44c8e <rtems_termios_enqueue_raw_characters+0x8e>
}
}
}
}
tty->rawInBufDropped += dropped;
44e36: d5aa 0078 addl %d2,%a2@(120)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
44e3a: 2f2a 0068 movel %a2@(104),%sp@-
44e3e: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return dropped;
44e44: 588f addql #4,%sp
44e46: 6002 bras 44e4a <rtems_termios_enqueue_raw_characters+0x24a>
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
44e48: 4282 clrl %d2 <== NOT EXECUTED
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
44e4a: 2002 movel %d2,%d0
44e4c: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5
44e52: 4e5e unlk %fp <== NOT EXECUTED
00043f1a <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
43f1a: 4e56 ffec linkw %fp,#-20
43f1e: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@
43f22: 266e 0008 moveal %fp@(8),%a3
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
43f26: 2053 moveal %a3@,%a0
43f28: 2468 0034 moveal %a0@(52),%a2
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
43f2c: 286b 0008 moveal %a3@(8),%a4
rtems_status_code sc;
args->ioctl_return = 0;
43f30: 42ab 000c clrl %a3@(12)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
43f34: 42a7 clrl %sp@-
43f36: 42a7 clrl %sp@-
43f38: 2f2a 0018 movel %a2@(24),%sp@-
43f3c: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
43f42: 4fef 000c lea %sp@(12),%sp
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
43f46: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL) {
43f48: 6708 beqs 43f52 <rtems_termios_ioctl+0x38> <== ALWAYS TAKEN
args->ioctl_return = sc;
43f4a: 2740 000c movel %d0,%a3@(12) <== NOT EXECUTED
return sc;
43f4e: 6000 02d4 braw 44224 <rtems_termios_ioctl+0x30a> <== NOT EXECUTED
}
switch (args->command) {
43f52: 202b 0004 movel %a3@(4),%d0
43f56: 7204 moveq #4,%d1
43f58: b280 cmpl %d0,%d1
43f5a: 6700 023a beqw 44196 <rtems_termios_ioctl+0x27c>
43f5e: 6514 bcss 43f74 <rtems_termios_ioctl+0x5a>
43f60: 7602 moveq #2,%d3
43f62: b680 cmpl %d0,%d3
43f64: 6778 beqs 43fde <rtems_termios_ioctl+0xc4>
43f66: 6500 020e bcsw 44176 <rtems_termios_ioctl+0x25c>
43f6a: 123c 0001 moveb #1,%d1
43f6e: b280 cmpl %d0,%d1
43f70: 6630 bnes 43fa2 <rtems_termios_ioctl+0x88> <== NEVER TAKEN
43f72: 6050 bras 43fc4 <rtems_termios_ioctl+0xaa>
43f74: 0c80 4004 667f cmpil #1074030207,%d0
43f7a: 6700 0272 beqw 441ee <rtems_termios_ioctl+0x2d4>
43f7e: 620a bhis 43f8a <rtems_termios_ioctl+0x70>
43f80: 7605 moveq #5,%d3
43f82: b680 cmpl %d0,%d3
43f84: 661c bnes 43fa2 <rtems_termios_ioctl+0x88>
43f86: 6000 01fe braw 44186 <rtems_termios_ioctl+0x26c>
43f8a: 222a 00cc movel %a2@(204),%d1
43f8e: 0c80 4004 741a cmpil #1074033690,%d0
43f94: 6700 0252 beqw 441e8 <rtems_termios_ioctl+0x2ce>
43f98: 0c80 8004 741b cmpil #-2147191781,%d0
43f9e: 6700 0206 beqw 441a6 <rtems_termios_ioctl+0x28c>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
43fa2: 202a 00cc movel %a2@(204),%d0
43fa6: eb88 lsll #5,%d0
43fa8: 0680 0005 cef8 addil #380664,%d0
43fae: 2240 moveal %d0,%a1
43fb0: 2051 moveal %a1@,%a0
43fb2: 4a88 tstl %a0
43fb4: 6700 025c beqw 44212 <rtems_termios_ioctl+0x2f8>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
43fb8: 2f0b movel %a3,%sp@-
43fba: 2f0a movel %a2,%sp@-
43fbc: 4e90 jsr %a0@
43fbe: 2400 movel %d0,%d2
43fc0: 6000 01ae braw 44170 <rtems_termios_ioctl+0x256>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
43fc4: 4878 0024 pea 24 <OPER2+0x10>
43fc8: 486a 0030 pea %a2@(48)
43fcc: 2f2b 0008 movel %a3@(8),%sp@-
43fd0: 4eb9 0004 c854 jsr 4c854 <memcpy>
break;
43fd6: 4fef 000c lea %sp@(12),%sp
43fda: 6000 0238 braw 44214 <rtems_termios_ioctl+0x2fa>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
43fde: 4878 0024 pea 24 <OPER2+0x10>
43fe2: 2f2b 0008 movel %a3@(8),%sp@-
43fe6: 486a 0030 pea %a2@(48)
43fea: 4eb9 0004 c854 jsr 4c854 <memcpy>
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
43ff0: 202a 00b8 movel %a2@(184),%d0
43ff4: 4fef 000c lea %sp@(12),%sp
43ff8: 0800 0009 btst #9,%d0
43ffc: 6760 beqs 4405e <rtems_termios_ioctl+0x144>
!(tty->termios.c_iflag & IXON)) {
43ffe: 202a 0030 movel %a2@(48),%d0
44002: 0280 0000 0400 andil #1024,%d0
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
44008: 6654 bnes 4405e <rtems_termios_ioctl+0x144>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
4400a: 202a 00b8 movel %a2@(184),%d0
4400e: 0280 ffff fdef andil #-529,%d0
44014: 2540 00b8 movel %d0,%a2@(184)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
44018: 202a 00b8 movel %a2@(184),%d0
4401c: 0800 0005 btst #5,%d0
44020: 673c beqs 4405e <rtems_termios_ioctl+0x144> <== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
44022: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
44028: 40c3 movew %sr,%d3 <== NOT EXECUTED
4402a: 8083 orl %d3,%d0 <== NOT EXECUTED
4402c: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
4402e: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44032: 72df moveq #-33,%d1 <== NOT EXECUTED
44034: c081 andl %d1,%d0 <== NOT EXECUTED
44036: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4403a: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED
4403e: 671c beqs 4405c <rtems_termios_ioctl+0x142> <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
44040: 202a 0084 movel %a2@(132),%d0 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
44044: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44048: d0aa 007c addl %a2@(124),%d0 <== NOT EXECUTED
4404c: 2f00 movel %d0,%sp@- <== NOT EXECUTED
4404e: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44052: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44056: 4e90 jsr %a0@ <== NOT EXECUTED
44058: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
4405c: 46c3 movew %d3,%sr <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
4405e: 202a 00b8 movel %a2@(184),%d0
44062: 0800 000a btst #10,%d0
44066: 6724 beqs 4408c <rtems_termios_ioctl+0x172>
44068: 202a 0030 movel %a2@(48),%d0
4406c: 0280 0000 1000 andil #4096,%d0
44072: 6618 bnes 4408c <rtems_termios_ioctl+0x172> <== NEVER TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
44074: 202a 00b8 movel %a2@(184),%d0
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
44078: 76fd moveq #-3,%d3
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
4407a: 0880 000a bclr #10,%d0
4407e: 2540 00b8 movel %d0,%a2@(184)
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
44082: 202a 00b8 movel %a2@(184),%d0
44086: c083 andl %d3,%d0
44088: 2540 00b8 movel %d0,%a2@(184)
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
4408c: 202a 00b8 movel %a2@(184),%d0
44090: 0800 0008 btst #8,%d0
44094: 6736 beqs 440cc <rtems_termios_ioctl+0x1b2> <== ALWAYS TAKEN
44096: 4aaa 0038 tstl %a2@(56) <== NOT EXECUTED
4409a: 6d30 blts 440cc <rtems_termios_ioctl+0x1b2> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
4409c: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
440a0: 0880 0008 bclr #8,%d0 <== NOT EXECUTED
440a4: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
440a8: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
440ac: 44c0 movew %d0,%ccr <== NOT EXECUTED
440ae: 6610 bnes 440c0 <rtems_termios_ioctl+0x1a6> <== NOT EXECUTED
440b0: 206a 00b0 moveal %a2@(176),%a0 <== NOT EXECUTED
440b4: 4a88 tstl %a0 <== NOT EXECUTED
440b6: 6708 beqs 440c0 <rtems_termios_ioctl+0x1a6> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
440b8: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
440bc: 4e90 jsr %a0@ <== NOT EXECUTED
440be: 588f addql #4,%sp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
440c0: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
440c4: 72fb moveq #-5,%d1 <== NOT EXECUTED
440c6: c081 andl %d1,%d0 <== NOT EXECUTED
440c8: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
440cc: 4aaa 0038 tstl %a2@(56)
440d0: 6c0c bges 440de <rtems_termios_ioctl+0x1c4> <== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
440d2: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
440d6: 08c0 0008 bset #8,%d0 <== NOT EXECUTED
440da: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
440de: 222a 0030 movel %a2@(48),%d1
440e2: 0801 000c btst #12,%d1
440e6: 670c beqs 440f4 <rtems_termios_ioctl+0x1da>
tty->flow_ctrl |= FL_MDXOF;
440e8: 202a 00b8 movel %a2@(184),%d0
440ec: 08c0 000a bset #10,%d0
440f0: 2540 00b8 movel %d0,%a2@(184)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
440f4: 0801 000a btst #10,%d1
440f8: 670c beqs 44106 <rtems_termios_ioctl+0x1ec>
tty->flow_ctrl |= FL_MDXON;
440fa: 202a 00b8 movel %a2@(184),%d0
440fe: 08c0 0009 bset #9,%d0
44102: 2540 00b8 movel %d0,%a2@(184)
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
44106: 7002 moveq #2,%d0
44108: c0aa 003c andl %a2@(60),%d0
4410c: 663a bnes 44148 <rtems_termios_ioctl+0x22e>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
4410e: 4283 clrl %d3
44110: 162a 0046 moveb %a2@(70),%d3
rtems_clock_get_ticks_per_second() / 10;
44114: 4eb9 0004 539c jsr 4539c <rtems_clock_get_ticks_per_second>
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
4411a: 4c03 0800 mulsl %d3,%d0
rtems_clock_get_ticks_per_second() / 10;
4411e: 760a moveq #10,%d3
44120: 4c43 0000 remul %d3,%d0,%d0
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
44124: 2540 0054 movel %d0,%a2@(84)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
44128: 4a2a 0046 tstb %a2@(70)
4412c: 6714 beqs 44142 <rtems_termios_ioctl+0x228>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4412e: 42aa 006c clrl %a2@(108)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
44132: 2540 0070 movel %d0,%a2@(112)
if (tty->termios.c_cc[VMIN])
44136: 4a2a 0047 tstb %a2@(71)
4413a: 6614 bnes 44150 <rtems_termios_ioctl+0x236>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
4413c: 2540 0074 movel %d0,%a2@(116)
44140: 601a bras 4415c <rtems_termios_ioctl+0x242>
} else {
if (tty->termios.c_cc[VMIN]) {
44142: 4a2a 0047 tstb %a2@(71)
44146: 670e beqs 44156 <rtems_termios_ioctl+0x23c> <== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
44148: 42aa 006c clrl %a2@(108)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
4414c: 42aa 0070 clrl %a2@(112)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
44150: 42aa 0074 clrl %a2@(116)
44154: 6006 bras 4415c <rtems_termios_ioctl+0x242>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
44156: 7001 moveq #1,%d0
44158: 2540 006c movel %d0,%a2@(108)
}
}
}
if (tty->device.setAttributes)
4415c: 206a 00a8 moveal %a2@(168),%a0
44160: 4a88 tstl %a0
44162: 6700 00b0 beqw 44214 <rtems_termios_ioctl+0x2fa>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
44166: 486a 0030 pea %a2@(48)
4416a: 2f2a 0010 movel %a2@(16),%sp@-
4416e: 4e90 jsr %a0@
44170: 508f addql #8,%sp
44172: 6000 00a0 braw 44214 <rtems_termios_ioctl+0x2fa>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
44176: 4aaa 00b4 tstl %a2@(180)
4417a: 6700 0098 beqw 44214 <rtems_termios_ioctl+0x2fa>
4417e: 2f0a movel %a2,%sp@-
44180: 4eba f7ba jsr %pc@(4393c <drainOutput.part.0>)
44184: 605e bras 441e4 <rtems_termios_ioctl+0x2ca>
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
44186: 2014 movel %a4@,%d0
44188: 222c 0004 movel %a4@(4),%d1
4418c: 2540 00d4 movel %d0,%a2@(212)
44190: 2541 00d8 movel %d1,%a2@(216)
break;
44194: 607e bras 44214 <rtems_termios_ioctl+0x2fa>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
44196: 2014 movel %a4@,%d0
44198: 222c 0004 movel %a4@(4),%d1
4419c: 2540 00dc movel %d0,%a2@(220)
441a0: 2541 00e0 movel %d1,%a2@(224)
break;
441a4: 606e bras 44214 <rtems_termios_ioctl+0x2fa>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
441a6: 2001 movel %d1,%d0
441a8: eb88 lsll #5,%d0
441aa: 0680 0005 cee4 addil #380644,%d0
441b0: 2240 moveal %d0,%a1
441b2: 2051 moveal %a1@,%a0
441b4: 4a88 tstl %a0
441b6: 6708 beqs 441c0 <rtems_termios_ioctl+0x2a6>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
441b8: 2f0a movel %a2,%sp@-
441ba: 4e90 jsr %a0@
441bc: 588f addql #4,%sp
441be: 2400 movel %d0,%d2
}
tty->t_line=*(int*)(args->buffer);
441c0: 206b 0008 moveal %a3@(8),%a0
441c4: 2010 movel %a0@,%d0
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
441c6: 41f9 0005 cee0 lea 5cee0 <rtems_termios_linesw>,%a0
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
441cc: 2540 00cc movel %d0,%a2@(204)
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
441d0: eb88 lsll #5,%d0
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
tty->t_sc = NULL; /* ensure that no more valid data */
441d2: 42aa 00d0 clrl %a2@(208)
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
441d6: 2070 0800 moveal %a0@(00000000,%d0:l),%a0
441da: 4a88 tstl %a0
441dc: 6736 beqs 44214 <rtems_termios_ioctl+0x2fa>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
441de: 2f0a movel %a2,%sp@-
441e0: 4e90 jsr %a0@
441e2: 2400 movel %d0,%d2
441e4: 588f addql #4,%sp
441e6: 602c bras 44214 <rtems_termios_ioctl+0x2fa>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
441e8: 206b 0008 moveal %a3@(8),%a0
441ec: 6020 bras 4420e <rtems_termios_ioctl+0x2f4>
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
441ee: 202a 0060 movel %a2@(96),%d0 <== NOT EXECUTED
441f2: 222a 005c movel %a2@(92),%d1 <== NOT EXECUTED
441f6: 9081 subl %d1,%d0 <== NOT EXECUTED
if ( rawnc < 0 )
441f8: 6a06 bpls 44200 <rtems_termios_ioctl+0x2e6> <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
441fa: 222a 0064 movel %a2@(100),%d1 <== NOT EXECUTED
441fe: d081 addl %d1,%d0 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
44200: 222a 0020 movel %a2@(32),%d1 <== NOT EXECUTED
44204: 92aa 0024 subl %a2@(36),%d1 <== NOT EXECUTED
44208: d280 addl %d0,%d1 <== NOT EXECUTED
4420a: 206b 0008 moveal %a3@(8),%a0 <== NOT EXECUTED
4420e: 2081 movel %d1,%a0@
}
break;
44210: 6002 bras 44214 <rtems_termios_ioctl+0x2fa>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
44212: 740a moveq #10,%d2 <== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
44214: 2f2a 0018 movel %a2@(24),%sp@-
44218: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
args->ioctl_return = sc;
return sc;
4421e: 588f addql #4,%sp
}
break;
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
44220: 2742 000c movel %d2,%a3@(12)
return sc;
}
44224: 2002 movel %d2,%d0
44226: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
4422c: 4e5e unlk %fp <== NOT EXECUTED
000439a0 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
439a0: 4e56 ffdc linkw %fp,#-36
439a4: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
439a8: 42a7 clrl %sp@-
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
439aa: 282e 0008 movel %fp@(8),%d4
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
439ae: 42a7 clrl %sp@-
439b0: 2f39 0005 d71c movel 5d71c <rtems_termios_ttyMutex>,%sp@-
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
439b6: 2a2e 000c movel %fp@(12),%d5
439ba: 2a6e 0010 moveal %fp@(16),%a5
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
439be: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
439c4: 4fef 000c lea %sp@(12),%sp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
439c8: 2400 movel %d0,%d2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
439ca: 6600 038c bnew 43d58 <rtems_termios_open+0x3b8>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
439ce: 2679 0005 d724 moveal 5d724 <rtems_termios_ttyHead>,%a3
439d4: 244b moveal %a3,%a2
439d6: 6010 bras 439e8 <rtems_termios_open+0x48>
if ((tty->major == major) && (tty->minor == minor))
439d8: b8aa 000c cmpl %a2@(12),%d4
439dc: 6608 bnes 439e6 <rtems_termios_open+0x46>
439de: baaa 0010 cmpl %a2@(16),%d5
439e2: 6700 02fe beqw 43ce2 <rtems_termios_open+0x342>
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
439e6: 2452 moveal %a2@,%a2
439e8: 4a8a tstl %a2
439ea: 66ec bnes 439d8 <rtems_termios_open+0x38>
439ec: 6000 0376 braw 43d64 <rtems_termios_open+0x3c4>
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
rtems_semaphore_release (rtems_termios_ttyMutex);
439f0: 2f39 0005 d71c movel 5d71c <rtems_termios_ttyMutex>,%sp@-
439f6: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
439fc: 588f addql #4,%sp
439fe: 6038 bras 43a38 <rtems_termios_open+0x98>
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
43a00: 41f9 0005 c120 lea 5c120 <rtems_termios_raw_input_size>,%a0
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
43a06: 49f9 0004 2e54 lea 42e54 <malloc>,%a4
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
43a0c: 2550 0064 movel %a0@,%a2@(100)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
43a10: 202a 0064 movel %a2@(100),%d0
43a14: 2f00 movel %d0,%sp@-
43a16: 4e94 jsr %a4@
if (tty->rawInBuf.theBuf == NULL) {
43a18: 588f addql #4,%sp
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
43a1a: 2600 movel %d0,%d3
43a1c: 2540 0058 movel %d0,%a2@(88)
if (tty->rawInBuf.theBuf == NULL) {
43a20: 661c bnes 43a3e <rtems_termios_open+0x9e>
free(tty);
43a22: 2f0a movel %a2,%sp@-
43a24: 4eb9 0004 2b68 jsr 42b68 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
43a2a: 2f39 0005 d71c movel 5d71c <rtems_termios_ttyMutex>,%sp@-
43a30: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
43a36: 508f addql #8,%sp
43a38: 741a moveq #26,%d2
43a3a: 6000 031c braw 43d58 <rtems_termios_open+0x3b8>
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
43a3e: 41f9 0005 c124 lea 5c124 <rtems_termios_raw_output_size>,%a0
43a44: 2550 0088 movel %a0@,%a2@(136)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
43a48: 202a 0088 movel %a2@(136),%d0
43a4c: 2f00 movel %d0,%sp@-
43a4e: 4e94 jsr %a4@
if (tty->rawOutBuf.theBuf == NULL) {
43a50: 588f addql #4,%sp
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
43a52: 2c00 movel %d0,%d6
43a54: 2540 007c movel %d0,%a2@(124)
if (tty->rawOutBuf.theBuf == NULL) {
43a58: 6620 bnes 43a7a <rtems_termios_open+0xda> <== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
43a5a: 2f03 movel %d3,%sp@- <== NOT EXECUTED
43a5c: 47f9 0004 2b68 lea 42b68 <free>,%a3 <== NOT EXECUTED
43a62: 4e93 jsr %a3@ <== NOT EXECUTED
free(tty);
43a64: 2f0a movel %a2,%sp@- <== NOT EXECUTED
43a66: 4e93 jsr %a3@ <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
43a68: 2f39 0005 d71c movel 5d71c <rtems_termios_ttyMutex>,%sp@- <== NOT EXECUTED
43a6e: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
43a74: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
43a78: 60be bras 43a38 <rtems_termios_open+0x98> <== NOT EXECUTED
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
43a7a: 2f39 0005 c128 movel 5c128 <rtems_termios_cbufsize>,%sp@-
43a80: 4e94 jsr %a4@
if (tty->cbuf == NULL) {
43a82: 588f addql #4,%sp
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
43a84: 2540 001c movel %d0,%a2@(28)
if (tty->cbuf == NULL) {
43a88: 6624 bnes 43aae <rtems_termios_open+0x10e>
free((void *)(tty->rawOutBuf.theBuf));
43a8a: 2f06 movel %d6,%sp@-
43a8c: 47f9 0004 2b68 lea 42b68 <free>,%a3
43a92: 4e93 jsr %a3@
free((void *)(tty->rawInBuf.theBuf));
43a94: 2f03 movel %d3,%sp@-
43a96: 4e93 jsr %a3@
free(tty);
43a98: 2f0a movel %a2,%sp@-
43a9a: 4e93 jsr %a3@
rtems_semaphore_release (rtems_termios_ttyMutex);
43a9c: 2f39 0005 d71c movel 5d71c <rtems_termios_ttyMutex>,%sp@-
43aa2: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
43aa8: 4fef 0010 lea %sp@(16),%sp
43aac: 608a bras 43a38 <rtems_termios_open+0x98>
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
43aae: 42aa 00d4 clrl %a2@(212)
tty->tty_snd.sw_arg = NULL;
43ab2: 42aa 00d8 clrl %a2@(216)
tty->tty_rcv.sw_pfn = NULL;
43ab6: 42aa 00dc clrl %a2@(220)
tty->tty_rcv.sw_arg = NULL;
43aba: 42aa 00e0 clrl %a2@(224)
tty->tty_rcvwakeup = 0;
43abe: 42aa 00e4 clrl %a2@(228)
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
43ac2: 248b movel %a3,%a2@
tty->back = NULL;
43ac4: 42aa 0004 clrl %a2@(4)
if (rtems_termios_ttyHead != NULL)
43ac8: 4a8b tstl %a3
43aca: 6704 beqs 43ad0 <rtems_termios_open+0x130>
rtems_termios_ttyHead->back = tty;
43acc: 274a 0004 movel %a2,%a3@(4)
rtems_termios_ttyHead = tty;
43ad0: 23ca 0005 d724 movel %a2,5d724 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
43ad6: 4ab9 0005 d720 tstl 5d720 <rtems_termios_ttyTail>
43adc: 6606 bnes 43ae4 <rtems_termios_open+0x144>
rtems_termios_ttyTail = tty;
43ade: 23ca 0005 d720 movel %a2,5d720 <rtems_termios_ttyTail>
tty->minor = minor;
43ae4: 2545 0010 movel %d5,%a2@(16)
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43ae8: 47f9 0004 57a4 lea 457a4 <rtems_semaphore_create>,%a3
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
tty->major = major;
43aee: 2544 000c movel %d4,%a2@(12)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43af2: 486a 0014 pea %a2@(20)
rtems_build_name ('T', 'R', 'i', c),
43af6: 1039 0005 c12c moveb 5c12c <c.6337>,%d0
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43afc: 42a7 clrl %sp@-
43afe: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
rtems_build_name ('T', 'R', 'i', c),
43b02: 49c0 extbl %d0
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
43b04: 4878 0001 pea 1 <ADD>
43b08: 0080 5452 6900 oril #1414686976,%d0
43b0e: 2f00 movel %d0,%sp@-
43b10: 4e93 jsr %a3@
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
43b12: 4fef 0014 lea %sp@(20),%sp
43b16: 4a80 tstl %d0
43b18: 6600 0228 bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b1c: 486a 0018 pea %a2@(24)
rtems_build_name ('T', 'R', 'o', c),
43b20: 1039 0005 c12c moveb 5c12c <c.6337>,%d0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b26: 42a7 clrl %sp@-
43b28: 4878 0054 pea 54 <DBL_MANT_DIG+0x1f>
rtems_build_name ('T', 'R', 'o', c),
43b2c: 49c0 extbl %d0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b2e: 4878 0001 pea 1 <ADD>
43b32: 0080 5452 6f00 oril #1414688512,%d0
43b38: 2f00 movel %d0,%sp@-
43b3a: 4e93 jsr %a3@
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
43b3c: 4fef 0014 lea %sp@(20),%sp
43b40: 4a80 tstl %d0
43b42: 6600 01fe bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b46: 486a 008c pea %a2@(140)
rtems_build_name ('T', 'R', 'x', c),
43b4a: 1039 0005 c12c moveb 5c12c <c.6337>,%d0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b50: 42a7 clrl %sp@-
43b52: 4878 0020 pea 20 <OPER2+0xc>
rtems_build_name ('T', 'R', 'x', c),
43b56: 49c0 extbl %d0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
43b58: 0080 5452 7800 oril #1414690816,%d0
43b5e: 42a7 clrl %sp@-
43b60: 2f00 movel %d0,%sp@-
43b62: 4e93 jsr %a3@
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
43b64: 4fef 0014 lea %sp@(20),%sp
43b68: 4a80 tstl %d0
43b6a: 6600 01d6 bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
43b6e: 42aa 0094 clrl %a2@(148)
/*
* Set callbacks
*/
tty->device = *callbacks;
43b72: 4878 0020 pea 20 <OPER2+0xc>
43b76: 2f2e 0014 movel %fp@(20),%sp@-
43b7a: 486a 0098 pea %a2@(152)
43b7e: 4eb9 0004 c854 jsr 4c854 <memcpy>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43b84: 4fef 000c lea %sp@(12),%sp
43b88: 7002 moveq #2,%d0
43b8a: b0aa 00b4 cmpl %a2@(180),%d0
43b8e: 6662 bnes 43bf2 <rtems_termios_open+0x252>
sc = rtems_task_create (
43b90: 486a 00c8 pea %a2@(200)
43b94: 47f9 0004 5b98 lea 45b98 <rtems_task_create>,%a3
rtems_build_name ('T', 'x', 'T', c),
43b9a: 1039 0005 c12c moveb 5c12c <c.6337>,%d0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
43ba0: 42a7 clrl %sp@-
43ba2: 4878 0500 pea 500 <DBL_MAX_EXP+0xff>
rtems_build_name ('T', 'x', 'T', c),
43ba6: 49c0 extbl %d0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
43ba8: 4878 0400 pea 400 <D_BIAS+0x2>
43bac: 4878 000a pea a <LASTO>
43bb0: 0080 5478 5400 oril #1417171968,%d0
43bb6: 2f00 movel %d0,%sp@-
43bb8: 4e93 jsr %a3@
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
43bba: 4fef 0018 lea %sp@(24),%sp
43bbe: 4a80 tstl %d0
43bc0: 6600 0180 bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
43bc4: 486a 00c4 pea %a2@(196)
rtems_build_name ('R', 'x', 'T', c),
43bc8: 1039 0005 c12c moveb 5c12c <c.6337>,%d0
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
43bce: 42a7 clrl %sp@-
43bd0: 4878 0500 pea 500 <DBL_MAX_EXP+0xff>
rtems_build_name ('R', 'x', 'T', c),
43bd4: 49c0 extbl %d0
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
43bd6: 4878 0400 pea 400 <D_BIAS+0x2>
43bda: 4878 0009 pea 9 <DIVIDE_BY_ZERO+0x1>
43bde: 0080 5278 5400 oril #1383617536,%d0
43be4: 2f00 movel %d0,%sp@-
43be6: 4e93 jsr %a3@
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
43be8: 4fef 0018 lea %sp@(24),%sp
43bec: 4a80 tstl %d0
43bee: 6600 0152 bnew 43d42 <rtems_termios_open+0x3a2>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
43bf2: 4aaa 00a0 tstl %a2@(160)
43bf6: 6708 beqs 43c00 <rtems_termios_open+0x260>
43bf8: 7202 moveq #2,%d1
43bfa: b2aa 00b4 cmpl %a2@(180),%d1
43bfe: 662c bnes 43c2c <rtems_termios_open+0x28c>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43c00: 486a 0068 pea %a2@(104)
rtems_build_name ('T', 'R', 'r', c),
43c04: 1039 0005 c12c moveb 5c12c <c.6337>,%d0
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43c0a: 42a7 clrl %sp@-
43c0c: 4878 0024 pea 24 <OPER2+0x10>
rtems_build_name ('T', 'R', 'r', c),
43c10: 49c0 extbl %d0
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
43c12: 0080 5452 7200 oril #1414689280,%d0
43c18: 42a7 clrl %sp@-
43c1a: 2f00 movel %d0,%sp@-
43c1c: 4eb9 0004 57a4 jsr 457a4 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
43c22: 4fef 0014 lea %sp@(20),%sp
43c26: 4a80 tstl %d0
43c28: 6600 0118 bnew 43d42 <rtems_termios_open+0x3a2>
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
43c2c: 203c 0000 1805 movel #6149,%d0
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
43c32: 223c 0000 08bd movel #2237,%d1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
43c38: 307c 2502 moveaw #9474,%a0
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
43c3c: 2540 0034 movel %d0,%a2@(52)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
43c40: 7003 moveq #3,%d0
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
43c42: 2541 0038 movel %d1,%a2@(56)
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
43c46: 1540 0041 moveb %d0,%a2@(65)
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
43c4a: 42aa 00b8 clrl %a2@(184)
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
43c4e: 707f moveq #127,%d0
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
43c50: 721c moveq #28,%d1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
43c52: 2548 0030 movel %a0,%a2@(48)
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
43c56: 1540 0043 moveb %d0,%a2@(67)
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
43c5a: 7004 moveq #4,%d0
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
43c5c: 1541 0042 moveb %d1,%a2@(66)
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
43c60: 1540 0045 moveb %d0,%a2@(69)
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
43c64: 7011 moveq #17,%d0
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
43c66: 7215 moveq #21,%d1
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
43c68: 1540 0049 moveb %d0,%a2@(73)
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
43c6c: 701a moveq #26,%d0
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
43c6e: 207c 0000 823b moveal #33339,%a0
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
43c74: 1540 004b moveb %d0,%a2@(75)
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
43c78: 700f moveq #15,%d0
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
43c7a: 1541 0044 moveb %d1,%a2@(68)
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
43c7e: 2548 003c movel %a0,%a2@(60)
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
43c82: 1540 004e moveb %d0,%a2@(78)
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
43c86: 7016 moveq #22,%d0
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
43c88: 4201 clrb %d1
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
43c8a: 1540 0050 moveb %d0,%a2@(80)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
43c8e: 202a 0064 movel %a2@(100),%d0
43c92: e288 lsrl #1,%d0
tty->highwater = tty->rawInBuf.Size * 3/4;
43c94: 206a 0064 moveal %a2@(100),%a0
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
43c98: 1541 004c moveb %d1,%a2@(76)
tty->termios.c_cc[VEOL2] = '\000';
43c9c: 1541 0051 moveb %d1,%a2@(81)
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
43ca0: 7213 moveq #19,%d1
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
43ca2: 41f0 8a00 lea %a0@(00000000,%a0:l:2),%a0
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
43ca6: 2540 00bc movel %d0,%a2@(188)
tty->highwater = tty->rawInBuf.Size * 3/4;
43caa: 2008 movel %a0,%d0
43cac: e488 lsrl #2,%d0
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
43cae: 1541 004a moveb %d1,%a2@(74)
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
43cb2: 7212 moveq #18,%d1
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
43cb4: 2540 00c0 movel %d0,%a2@(192)
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
43cb8: 1541 004d moveb %d1,%a2@(77)
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
43cbc: 7217 moveq #23,%d1
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
43cbe: 1039 0005 c12c moveb 5c12c <c.6337>,%d0
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
43cc4: 1541 004f moveb %d1,%a2@(79)
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
43cc8: 49c0 extbl %d0
43cca: 2200 movel %d0,%d1
43ccc: 5281 addql #1,%d1
43cce: 13c1 0005 c12c moveb %d1,5c12c <c.6337>
43cd4: 727a moveq #122,%d1
43cd6: b280 cmpl %d0,%d1
43cd8: 6608 bnes 43ce2 <rtems_termios_open+0x342>
c = 'a';
43cda: 7061 moveq #97,%d0
43cdc: 13c0 0005 c12c moveb %d0,5c12c <c.6337>
}
args->iop->data1 = tty;
43ce2: 2055 moveal %a5@,%a0
if (!tty->refcount++) {
43ce4: 202a 0008 movel %a2@(8),%d0
43ce8: 2200 movel %d0,%d1
43cea: 5281 addql #1,%d1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
43cec: 214a 0034 movel %a2,%a0@(52)
if (!tty->refcount++) {
43cf0: 2541 0008 movel %d1,%a2@(8)
43cf4: 4a80 tstl %d0
43cf6: 6652 bnes 43d4a <rtems_termios_open+0x3aa>
if (tty->device.firstOpen)
43cf8: 206a 0098 moveal %a2@(152),%a0
43cfc: 4a88 tstl %a0
43cfe: 670c beqs 43d0c <rtems_termios_open+0x36c>
(*tty->device.firstOpen)(major, minor, arg);
43d00: 2f0d movel %a5,%sp@-
43d02: 2f05 movel %d5,%sp@-
43d04: 2f04 movel %d4,%sp@-
43d06: 4e90 jsr %a0@
43d08: 4fef 000c lea %sp@(12),%sp
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
43d0c: 7002 moveq #2,%d0
43d0e: b0aa 00b4 cmpl %a2@(180),%d0
43d12: 6636 bnes 43d4a <rtems_termios_open+0x3aa>
sc = rtems_task_start(
43d14: 2f0a movel %a2,%sp@-
43d16: 487a 113e pea %pc@(44e56 <rtems_termios_rxdaemon>)
43d1a: 47f9 0004 5e18 lea 45e18 <rtems_task_start>,%a3
43d20: 2f2a 00c4 movel %a2@(196),%sp@-
43d24: 4e93 jsr %a3@
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
43d26: 4fef 000c lea %sp@(12),%sp
43d2a: 4a80 tstl %d0
43d2c: 6614 bnes 43d42 <rtems_termios_open+0x3a2> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
43d2e: 2f0a movel %a2,%sp@-
43d30: 487a 1348 pea %pc@(4507a <rtems_termios_txdaemon>)
43d34: 2f2a 00c8 movel %a2@(200),%sp@-
43d38: 4e93 jsr %a3@
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
43d3a: 4fef 000c lea %sp@(12),%sp
43d3e: 4a80 tstl %d0
43d40: 6708 beqs 43d4a <rtems_termios_open+0x3aa>
rtems_fatal_error_occurred (sc);
43d42: 2f00 movel %d0,%sp@-
43d44: 4eb9 0004 60a0 jsr 460a0 <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
43d4a: 2f39 0005 d71c movel 5d71c <rtems_termios_ttyMutex>,%sp@-
43d50: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
43d56: 588f addql #4,%sp
}
43d58: 2002 movel %d2,%d0
43d5a: 4cee 3c7c ffdc moveml %fp@(-36),%d2-%d6/%a2-%a5
43d60: 4e5e unlk %fp
43d62: 4e75 rts
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
43d64: 4878 00e8 pea e8 <DBL_MANT_DIG+0xb3>
43d68: 4878 0001 pea 1 <ADD>
43d6c: 4eb9 0004 27cc jsr 427cc <calloc>
if (tty == NULL) {
43d72: 508f addql #8,%sp
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
43d74: 2440 moveal %d0,%a2
if (tty == NULL) {
43d76: 4a80 tstl %d0
43d78: 6600 fc86 bnew 43a00 <rtems_termios_open+0x60>
43d7c: 6000 fc72 braw 439f0 <rtems_termios_open+0x50>
00044230 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
44230: 4e56 ffe0 linkw %fp,#-32
44234: 48d7 1c7c moveml %d2-%d6/%a2-%a4,%sp@
44238: 266e 0008 moveal %fp@(8),%a3
4423c: 242e 000c movel %fp@(12),%d2
44240: 246e 0010 moveal %fp@(16),%a2
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
44244: 4aaa 00b4 tstl %a2@(180)
44248: 661c bnes 44266 <rtems_termios_puts+0x36>
(*tty->device.write)(tty->minor, buf, len);
4424a: 2d42 0010 movel %d2,%fp@(16)
4424e: 2d4b 000c movel %a3,%fp@(12)
44252: 2d6a 0010 0008 movel %a2@(16),%fp@(8)
44258: 226a 00a4 moveal %a2@(164),%a1
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
4425c: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
44262: 4e5e unlk %fp
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
44264: 4ed1 jmp %a1@
return;
}
newHead = tty->rawOutBuf.Head;
44266: 2c2a 0080 movel %a2@(128),%d6
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
4426a: 2a3c 0000 0700 movel #1792,%d5
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
44270: 49f9 0004 59e0 lea 459e0 <rtems_semaphore_obtain>,%a4
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
44276: 6000 0096 braw 4430e <rtems_termios_puts+0xde>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
4427a: 202a 0088 movel %a2@(136),%d0
4427e: 5286 addql #1,%d6
44280: 4c40 6004 remul %d0,%d4,%d6
44284: 2c04 movel %d4,%d6
44286: 6022 bras 442aa <rtems_termios_puts+0x7a>
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
44288: 7002 moveq #2,%d0
4428a: 2540 0094 movel %d0,%a2@(148)
rtems_interrupt_enable (level);
4428e: 46c3 movew %d3,%sr
sc = rtems_semaphore_obtain(
44290: 42a7 clrl %sp@-
44292: 42a7 clrl %sp@-
44294: 2f2a 008c movel %a2@(140),%sp@-
44298: 4e94 jsr %a4@
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4429a: 4fef 000c lea %sp@(12),%sp
4429e: 4a80 tstl %d0
442a0: 6708 beqs 442aa <rtems_termios_puts+0x7a> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
442a2: 2f00 movel %d0,%sp@- <== NOT EXECUTED
442a4: 4eb9 0004 60a0 jsr 460a0 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
442aa: 2005 movel %d5,%d0
442ac: 40c3 movew %sr,%d3
442ae: 8083 orl %d3,%d0
442b0: 46c0 movew %d0,%sr
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
442b2: 202a 0084 movel %a2@(132),%d0
442b6: b084 cmpl %d4,%d0
442b8: 67ce beqs 44288 <rtems_termios_puts+0x58>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
442ba: 202a 0080 movel %a2@(128),%d0
442be: 206a 007c moveal %a2@(124),%a0
442c2: 119b 0800 moveb %a3@+,%a0@(00000000,%d0:l)
tty->rawOutBuf.Head = newHead;
442c6: 2544 0080 movel %d4,%a2@(128)
if (tty->rawOutBufState == rob_idle) {
442ca: 4aaa 0094 tstl %a2@(148)
442ce: 663a bnes 4430a <rtems_termios_puts+0xda>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
442d0: 202a 00b8 movel %a2@(184),%d0
442d4: 0800 0004 btst #4,%d0
442d8: 661e bnes 442f8 <rtems_termios_puts+0xc8> <== NEVER TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
442da: 202a 0084 movel %a2@(132),%d0
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
442de: 4878 0001 pea 1 <ADD>
442e2: d0aa 007c addl %a2@(124),%d0
442e6: 2f00 movel %d0,%sp@-
442e8: 2f2a 0010 movel %a2@(16),%sp@-
442ec: 206a 00a4 moveal %a2@(164),%a0
442f0: 4e90 jsr %a0@
442f2: 4fef 000c lea %sp@(12),%sp
442f6: 600c bras 44304 <rtems_termios_puts+0xd4>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
442f8: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
442fc: 7220 moveq #32,%d1 <== NOT EXECUTED
442fe: 8081 orl %d1,%d0 <== NOT EXECUTED
44300: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
44304: 7001 moveq #1,%d0
44306: 2540 0094 movel %d0,%a2@(148)
}
rtems_interrupt_enable (level);
4430a: 46c3 movew %d3,%sr
len--;
4430c: 5382 subql #1,%d2
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
4430e: 4a82 tstl %d2
44310: 6600 ff68 bnew 4427a <rtems_termios_puts+0x4a>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
44314: 4cee 1c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a4
4431a: 4e5e unlk %fp <== NOT EXECUTED
0004490e <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
4490e: 4e56 ffd4 linkw %fp,#-44
44912: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
44916: 266e 0008 moveal %fp@(8),%a3
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4491a: 2053 moveal %a3@,%a0
uint32_t count = args->count;
4491c: 262b 0010 movel %a3@(16),%d3
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
44920: 2468 0034 moveal %a0@(52),%a2
uint32_t count = args->count;
char *buffer = args->buffer;
44924: 2a6b 000c moveal %a3@(12),%a5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44928: 42a7 clrl %sp@-
4492a: 42a7 clrl %sp@-
4492c: 2f2a 0014 movel %a2@(20),%sp@-
44930: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
44936: 4fef 000c lea %sp@(12),%sp
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4493a: 2800 movel %d0,%d4
if (sc != RTEMS_SUCCESSFUL)
4493c: 6600 029a bnew 44bd8 <rtems_termios_read+0x2ca>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
44940: 202a 00cc movel %a2@(204),%d0
44944: eb88 lsll #5,%d0
44946: 0680 0005 cee8 addil #380648,%d0
4494c: 2240 moveal %d0,%a1
4494e: 2051 moveal %a1@,%a0
44950: 4a88 tstl %a0
44952: 671e beqs 44972 <rtems_termios_read+0x64>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
44954: 2f0b movel %a3,%sp@-
44956: 2f0a movel %a2,%sp@-
44958: 4e90 jsr %a0@
4495a: 2800 movel %d0,%d4
tty->tty_rcvwakeup = 0;
4495c: 42aa 00e4 clrl %a2@(228)
rtems_semaphore_release (tty->isem);
44960: 2f2a 0014 movel %a2@(20),%sp@-
44964: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return sc;
4496a: 4fef 000c lea %sp@(12),%sp
4496e: 6000 0268 braw 44bd8 <rtems_termios_read+0x2ca>
}
if (tty->cindex == tty->ccount) {
44972: 202a 0020 movel %a2@(32),%d0
44976: b0aa 0024 cmpl %a2@(36),%d0
4497a: 6600 0234 bnew 44bb0 <rtems_termios_read+0x2a2>
tty->cindex = tty->ccount = 0;
4497e: 42aa 0020 clrl %a2@(32)
tty->read_start_column = tty->column;
44982: 256a 0028 002c movel %a2@(40),%a2@(44)
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
44988: 42aa 0024 clrl %a2@(36)
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
4498c: 4aaa 00a0 tstl %a2@(160)
44990: 6700 00da beqw 44a6c <rtems_termios_read+0x15e>
44994: 4aaa 00b4 tstl %a2@(180)
44998: 6600 00d2 bnew 44a6c <rtems_termios_read+0x15e>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
4499c: 7002 moveq #2,%d0
4499e: c0aa 003c andl %a2@(60),%d0
449a2: 673e beqs 449e2 <rtems_termios_read+0xd4> <== NEVER TAKEN
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
449a4: 49f9 0004 5ec0 lea 45ec0 <rtems_task_wake_after>,%a4
} else {
if (siproc (n, tty))
449aa: 243c 0004 47e2 movel #280546,%d2
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
449b0: 2f2a 0010 movel %a2@(16),%sp@-
449b4: 206a 00a0 moveal %a2@(160),%a0
449b8: 4e90 jsr %a0@
if (n < 0) {
449ba: 588f addql #4,%sp
449bc: 4a80 tstl %d0
449be: 6c0a bges 449ca <rtems_termios_read+0xbc>
rtems_task_wake_after (1);
449c0: 4878 0001 pea 1 <ADD>
449c4: 4e94 jsr %a4@
449c6: 588f addql #4,%sp
449c8: 60e6 bras 449b0 <rtems_termios_read+0xa2>
} else {
if (siproc (n, tty))
449ca: 2f0a movel %a2,%sp@-
449cc: 2042 moveal %d2,%a0
449ce: 0280 0000 00ff andil #255,%d0
449d4: 2f00 movel %d0,%sp@-
449d6: 4e90 jsr %a0@
449d8: 508f addql #8,%sp
449da: 4a80 tstl %d0
449dc: 67d2 beqs 449b0 <rtems_termios_read+0xa2>
449de: 6000 01d0 braw 44bb0 <rtems_termios_read+0x2a2>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
449e2: 49f9 0004 53b4 lea 453b4 <rtems_clock_get_ticks_since_boot>,%a4
449e8: 4e94 jsr %a4@
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
449ea: 2c3c 0004 5ec0 movel #286400,%d6
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
449f0: 2400 movel %d0,%d2
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
449f2: 2a3c 0004 47e2 movel #280546,%d5
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
449f8: 2f2a 0010 movel %a2@(16),%sp@-
449fc: 206a 00a0 moveal %a2@(160),%a0
44a00: 4e90 jsr %a0@
if (n < 0) {
44a02: 588f addql #4,%sp
44a04: 4a80 tstl %d0
44a06: 6c34 bges 44a3c <rtems_termios_read+0x12e>
if (tty->termios.c_cc[VMIN]) {
44a08: 4a2a 0047 tstb %a2@(71)
44a0c: 670e beqs 44a1c <rtems_termios_read+0x10e> <== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
44a0e: 4a2a 0046 tstb %a2@(70)
44a12: 671c beqs 44a30 <rtems_termios_read+0x122> <== NEVER TAKEN
44a14: 4aaa 0020 tstl %a2@(32)
44a18: 6716 beqs 44a30 <rtems_termios_read+0x122>
44a1a: 6008 bras 44a24 <rtems_termios_read+0x116>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
44a1c: 4a2a 0046 tstb %a2@(70) <== NOT EXECUTED
44a20: 6700 018e beqw 44bb0 <rtems_termios_read+0x2a2> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
44a24: 4e94 jsr %a4@
if ((now - then) > tty->vtimeTicks) {
44a26: 9082 subl %d2,%d0
44a28: b0aa 0054 cmpl %a2@(84),%d0
44a2c: 6200 0182 bhiw 44bb0 <rtems_termios_read+0x2a2>
break;
}
}
rtems_task_wake_after (1);
44a30: 4878 0001 pea 1 <ADD>
44a34: 2246 moveal %d6,%a1
44a36: 4e91 jsr %a1@
44a38: 588f addql #4,%sp
44a3a: 60bc bras 449f8 <rtems_termios_read+0xea>
} else {
siproc (n, tty);
44a3c: 2f0a movel %a2,%sp@-
44a3e: 2045 moveal %d5,%a0
44a40: 0280 0000 00ff andil #255,%d0
44a46: 2f00 movel %d0,%sp@-
44a48: 4e90 jsr %a0@
if (tty->ccount >= tty->termios.c_cc[VMIN])
44a4a: 508f addql #8,%sp
44a4c: 4281 clrl %d1
44a4e: 102a 0047 moveb %a2@(71),%d0
44a52: 1200 moveb %d0,%d1
44a54: b2aa 0020 cmpl %a2@(32),%d1
44a58: 6f00 0156 blew 44bb0 <rtems_termios_read+0x2a2>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
44a5c: 4a00 tstb %d0
44a5e: 6798 beqs 449f8 <rtems_termios_read+0xea> <== NEVER TAKEN
44a60: 4a2a 0046 tstb %a2@(70)
44a64: 6792 beqs 449f8 <rtems_termios_read+0xea> <== NEVER TAKEN
then = rtems_clock_get_ticks_since_boot();
44a66: 4e94 jsr %a4@
44a68: 2400 movel %d0,%d2
44a6a: 608c bras 449f8 <rtems_termios_read+0xea>
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
44a6c: 2e0a movel %a2,%d7
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
44a6e: 7401 moveq #1,%d2
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
44a70: 49fa fd70 lea %pc@(447e2 <siproc>),%a4
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
44a74: 0687 0000 0049 addil #73,%d7
/*
* Wait for characters
*/
if ( wait ) {
sc = rtems_semaphore_obtain(
44a7a: 2c3c 0004 59e0 movel #285152,%d6
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
44a80: 2a2a 0074 movel %a2@(116),%d5
44a84: 6000 00e2 braw 44b68 <rtems_termios_read+0x25a>
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
44a88: 2a2a 005c movel %a2@(92),%d5
44a8c: 5285 addql #1,%d5
44a8e: 202a 0064 movel %a2@(100),%d0
c = tty->rawInBuf.theBuf[newHead];
44a92: 206a 0058 moveal %a2@(88),%a0
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
44a96: 4c40 5001 remul %d0,%d1,%d5
c = tty->rawInBuf.theBuf[newHead];
44a9a: 1a30 1800 moveb %a0@(00000000,%d1:l),%d5
tty->rawInBuf.Head = newHead;
44a9e: 2541 005c movel %d1,%a2@(92)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
44aa2: 202a 0060 movel %a2@(96),%d0
44aa6: 226a 0064 moveal %a2@(100),%a1
44aaa: 43f1 0800 lea %a1@(00000000,%d0:l),%a1
44aae: 93c1 subal %d1,%a1
% tty->rawInBuf.Size)
44ab0: 2009 movel %a1,%d0
44ab2: 206a 0064 moveal %a2@(100),%a0
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
44ab6: 1d45 ffff moveb %d5,%fp@(-1)
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
44aba: 2a08 movel %a0,%d5
44abc: 4c45 0001 remul %d5,%d1,%d0
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
44ac0: b2aa 00bc cmpl %a2@(188),%d1
44ac4: 646a bccs 44b30 <rtems_termios_read+0x222> <== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
44ac6: 202a 00b8 movel %a2@(184),%d0
44aca: 72fe moveq #-2,%d1
44acc: c081 andl %d1,%d0
44ace: 2540 00b8 movel %d0,%a2@(184)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
44ad2: 202a 00b8 movel %a2@(184),%d0
44ad6: 0280 0000 0202 andil #514,%d0
44adc: 0c80 0000 0202 cmpil #514,%d0
44ae2: 6626 bnes 44b0a <rtems_termios_read+0x1fc> <== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
44ae4: 4aaa 0094 tstl %a2@(148) <== NOT EXECUTED
44ae8: 670a beqs 44af4 <rtems_termios_read+0x1e6> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
44aea: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44aee: 0800 0005 btst #5,%d0 <== NOT EXECUTED
44af2: 6716 beqs 44b0a <rtems_termios_read+0x1fc> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
44af4: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44af8: 2f07 movel %d7,%sp@- <== NOT EXECUTED
44afa: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44afe: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44b02: 4e90 jsr %a0@ <== NOT EXECUTED
44b04: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44b08: 6026 bras 44b30 <rtems_termios_read+0x222> <== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
44b0a: 202a 00b8 movel %a2@(184),%d0
44b0e: 0800 0008 btst #8,%d0
44b12: 671c beqs 44b30 <rtems_termios_read+0x222> <== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
44b14: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44b18: 7afb moveq #-5,%d5 <== NOT EXECUTED
44b1a: c085 andl %d5,%d0 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
44b1c: 206a 00b0 moveal %a2@(176),%a0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
44b20: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
44b24: 4a88 tstl %a0 <== NOT EXECUTED
44b26: 6708 beqs 44b30 <rtems_termios_read+0x222> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
44b28: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44b2c: 4e90 jsr %a0@ <== NOT EXECUTED
44b2e: 588f addql #4,%sp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
44b30: 7002 moveq #2,%d0
44b32: 4285 clrl %d5
44b34: 1a2e ffff moveb %fp@(-1),%d5
44b38: c0aa 003c andl %a2@(60),%d0
44b3c: 670e beqs 44b4c <rtems_termios_read+0x23e> <== NEVER TAKEN
if (siproc (c, tty))
44b3e: 2f0a movel %a2,%sp@-
44b40: 2f05 movel %d5,%sp@-
44b42: 4e94 jsr %a4@
44b44: 508f addql #8,%sp
wait = 0;
44b46: 4a80 tstl %d0
44b48: 57c0 seq %d0
44b4a: 6014 bras 44b60 <rtems_termios_read+0x252>
} else {
siproc (c, tty);
44b4c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
44b4e: 2f05 movel %d5,%sp@- <== NOT EXECUTED
44b50: 4e94 jsr %a4@ <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
44b52: 508f addql #8,%sp <== NOT EXECUTED
44b54: 4280 clrl %d0 <== NOT EXECUTED
44b56: 102a 0047 moveb %a2@(71),%d0 <== NOT EXECUTED
wait = 0;
44b5a: b0aa 0020 cmpl %a2@(32),%d0 <== NOT EXECUTED
44b5e: 5ec0 sgt %d0 <== NOT EXECUTED
44b60: 49c0 extbl %d0
44b62: c480 andl %d0,%d2
}
timeout = tty->rawInBufSemaphoreTimeout;
44b64: 2a2a 0070 movel %a2@(112),%d5
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
44b68: 222a 005c movel %a2@(92),%d1
44b6c: 202a 0060 movel %a2@(96),%d0
44b70: b081 cmpl %d1,%d0
44b72: 6710 beqs 44b84 <rtems_termios_read+0x276>
(tty->ccount < (CBUFSIZE-1))) {
44b74: 2039 0005 c128 movel 5c128 <rtems_termios_cbufsize>,%d0
44b7a: 5380 subql #1,%d0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
44b7c: b0aa 0020 cmpl %a2@(32),%d0
44b80: 6e00 ff06 bgtw 44a88 <rtems_termios_read+0x17a>
}
/*
* Wait for characters
*/
if ( wait ) {
44b84: 4a82 tstl %d2
44b86: 6728 beqs 44bb0 <rtems_termios_read+0x2a2>
sc = rtems_semaphore_obtain(
44b88: 2f05 movel %d5,%sp@-
44b8a: 2f2a 006c movel %a2@(108),%sp@-
44b8e: 2046 moveal %d6,%a0
44b90: 2f2a 0068 movel %a2@(104),%sp@-
44b94: 4e90 jsr %a0@
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
44b96: 4fef 000c lea %sp@(12),%sp
44b9a: 4a80 tstl %d0
44b9c: 67ca beqs 44b68 <rtems_termios_read+0x25a> <== ALWAYS TAKEN
44b9e: 6010 bras 44bb0 <rtems_termios_read+0x2a2> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
44ba0: 206a 001c moveal %a2@(28),%a0
count--;
44ba4: 5383 subql #1,%d3
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
44ba6: 1af0 0800 moveb %a0@(00000000,%d0:l),%a5@+
44baa: 5280 addql #1,%d0
44bac: 2540 0024 movel %d0,%a2@(36)
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
44bb0: 4a83 tstl %d3
44bb2: 670a beqs 44bbe <rtems_termios_read+0x2b0>
44bb4: 202a 0024 movel %a2@(36),%d0
44bb8: b0aa 0020 cmpl %a2@(32),%d0
44bbc: 6de2 blts 44ba0 <rtems_termios_read+0x292>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
44bbe: 202b 0010 movel %a3@(16),%d0
44bc2: 9083 subl %d3,%d0
44bc4: 2740 0018 movel %d0,%a3@(24)
tty->tty_rcvwakeup = 0;
44bc8: 42aa 00e4 clrl %a2@(228)
rtems_semaphore_release (tty->isem);
44bcc: 2f2a 0014 movel %a2@(20),%sp@-
44bd0: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return sc;
44bd6: 588f addql #4,%sp
}
44bd8: 2004 movel %d4,%d0
44bda: 4cee 3cfc ffd4 moveml %fp@(-44),%d2-%d7/%a2-%a5
44be0: 4e5e unlk %fp <== NOT EXECUTED
00044ec6 <rtems_termios_refill_transmitter>:
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
44ec6: 4e56 fff4 linkw %fp,#-12
44eca: 48d7 040c moveml %d2-%d3/%a2,%sp@
44ece: 246e 0008 moveal %fp@(8),%a2
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
44ed2: 202a 00b8 movel %a2@(184),%d0
44ed6: 0280 0000 0403 andil #1027,%d0
44edc: 0c80 0000 0401 cmpil #1025,%d0
44ee2: 663c bnes 44f20 <rtems_termios_refill_transmitter+0x5a><== ALWAYS TAKEN
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
44ee4: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44ee8: 486a 004a pea %a2@(74) <== NOT EXECUTED
44eec: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44ef0: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44ef4: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_interrupt_disable(level);
44ef6: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
44efc: 40c1 movew %sr,%d1 <== NOT EXECUTED
44efe: 8081 orl %d1,%d0 <== NOT EXECUTED
44f00: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->t_dqlen--;
tty->flow_ctrl |= FL_ISNTXOF;
44f02: 7402 moveq #2,%d2 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
44f04: 53aa 0090 subql #1,%a2@(144) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
44f08: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44f0c: 8082 orl %d2,%d0 <== NOT EXECUTED
44f0e: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
rtems_interrupt_enable(level);
44f12: 46c1 movew %d1,%sr <== NOT EXECUTED
44f14: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
nToSend = 1;
44f18: 143c 0001 moveb #1,%d2 <== NOT EXECUTED
44f1c: 6000 0150 braw 4506e <rtems_termios_refill_transmitter+0x1a8><== NOT EXECUTED
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
44f20: 202a 00b8 movel %a2@(184),%d0
44f24: 7203 moveq #3,%d1
44f26: 7402 moveq #2,%d2
44f28: c081 andl %d1,%d0
44f2a: b480 cmpl %d0,%d2
44f2c: 663a bnes 44f68 <rtems_termios_refill_transmitter+0xa2><== ALWAYS TAKEN
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
44f2e: 4878 0001 pea 1 <ADD> <== NOT EXECUTED
44f32: 486a 0049 pea %a2@(73) <== NOT EXECUTED
44f36: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
44f3a: 206a 00a4 moveal %a2@(164),%a0 <== NOT EXECUTED
44f3e: 4e90 jsr %a0@ <== NOT EXECUTED
rtems_interrupt_disable(level);
44f40: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
44f46: 40c1 movew %sr,%d1 <== NOT EXECUTED
44f48: 8081 orl %d1,%d0 <== NOT EXECUTED
44f4a: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->t_dqlen--;
tty->flow_ctrl &= ~FL_ISNTXOF;
44f4c: 74fd moveq #-3,%d2 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
44f4e: 53aa 0090 subql #1,%a2@(144) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
44f52: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
44f56: c082 andl %d2,%d0 <== NOT EXECUTED
44f58: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
rtems_interrupt_enable(level);
44f5c: 46c1 movew %d1,%sr <== NOT EXECUTED
nToSend = 1;
44f5e: 7401 moveq #1,%d2 <== NOT EXECUTED
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
44f60: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
44f64: 6000 0108 braw 4506e <rtems_termios_refill_transmitter+0x1a8><== NOT EXECUTED
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
44f68: 222a 0080 movel %a2@(128),%d1
44f6c: 202a 0084 movel %a2@(132),%d0
44f70: b081 cmpl %d1,%d0
44f72: 661a bnes 44f8e <rtems_termios_refill_transmitter+0xc8>
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
44f74: 7002 moveq #2,%d0
44f76: b0aa 0094 cmpl %a2@(148),%d0
44f7a: 6600 00f0 bnew 4506c <rtems_termios_refill_transmitter+0x1a6>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
44f7e: 2f2a 008c movel %a2@(140),%sp@- <== NOT EXECUTED
44f82: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release> <== NOT EXECUTED
44f88: 588f addql #4,%sp <== NOT EXECUTED
44f8a: 6000 00e0 braw 4506c <rtems_termios_refill_transmitter+0x1a6><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
44f8e: 203c 0000 0700 movel #1792,%d0
44f94: 40c1 movew %sr,%d1
44f96: 8081 orl %d1,%d0
44f98: 46c0 movew %d0,%sr
len = tty->t_dqlen;
44f9a: 206a 0090 moveal %a2@(144),%a0
tty->t_dqlen = 0;
44f9e: 42aa 0090 clrl %a2@(144)
rtems_interrupt_enable(level);
44fa2: 46c1 movew %d1,%sr
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
44fa4: 222a 0084 movel %a2@(132),%d1
44fa8: d288 addl %a0,%d1
44faa: 202a 0088 movel %a2@(136),%d0
44fae: 4c40 1003 remul %d0,%d3,%d1
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
44fb2: 7202 moveq #2,%d1
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
tty->rawOutBuf.Tail = newTail;
44fb4: 2543 0084 movel %d3,%a2@(132)
if (tty->rawOutBufState == rob_wait) {
44fb8: b2aa 0094 cmpl %a2@(148),%d1
44fbc: 660c bnes 44fca <rtems_termios_refill_transmitter+0x104>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
44fbe: 2f2a 008c movel %a2@(140),%sp@-
44fc2: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
44fc8: 588f addql #4,%sp
}
if (newTail == tty->rawOutBuf.Head) {
44fca: 202a 0080 movel %a2@(128),%d0
44fce: b083 cmpl %d3,%d0
44fd0: 661c bnes 44fee <rtems_termios_refill_transmitter+0x128>
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
44fd2: 206a 00d4 moveal %a2@(212),%a0
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
44fd6: 42aa 0094 clrl %a2@(148)
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
44fda: 4a88 tstl %a0
44fdc: 6700 0086 beqw 45064 <rtems_termios_refill_transmitter+0x19e>
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
44fe0: 2f2a 00d8 movel %a2@(216),%sp@- <== NOT EXECUTED
44fe4: 486a 0030 pea %a2@(48) <== NOT EXECUTED
44fe8: 4e90 jsr %a0@ <== NOT EXECUTED
44fea: 508f addql #8,%sp <== NOT EXECUTED
44fec: 6076 bras 45064 <rtems_termios_refill_transmitter+0x19e><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
44fee: 202a 00b8 movel %a2@(184),%d0
44ff2: 0280 0000 0210 andil #528,%d0
44ff8: 0c80 0000 0210 cmpil #528,%d0
44ffe: 6622 bnes 45022 <rtems_termios_refill_transmitter+0x15c><== ALWAYS TAKEN
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
45000: 303c 0700 movew #1792,%d0 <== NOT EXECUTED
45004: 40c1 movew %sr,%d1 <== NOT EXECUTED
45006: 8081 orl %d1,%d0 <== NOT EXECUTED
45008: 46c0 movew %d0,%sr <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
4500a: 202a 00b8 movel %a2@(184),%d0 <== NOT EXECUTED
4500e: 7420 moveq #32,%d2 <== NOT EXECUTED
45010: 8082 orl %d2,%d0 <== NOT EXECUTED
45012: 2540 00b8 movel %d0,%a2@(184) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
45016: 7001 moveq #1,%d0 <== NOT EXECUTED
45018: 2540 0094 movel %d0,%a2@(148) <== NOT EXECUTED
rtems_interrupt_enable(level);
4501c: 46c1 movew %d1,%sr <== NOT EXECUTED
nToSend = 0;
4501e: 4202 clrb %d2 <== NOT EXECUTED
45020: 6044 bras 45066 <rtems_termios_refill_transmitter+0x1a0><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
45022: 202a 0080 movel %a2@(128),%d0
45026: b083 cmpl %d3,%d0
45028: 6406 bccs 45030 <rtems_termios_refill_transmitter+0x16a>
nToSend = tty->rawOutBuf.Size - newTail;
4502a: 242a 0088 movel %a2@(136),%d2
4502e: 6004 bras 45034 <rtems_termios_refill_transmitter+0x16e>
else
nToSend = tty->rawOutBuf.Head - newTail;
45030: 242a 0080 movel %a2@(128),%d2
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
45034: 202a 00b8 movel %a2@(184),%d0
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
45038: 9483 subl %d3,%d2
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
4503a: 0280 0000 0600 andil #1536,%d0
45040: 6702 beqs 45044 <rtems_termios_refill_transmitter+0x17e>
nToSend = 1;
45042: 7401 moveq #1,%d2
}
tty->rawOutBufState = rob_busy; /*apm*/
45044: 7201 moveq #1,%d1
45046: 2541 0094 movel %d1,%a2@(148)
(*tty->device.write)(
4504a: 2f02 movel %d2,%sp@-
4504c: 202a 007c movel %a2@(124),%d0
45050: d083 addl %d3,%d0
45052: 2f00 movel %d0,%sp@-
45054: 2f2a 0010 movel %a2@(16),%sp@-
45058: 206a 00a4 moveal %a2@(164),%a0
4505c: 4e90 jsr %a0@
4505e: 4fef 000c lea %sp@(12),%sp
45062: 6002 bras 45066 <rtems_termios_refill_transmitter+0x1a0>
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
45064: 4282 clrl %d2
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
45066: 2543 0084 movel %d3,%a2@(132)
4506a: 6002 bras 4506e <rtems_termios_refill_transmitter+0x1a8>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
4506c: 4282 clrl %d2
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
4506e: 2002 movel %d2,%d0
45070: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
45076: 4e5e unlk %fp <== NOT EXECUTED
00044e56 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
44e56: 4e56 ffe0 linkw %fp,#-32
44e5a: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44e5e: 260e movel %fp,%d3
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44e60: 240e movel %fp,%d2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44e62: 5d83 subql #6,%d3
44e64: 4bf9 0004 541c lea 4541c <rtems_event_receive>,%a5
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
tty->rxTaskId = 0;
rtems_task_delete(RTEMS_SELF);
44e6a: 49f9 0004 5cbc lea 45cbc <rtems_task_delete>,%a4
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44e70: 5382 subql #1,%d2
44e72: 47f9 0004 4c00 lea 44c00 <rtems_termios_enqueue_raw_characters>,%a3
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
44e78: 246e 0008 moveal %fp@(8),%a2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
44e7c: 2f03 movel %d3,%sp@-
44e7e: 42a7 clrl %sp@-
44e80: 4878 0002 pea 2 <DOUBLE_FLOAT>
44e84: 4878 0003 pea 3 <DIVIDE>
44e88: 4e95 jsr %a5@
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
44e8a: 4fef 0010 lea %sp@(16),%sp
44e8e: 7001 moveq #1,%d0
44e90: c0ae fffa andl %fp@(-6),%d0
44e94: 670a beqs 44ea0 <rtems_termios_rxdaemon+0x4a> <== ALWAYS TAKEN
tty->rxTaskId = 0;
44e96: 42aa 00c4 clrl %a2@(196) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
44e9a: 42a7 clrl %sp@- <== NOT EXECUTED
44e9c: 4e94 jsr %a4@ <== NOT EXECUTED
44e9e: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
44ea0: 2f2a 0010 movel %a2@(16),%sp@-
44ea4: 206a 00a0 moveal %a2@(160),%a0
44ea8: 4e90 jsr %a0@
if (c != EOF) {
44eaa: 588f addql #4,%sp
44eac: 72ff moveq #-1,%d1
44eae: b280 cmpl %d0,%d1
44eb0: 67ca beqs 44e7c <rtems_termios_rxdaemon+0x26>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44eb2: 4878 0001 pea 1 <ADD>
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
44eb6: 1d40 ffff moveb %d0,%fp@(-1)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
44eba: 2f02 movel %d2,%sp@-
44ebc: 2f0a movel %a2,%sp@-
44ebe: 4e93 jsr %a3@
44ec0: 4fef 000c lea %sp@(12),%sp
44ec4: 60b6 bras 44e7c <rtems_termios_rxdaemon+0x26>
0004507a <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
4507a: 4e56 ffe8 linkw %fp,#-24
4507e: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
45082: 240e movel %fp,%d2
45084: 5982 subql #4,%d2
45086: 4bf9 0004 541c lea 4541c <rtems_event_receive>,%a5
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
tty->txTaskId = 0;
rtems_task_delete(RTEMS_SELF);
4508c: 49f9 0004 5cbc lea 45cbc <rtems_task_delete>,%a4
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
45092: 47f9 0004 4ec6 lea 44ec6 <rtems_termios_refill_transmitter>,%a3
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
45098: 246e 0008 moveal %fp@(8),%a2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
4509c: 2f02 movel %d2,%sp@-
4509e: 42a7 clrl %sp@-
450a0: 4878 0002 pea 2 <DOUBLE_FLOAT>
450a4: 4878 0003 pea 3 <DIVIDE>
450a8: 4e95 jsr %a5@
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
450aa: 4fef 0010 lea %sp@(16),%sp
450ae: 7001 moveq #1,%d0
450b0: c0ae fffc andl %fp@(-4),%d0
450b4: 670a beqs 450c0 <rtems_termios_txdaemon+0x46> <== ALWAYS TAKEN
tty->txTaskId = 0;
450b6: 42aa 00c8 clrl %a2@(200) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
450ba: 42a7 clrl %sp@- <== NOT EXECUTED
450bc: 4e94 jsr %a4@ <== NOT EXECUTED
450be: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
450c0: 202a 00cc movel %a2@(204),%d0
450c4: eb88 lsll #5,%d0
450c6: 0680 0005 cef4 addil #380660,%d0
450cc: 2240 moveal %d0,%a1
450ce: 2051 moveal %a1@,%a0
450d0: 4a88 tstl %a0
450d2: 6706 beqs 450da <rtems_termios_txdaemon+0x60> <== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
450d4: 2f0a movel %a2,%sp@- <== NOT EXECUTED
450d6: 4e90 jsr %a0@ <== NOT EXECUTED
450d8: 588f addql #4,%sp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
450da: 2f0a movel %a2,%sp@-
450dc: 4e93 jsr %a3@
}
450de: 588f addql #4,%sp
450e0: 60ba bras 4509c <rtems_termios_txdaemon+0x22>
00044856 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
44856: 4e56 ffe8 linkw %fp,#-24
4485a: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
4485e: 246e 0008 moveal %fp@(8),%a2
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
44862: 2052 moveal %a2@,%a0
44864: 2668 0034 moveal %a0@(52),%a3
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44868: 42a7 clrl %sp@-
4486a: 42a7 clrl %sp@-
4486c: 2f2b 0018 movel %a3@(24),%sp@-
44870: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
44876: 4fef 000c lea %sp@(12),%sp
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4487a: 2400 movel %d0,%d2
if (sc != RTEMS_SUCCESSFUL)
4487c: 6600 0084 bnew 44902 <rtems_termios_write+0xac>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
44880: 202b 00cc movel %a3@(204),%d0
44884: eb88 lsll #5,%d0
44886: 0680 0005 ceec addil #380652,%d0
4488c: 2240 moveal %d0,%a1
4488e: 2051 moveal %a1@,%a0
44890: 4a88 tstl %a0
44892: 6718 beqs 448ac <rtems_termios_write+0x56>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
44894: 2f0a movel %a2,%sp@-
44896: 2f0b movel %a3,%sp@-
44898: 4e90 jsr %a0@
rtems_semaphore_release (tty->osem);
4489a: 2f2b 0018 movel %a3@(24),%sp@-
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
4489e: 2400 movel %d0,%d2
rtems_semaphore_release (tty->osem);
448a0: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return sc;
448a6: 4fef 000c lea %sp@(12),%sp
448aa: 6056 bras 44902 <rtems_termios_write+0xac>
}
if (tty->termios.c_oflag & OPOST) {
448ac: 7001 moveq #1,%d0
448ae: c0ab 0034 andl %a3@(52),%d0
448b2: 6728 beqs 448dc <rtems_termios_write+0x86> <== NEVER TAKEN
uint32_t count = args->count;
448b4: 262a 0010 movel %a2@(16),%d3
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
448b8: 4bfa fa64 lea %pc@(4431e <oproc>),%a5
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
448bc: 286a 000c moveal %a2@(12),%a4
while (count--)
448c0: 600e bras 448d0 <rtems_termios_write+0x7a>
oproc (*buffer++, tty);
448c2: 4280 clrl %d0
448c4: 101c moveb %a4@+,%d0
448c6: 5383 subql #1,%d3
448c8: 2f0b movel %a3,%sp@-
448ca: 2f00 movel %d0,%sp@-
448cc: 4e95 jsr %a5@
448ce: 508f addql #8,%sp
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
448d0: 4a83 tstl %d3
448d2: 66ee bnes 448c2 <rtems_termios_write+0x6c>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
448d4: 256a 0010 0018 movel %a2@(16),%a2@(24)
448da: 601a bras 448f6 <rtems_termios_write+0xa0>
} else {
rtems_termios_puts (args->buffer, args->count, tty);
448dc: 2f0b movel %a3,%sp@- <== NOT EXECUTED
448de: 2f2a 0010 movel %a2@(16),%sp@- <== NOT EXECUTED
448e2: 2f2a 000c movel %a2@(12),%sp@- <== NOT EXECUTED
448e6: 4eb9 0004 4230 jsr 44230 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
448ec: 256a 0010 0018 movel %a2@(16),%a2@(24) <== NOT EXECUTED
448f2: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
448f6: 2f2b 0018 movel %a3@(24),%sp@-
448fa: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
return sc;
44900: 588f addql #4,%sp
}
44902: 2002 movel %d2,%d0
44904: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
4490a: 4e5e unlk %fp <== NOT EXECUTED
00051390 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
51390: 4e56 fffc linkw %fp,#-4
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
51394: 486e fffc pea %fp@(-4)
51398: 2f2e 0008 movel %fp@(8),%sp@-
5139c: 4879 0007 5878 pea 75878 <_Timer_Information>
513a2: 4eb9 0005 3d18 jsr 53d18 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
513a8: 4fef 000c lea %sp@(12),%sp
513ac: 4aae fffc tstl %fp@(-4)
513b0: 6620 bnes 513d2 <rtems_timer_cancel+0x42>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
513b2: 7204 moveq #4,%d1
513b4: 2040 moveal %d0,%a0
513b6: b2a8 0038 cmpl %a0@(56),%d1
513ba: 670c beqs 513c8 <rtems_timer_cancel+0x38> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
513bc: 4868 0010 pea %a0@(16)
513c0: 4eb9 0005 5870 jsr 55870 <_Watchdog_Remove>
513c6: 588f addql #4,%sp
_Thread_Enable_dispatch();
513c8: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
513ce: 4280 clrl %d0
513d0: 6002 bras 513d4 <rtems_timer_cancel+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
513d2: 7004 moveq #4,%d0
}
513d4: 4e5e unlk %fp <== NOT EXECUTED
00045ee4 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
45ee4: 4e56 0000 linkw %fp,#0
45ee8: 2f0a movel %a2,%sp@-
45eea: 246e 000c moveal %fp@(12),%a2
45eee: 2f02 movel %d2,%sp@-
45ef0: 242e 0008 movel %fp@(8),%d2
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
45ef4: 676e beqs 45f64 <rtems_timer_create+0x80> <== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
45ef6: 4a8a tstl %a2
45ef8: 676e beqs 45f68 <rtems_timer_create+0x84> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45efa: 2039 0005 d89a movel 5d89a <_Thread_Dispatch_disable_level>,%d0
45f00: 5280 addql #1,%d0
45f02: 23c0 0005 d89a movel %d0,5d89a <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45f08: 2039 0005 d89a movel 5d89a <_Thread_Dispatch_disable_level>,%d0
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
45f0e: 4879 0005 da6c pea 5da6c <_Timer_Information>
45f14: 4eb9 0004 6d2c jsr 46d2c <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
45f1a: 588f addql #4,%sp
45f1c: 2040 moveal %d0,%a0
45f1e: 4a80 tstl %d0
45f20: 660a bnes 45f2c <rtems_timer_create+0x48>
_Thread_Enable_dispatch();
45f22: 4eb9 0004 7d40 jsr 47d40 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
45f28: 7005 moveq #5,%d0
45f2a: 603e bras 45f6a <rtems_timer_create+0x86>
}
the_timer->the_class = TIMER_DORMANT;
45f2c: 7004 moveq #4,%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45f2e: 4281 clrl %d1
45f30: 2140 0038 movel %d0,%a0@(56)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45f34: 2028 0008 movel %a0@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45f38: 2279 0005 da84 moveal 5da84 <_Timer_Information+0x18>,%a1
45f3e: 3200 movew %d0,%d1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
45f40: 42a8 0018 clrl %a0@(24)
the_watchdog->routine = routine;
45f44: 42a8 002c clrl %a0@(44)
the_watchdog->id = id;
45f48: 42a8 0030 clrl %a0@(48)
the_watchdog->user_data = user_data;
45f4c: 42a8 0034 clrl %a0@(52)
45f50: 2388 1c00 movel %a0,%a1@(00000000,%d1:l:4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
45f54: 2142 000c movel %d2,%a0@(12)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
45f58: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
45f5a: 4eb9 0004 7d40 jsr 47d40 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
45f60: 4280 clrl %d0
45f62: 6006 bras 45f6a <rtems_timer_create+0x86>
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
45f64: 7003 moveq #3,%d0
45f66: 6002 bras 45f6a <rtems_timer_create+0x86>
if ( !id )
return RTEMS_INVALID_ADDRESS;
45f68: 7009 moveq #9,%d0
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
45f6a: 242e fff8 movel %fp@(-8),%d2
45f6e: 246e fffc moveal %fp@(-4),%a2
45f72: 4e5e unlk %fp
...
0005176c <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
5176c: 4e56 ffe8 linkw %fp,#-24
51770: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
51774: 262e 0008 movel %fp@(8),%d3
51778: 242e 000c movel %fp@(12),%d2
5177c: 282e 0010 movel %fp@(16),%d4
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
51780: 2679 0007 58b0 moveal 758b0 <_Timer_server>,%a3
if ( !timer_server )
51786: 4a8b tstl %a3
51788: 6700 0088 beqw 51812 <rtems_timer_server_fire_after+0xa6>
return RTEMS_INCORRECT_STATE;
if ( !routine )
5178c: 4a84 tstl %d4
5178e: 6700 0086 beqw 51816 <rtems_timer_server_fire_after+0xaa>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
51792: 4a82 tstl %d2
51794: 6700 0084 beqw 5181a <rtems_timer_server_fire_after+0xae>
51798: 486e fffc pea %fp@(-4)
5179c: 2f03 movel %d3,%sp@-
5179e: 4879 0007 5878 pea 75878 <_Timer_Information>
517a4: 4eb9 0005 3d18 jsr 53d18 <_Objects_Get>
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
517aa: 4fef 000c lea %sp@(12),%sp
517ae: 2440 moveal %d0,%a2
517b0: 4aae fffc tstl %fp@(-4)
517b4: 6668 bnes 5181e <rtems_timer_server_fire_after+0xb2><== NEVER TAKEN
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
517b6: 486a 0010 pea %a2@(16)
517ba: 4eb9 0005 5870 jsr 55870 <_Watchdog_Remove>
_ISR_Disable( level );
517c0: 203c 0000 0700 movel #1792,%d0
517c6: 40c1 movew %sr,%d1
517c8: 8081 orl %d1,%d0
517ca: 46c0 movew %d0,%sr
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
517cc: 588f addql #4,%sp
517ce: 4aaa 0018 tstl %a2@(24)
517d2: 670a beqs 517de <rtems_timer_server_fire_after+0x72>
_ISR_Enable( level );
517d4: 46c1 movew %d1,%sr
_Thread_Enable_dispatch();
517d6: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
517dc: 6030 bras 5180e <rtems_timer_server_fire_after+0xa2>
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL_ON_TASK;
517de: 7001 moveq #1,%d0
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
517e0: 256e 0014 0034 movel %fp@(20),%a2@(52)
517e6: 2540 0038 movel %d0,%a2@(56)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
517ea: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine;
517ee: 2544 002c movel %d4,%a2@(44)
the_watchdog->id = id;
517f2: 2543 0030 movel %d3,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
517f6: 2542 001c movel %d2,%a2@(28)
_ISR_Enable( level );
517fa: 46c1 movew %d1,%sr
(*timer_server->schedule_operation)( timer_server, the_timer );
517fc: 2f0a movel %a2,%sp@-
517fe: 2f0b movel %a3,%sp@-
51800: 206b 0004 moveal %a3@(4),%a0
51804: 4e90 jsr %a0@
_Thread_Enable_dispatch();
51806: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
5180c: 508f addql #8,%sp
5180e: 4280 clrl %d0
51810: 600e bras 51820 <rtems_timer_server_fire_after+0xb4>
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
51812: 700e moveq #14,%d0
51814: 600a bras 51820 <rtems_timer_server_fire_after+0xb4>
if ( !routine )
return RTEMS_INVALID_ADDRESS;
51816: 7009 moveq #9,%d0
51818: 6006 bras 51820 <rtems_timer_server_fire_after+0xb4>
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
5181a: 700a moveq #10,%d0
5181c: 6002 bras 51820 <rtems_timer_server_fire_after+0xb4>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
5181e: 7004 moveq #4,%d0
}
51820: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3
51826: 4e5e unlk %fp
...
0005182c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
5182c: 4e56 ffe8 linkw %fp,#-24
51830: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
51834: 262e 0008 movel %fp@(8),%d3
51838: 242e 000c movel %fp@(12),%d2
5183c: 282e 0010 movel %fp@(16),%d4
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
51840: 2679 0007 58b0 moveal 758b0 <_Timer_server>,%a3
if ( !timer_server )
51846: 4a8b tstl %a3
51848: 6700 0098 beqw 518e2 <rtems_timer_server_fire_when+0xb6>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
5184c: 4a39 0007 5674 tstb 75674 <_TOD_Is_set>
51852: 6700 0092 beqw 518e6 <rtems_timer_server_fire_when+0xba>
return RTEMS_NOT_DEFINED;
if ( !routine )
51856: 4a84 tstl %d4
51858: 6700 0090 beqw 518ea <rtems_timer_server_fire_when+0xbe>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
5185c: 2f02 movel %d2,%sp@-
5185e: 4eb9 0004 ec6c jsr 4ec6c <_TOD_Validate>
51864: 588f addql #4,%sp
51866: 4a00 tstb %d0
51868: 6700 0084 beqw 518ee <rtems_timer_server_fire_when+0xc2>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
5186c: 2f02 movel %d2,%sp@-
5186e: 4eb9 0004 ebd4 jsr 4ebd4 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
51874: 588f addql #4,%sp
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
51876: 2400 movel %d0,%d2
if ( seconds <= _TOD_Seconds_since_epoch() )
51878: b0b9 0007 56ee cmpl 756ee <_TOD_Now>,%d0
5187e: 636e blss 518ee <rtems_timer_server_fire_when+0xc2>
51880: 486e fffc pea %fp@(-4)
51884: 2f03 movel %d3,%sp@-
51886: 4879 0007 5878 pea 75878 <_Timer_Information>
5188c: 4eb9 0005 3d18 jsr 53d18 <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
51892: 4fef 000c lea %sp@(12),%sp
51896: 2440 moveal %d0,%a2
51898: 4aae fffc tstl %fp@(-4)
5189c: 6654 bnes 518f2 <rtems_timer_server_fire_when+0xc6>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
5189e: 486a 0010 pea %a2@(16)
518a2: 4eb9 0005 5870 jsr 55870 <_Watchdog_Remove>
the_watchdog->user_data = user_data;
518a8: 256e 0014 0034 movel %fp@(20),%a2@(52)
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
518ae: 94b9 0007 56ee subl 756ee <_TOD_Now>,%d2
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
518b4: 7003 moveq #3,%d0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
518b6: 42aa 0018 clrl %a2@(24)
518ba: 2540 0038 movel %d0,%a2@(56)
the_watchdog->routine = routine;
518be: 2544 002c movel %d4,%a2@(44)
the_watchdog->id = id;
518c2: 2543 0030 movel %d3,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
518c6: 2542 001c movel %d2,%a2@(28)
(*timer_server->schedule_operation)( timer_server, the_timer );
518ca: 2f0a movel %a2,%sp@-
518cc: 2f0b movel %a3,%sp@-
518ce: 206b 0004 moveal %a3@(4),%a0
518d2: 4e90 jsr %a0@
_Thread_Enable_dispatch();
518d4: 4eb9 0005 4940 jsr 54940 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
518da: 4fef 000c lea %sp@(12),%sp
518de: 4280 clrl %d0
518e0: 6012 bras 518f4 <rtems_timer_server_fire_when+0xc8>
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
518e2: 700e moveq #14,%d0
518e4: 600e bras 518f4 <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
518e6: 700b moveq #11,%d0 <== NOT EXECUTED
518e8: 600a bras 518f4 <rtems_timer_server_fire_when+0xc8><== NOT EXECUTED
if ( !routine )
return RTEMS_INVALID_ADDRESS;
518ea: 7009 moveq #9,%d0
518ec: 6006 bras 518f4 <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
518ee: 7014 moveq #20,%d0
518f0: 6002 bras 518f4 <rtems_timer_server_fire_when+0xc8>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
518f2: 7004 moveq #4,%d0
}
518f4: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3
518fa: 4e5e unlk %fp
...
00042830 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
42830: 4e56 fff0 linkw %fp,#-16
42834: 48d7 041c moveml %d2-%d4/%a2,%sp@
42838: 242e 0008 movel %fp@(8),%d2
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
4283c: 0802 001d btst #29,%d2
42840: 6734 beqs 42876 <rtems_verror+0x46>
if (rtems_panic_in_progress++)
42842: 2039 0005 d6d4 movel 5d6d4 <rtems_panic_in_progress>,%d0
42848: 2200 movel %d0,%d1
4284a: 5281 addql #1,%d1
4284c: 23c1 0005 d6d4 movel %d1,5d6d4 <rtems_panic_in_progress>
42852: 4a80 tstl %d0
42854: 6714 beqs 4286a <rtems_verror+0x3a> <== ALWAYS TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
42856: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0<== NOT EXECUTED
4285c: 5280 addql #1,%d0 <== NOT EXECUTED
4285e: 23c0 0005 d828 movel %d0,5d828 <_Thread_Dispatch_disable_level><== NOT EXECUTED
return _Thread_Dispatch_disable_level;
42864: 2039 0005 d828 movel 5d828 <_Thread_Dispatch_disable_level>,%d0<== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
4286a: 7002 moveq #2,%d0
4286c: b0b9 0005 d6d4 cmpl 5d6d4 <rtems_panic_in_progress>,%d0
42872: 6d00 0100 bltw 42974 <rtems_verror+0x144>
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
42876: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
status = error_flag & ~RTEMS_ERROR_MASK;
4287c: 2802 movel %d2,%d4
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
4287e: 2f28 0008 movel %a0@(8),%sp@-
status = error_flag & ~RTEMS_ERROR_MASK;
42882: 0284 8fff ffff andil #-1879048193,%d4
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
42888: 4eb9 0004 c3c0 jsr 4c3c0 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
4288e: 588f addql #4,%sp
42890: 0802 001e btst #30,%d2
42894: 670c beqs 428a2 <rtems_verror+0x72>
local_errno = errno;
42896: 4eb9 0004 c034 jsr 4c034 <__errno>
4289c: 2040 moveal %d0,%a0
4289e: 2610 movel %a0@,%d3
428a0: 6002 bras 428a4 <rtems_verror+0x74>
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
428a2: 4283 clrl %d3
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
428a4: 2f2e 0010 movel %fp@(16),%sp@-
428a8: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
428ae: 2f2e 000c movel %fp@(12),%sp@-
428b2: 2f28 000c movel %a0@(12),%sp@-
428b6: 4eb9 0005 308c jsr 5308c <vfprintf>
if (status)
428bc: 4fef 000c lea %sp@(12),%sp
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
428c0: 2400 movel %d0,%d2
if (status)
428c2: 4a84 tstl %d4
428c4: 6726 beqs 428ec <rtems_verror+0xbc>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
428c6: 2f04 movel %d4,%sp@-
428c8: 4eb9 0004 2818 jsr 42818 <rtems_status_text>
428ce: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
428d4: 2f00 movel %d0,%sp@-
428d6: 4879 0005 ac9f pea 5ac9f <IMFS_ops+0x4f>
428dc: 2f28 000c movel %a0@(12),%sp@-
428e0: 4eb9 0004 c762 jsr 4c762 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
428e6: 4fef 0010 lea %sp@(16),%sp
428ea: d480 addl %d0,%d2
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
428ec: 4a83 tstl %d3
428ee: 6756 beqs 42946 <rtems_verror+0x116>
if ((local_errno > 0) && *strerror(local_errno))
428f0: 6f36 bles 42928 <rtems_verror+0xf8>
428f2: 2f03 movel %d3,%sp@-
428f4: 45f9 0004 d384 lea 4d384 <strerror>,%a2
428fa: 4e92 jsr %a2@
428fc: 588f addql #4,%sp
428fe: 2040 moveal %d0,%a0
42900: 4a10 tstb %a0@
42902: 6724 beqs 42928 <rtems_verror+0xf8> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
42904: 2f03 movel %d3,%sp@-
42906: 4e92 jsr %a2@
42908: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
4290e: 2f00 movel %d0,%sp@-
42910: 4879 0005 acad pea 5acad <IMFS_ops+0x5d>
42916: 2f28 000c movel %a0@(12),%sp@-
4291a: 4eb9 0004 c762 jsr 4c762 <fprintf>
42920: 4fef 0010 lea %sp@(16),%sp
42924: d480 addl %d0,%d2
42926: 601e bras 42946 <rtems_verror+0x116>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
42928: 2f03 movel %d3,%sp@-
4292a: 4879 0005 acba pea 5acba <IMFS_ops+0x6a>
42930: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
42936: 2f28 000c movel %a0@(12),%sp@-
4293a: 4eb9 0004 c762 jsr 4c762 <fprintf>
42940: 4fef 000c lea %sp@(12),%sp
42944: d480 addl %d0,%d2
}
chars_written += fprintf(stderr, "\n");
42946: 4879 0005 a8bf pea 5a8bf <rtems_filesystem_table+0x3d7>
4294c: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
42952: 2f28 000c movel %a0@(12),%sp@-
42956: 4eb9 0004 c762 jsr 4c762 <fprintf>
(void) fflush(stderr);
4295c: 2079 0005 c1b4 moveal 5c1b4 <_impure_ptr>,%a0
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
42962: d480 addl %d0,%d2
(void) fflush(stderr);
42964: 2f28 000c movel %a0@(12),%sp@-
42968: 4eb9 0004 c3c0 jsr 4c3c0 <fflush>
return chars_written;
4296e: 4fef 000c lea %sp@(12),%sp
42972: 6002 bras 42976 <rtems_verror+0x146>
if (rtems_panic_in_progress++)
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
42974: 4282 clrl %d2 <== NOT EXECUTED
chars_written += fprintf(stderr, "\n");
(void) fflush(stderr);
return chars_written;
}
42976: 2002 movel %d2,%d0
42978: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
4297e: 4e5e unlk %fp <== NOT EXECUTED
00042fe4 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
42fe4: 4e56 ffe4 linkw %fp,#-28
42fe8: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
42fec: 246e 0008 moveal %fp@(8),%a2
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
42ff0: 4283 clrl %d3
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
42ff2: 283c 7fff ffff movel #2147483647,%d4
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
42ff8: 4282 clrl %d2
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
42ffa: 47f9 0004 e778 lea 4e778 <__srget_r>,%a3
43000: 202a 0004 movel %a2@(4),%d0
43004: 5380 subql #1,%d0
43006: 2540 0004 movel %d0,%a2@(4)
4300a: 6c0e bges 4301a <scanInt+0x36> <== ALWAYS TAKEN
4300c: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4300e: 2f39 0005 d8c4 movel 5d8c4 <_impure_ptr>,%sp@- <== NOT EXECUTED
43014: 4e93 jsr %a3@ <== NOT EXECUTED
43016: 508f addql #8,%sp <== NOT EXECUTED
43018: 600a bras 43024 <scanInt+0x40> <== NOT EXECUTED
4301a: 2052 moveal %a2@,%a0
4301c: 4280 clrl %d0
4301e: 1010 moveb %a0@,%d0
43020: 5288 addql #1,%a0
43022: 2488 movel %a0,%a2@
if (c == ':')
43024: 723a moveq #58,%d1
43026: b280 cmpl %d0,%d1
43028: 6750 beqs 4307a <scanInt+0x96>
break;
if (sign == 0) {
4302a: 4a83 tstl %d3
4302c: 660e bnes 4303c <scanInt+0x58>
if (c == '-') {
4302e: 7c2d moveq #45,%d6
43030: bc80 cmpl %d0,%d6
43032: 6606 bnes 4303a <scanInt+0x56>
sign = -1;
limit++;
43034: 5284 addql #1,%d4
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
43036: 76ff moveq #-1,%d3
limit++;
continue;
43038: 60c6 bras 43000 <scanInt+0x1c>
}
sign = 1;
4303a: 7601 moveq #1,%d3
}
if (!isdigit(c))
4303c: 2079 0005 d8c0 moveal 5d8c0 <__ctype_ptr__>,%a0
43042: 1230 0801 moveb %a0@(00000001,%d0:l),%d1
43046: 49c1 extbl %d1
43048: 44c1 movew %d1,%ccr
4304a: 6640 bnes 4308c <scanInt+0xa8>
return 0;
d = c - '0';
if ((i > (limit / 10))
4304c: 2204 movel %d4,%d1
4304e: 7c0a moveq #10,%d6
43050: 4c46 1005 remul %d6,%d5,%d1
43054: 4c46 1001 remul %d6,%d1,%d1
43058: b282 cmpl %d2,%d1
4305a: 6530 bcss 4308c <scanInt+0xa8>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
4305c: 0680 ffff ffd0 addil #-48,%d0
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
43062: b282 cmpl %d2,%d1
43064: 6604 bnes 4306a <scanInt+0x86>
43066: ba80 cmpl %d0,%d5
43068: 6522 bcss 4308c <scanInt+0xa8> <== ALWAYS TAKEN
return 0;
i = i * 10 + d;
4306a: 2202 movel %d2,%d1
4306c: e789 lsll #3,%d1
4306e: 2241 moveal %d1,%a1
43070: 41f1 2a00 lea %a1@(00000000,%d2:l:2),%a0
43074: 2400 movel %d0,%d2
43076: d488 addl %a0,%d2
43078: 6086 bras 43000 <scanInt+0x1c>
}
if (sign == 0)
4307a: 4a83 tstl %d3
4307c: 670e beqs 4308c <scanInt+0xa8> <== NEVER TAKEN
return 0;
*val = i * sign;
4307e: 4c02 3800 mulsl %d2,%d3
return 1;
43082: 7001 moveq #1,%d0
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
43084: 206e 000c moveal %fp@(12),%a0
43088: 2083 movel %d3,%a0@
return 1;
4308a: 6002 bras 4308e <scanInt+0xaa>
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
4308c: 4280 clrl %d0
*val = i * sign;
return 1;
}
4308e: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3
43094: 4e5e unlk %fp <== NOT EXECUTED
00043126 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
43126: 4e56 ffe4 linkw %fp,#-28
4312a: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
4312e: 42a7 clrl %sp@-
43130: 280e movel %fp,%d4
43132: 0684 0000 0014 addil #20,%d4
43138: 260e movel %fp,%d3
4313a: 0683 0000 0010 addil #16,%d3
43140: 47fa ff56 lea %pc@(43098 <scanString>),%a3
43144: 2f04 movel %d4,%sp@-
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
43146: 246e 000c moveal %fp@(12),%a2
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
4314a: 2f03 movel %d3,%sp@-
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
4314c: 242e 0008 movel %fp@(8),%d2
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
43150: 2f0a movel %a2,%sp@-
43152: 2f02 movel %d2,%sp@-
43154: 4e93 jsr %a3@
43156: 4fef 0014 lea %sp@(20),%sp
4315a: 4a80 tstl %d0
4315c: 6700 00b6 beqw 43214 <scangr+0xee>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
43160: 42a7 clrl %sp@-
43162: 2f04 movel %d4,%sp@-
43164: 2f03 movel %d3,%sp@-
43166: 486a 0004 pea %a2@(4)
4316a: 2f02 movel %d2,%sp@-
4316c: 4e93 jsr %a3@
4316e: 4fef 0014 lea %sp@(20),%sp
43172: 4a80 tstl %d0
43174: 6700 009e beqw 43214 <scangr+0xee>
|| !scanInt(fp, &grgid)
43178: 486e fff8 pea %fp@(-8)
4317c: 2f02 movel %d2,%sp@-
4317e: 4eba fe64 jsr %pc@(42fe4 <scanInt>)
43182: 508f addql #8,%sp
43184: 4a80 tstl %d0
43186: 6700 008c beqw 43214 <scangr+0xee>
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
4318a: 4878 0001 pea 1 <ADD>
4318e: 2f04 movel %d4,%sp@-
43190: 2f03 movel %d3,%sp@-
43192: 486e fffc pea %fp@(-4)
43196: 2f02 movel %d2,%sp@-
43198: 4e93 jsr %a3@
4319a: 4fef 0014 lea %sp@(20),%sp
4319e: 4a80 tstl %d0
431a0: 6772 beqs 43214 <scangr+0xee> <== NEVER TAKEN
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431a2: 222e fffc movel %fp@(-4),%d1
431a6: 7001 moveq #1,%d0
431a8: 2041 moveal %d1,%a0
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
431aa: 356e fffa 0008 movew %fp@(-6),%a2@(8)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431b0: 600a bras 431bc <scangr+0x96>
if(*cp == ',')
431b2: 49c2 extbl %d2
431b4: 762c moveq #44,%d3
431b6: b682 cmpl %d2,%d3
431b8: 6602 bnes 431bc <scangr+0x96>
memcount++;
431ba: 5280 addql #1,%d0
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431bc: 1418 moveb %a0@+,%d2
431be: 66f2 bnes 431b2 <scangr+0x8c>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
431c0: e588 lsll #2,%d0
431c2: 0680 0000 0013 addil #19,%d0
431c8: b0ae 0014 cmpl %fp@(20),%d0
431cc: 6246 bhis 43214 <scangr+0xee> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
431ce: 202e 0010 movel %fp@(16),%d0
431d2: 74f0 moveq #-16,%d2
431d4: 0680 0000 000f addil #15,%d0
431da: c082 andl %d2,%d0
431dc: 2540 000a movel %d0,%a2@(10)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
431e0: 2040 moveal %d0,%a0
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431e2: 7001 moveq #1,%d0
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
431e4: 2081 movel %d1,%a0@
431e6: 206e fffc moveal %fp@(-4),%a0
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
431ea: 6018 bras 43204 <scangr+0xde>
if(*cp == ',') {
431ec: 49c1 extbl %d1
431ee: 742c moveq #44,%d2
431f0: b481 cmpl %d1,%d2
431f2: 6610 bnes 43204 <scangr+0xde>
*cp = '\0';
431f4: 4203 clrb %d3
431f6: 1143 ffff moveb %d3,%a0@(-1)
grp->gr_mem[memcount++] = cp + 1;
431fa: 226a 000a moveal %a2@(10),%a1
431fe: 2388 0c00 movel %a0,%a1@(00000000,%d0:l:4)
43202: 5280 addql #1,%d0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
43204: 1218 moveb %a0@+,%d1
43206: 66e4 bnes 431ec <scangr+0xc6>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
43208: 206a 000a moveal %a2@(10),%a0
4320c: 42b0 0c00 clrl %a0@(00000000,%d0:l:4)
return 1;
43210: 7001 moveq #1,%d0
43212: 6002 bras 43216 <scangr+0xf0>
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
43214: 4280 clrl %d0
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
43216: 4cee 0c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a3
4321c: 4e5e unlk %fp <== NOT EXECUTED
00043220 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
43220: 4e56 ffe0 linkw %fp,#-32
43224: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
43228: 42a7 clrl %sp@-
4322a: 280e movel %fp,%d4
4322c: 0684 0000 0014 addil #20,%d4
43232: 260e movel %fp,%d3
43234: 0683 0000 0010 addil #16,%d3
4323a: 47fa fe5c lea %pc@(43098 <scanString>),%a3
4323e: 2f04 movel %d4,%sp@-
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
43240: 246e 000c moveal %fp@(12),%a2
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
43244: 2f03 movel %d3,%sp@-
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
43246: 242e 0008 movel %fp@(8),%d2
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
4324a: 2f0a movel %a2,%sp@-
4324c: 2f02 movel %d2,%sp@-
4324e: 4e93 jsr %a3@
43250: 4fef 0014 lea %sp@(20),%sp
43254: 4a80 tstl %d0
43256: 6700 00a4 beqw 432fc <scanpw+0xdc>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
4325a: 42a7 clrl %sp@-
4325c: 2f04 movel %d4,%sp@-
4325e: 2f03 movel %d3,%sp@-
43260: 486a 0004 pea %a2@(4)
43264: 2f02 movel %d2,%sp@-
43266: 4e93 jsr %a3@
43268: 4fef 0014 lea %sp@(20),%sp
4326c: 4a80 tstl %d0
4326e: 6700 008c beqw 432fc <scanpw+0xdc>
|| !scanInt(fp, &pwuid)
43272: 486e fff8 pea %fp@(-8)
43276: 49fa fd6c lea %pc@(42fe4 <scanInt>),%a4
4327a: 2f02 movel %d2,%sp@-
4327c: 4e94 jsr %a4@
4327e: 508f addql #8,%sp
43280: 4a80 tstl %d0
43282: 6778 beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanInt(fp, &pwgid)
43284: 486e fffc pea %fp@(-4)
43288: 2f02 movel %d2,%sp@-
4328a: 4e94 jsr %a4@
4328c: 508f addql #8,%sp
4328e: 4a80 tstl %d0
43290: 676a beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
43292: 42a7 clrl %sp@-
43294: 2f04 movel %d4,%sp@-
43296: 2f03 movel %d3,%sp@-
43298: 486a 000c pea %a2@(12)
4329c: 2f02 movel %d2,%sp@-
4329e: 4e93 jsr %a3@
432a0: 4fef 0014 lea %sp@(20),%sp
432a4: 4a80 tstl %d0
432a6: 6754 beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
432a8: 42a7 clrl %sp@-
432aa: 2f04 movel %d4,%sp@-
432ac: 2f03 movel %d3,%sp@-
432ae: 486a 0010 pea %a2@(16)
432b2: 2f02 movel %d2,%sp@-
432b4: 4e93 jsr %a3@
432b6: 4fef 0014 lea %sp@(20),%sp
432ba: 4a80 tstl %d0
432bc: 673e beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
432be: 42a7 clrl %sp@-
432c0: 2f04 movel %d4,%sp@-
432c2: 2f03 movel %d3,%sp@-
432c4: 486a 0014 pea %a2@(20)
432c8: 2f02 movel %d2,%sp@-
432ca: 4e93 jsr %a3@
432cc: 4fef 0014 lea %sp@(20),%sp
432d0: 4a80 tstl %d0
432d2: 6728 beqs 432fc <scanpw+0xdc> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
432d4: 4878 0001 pea 1 <ADD>
432d8: 2f04 movel %d4,%sp@-
432da: 2f03 movel %d3,%sp@-
432dc: 486a 0018 pea %a2@(24)
432e0: 2f02 movel %d2,%sp@-
432e2: 4e93 jsr %a3@
432e4: 4fef 0014 lea %sp@(20),%sp
432e8: 4a80 tstl %d0
432ea: 6710 beqs 432fc <scanpw+0xdc>
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
432ec: 7001 moveq #1,%d0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
432ee: 356e fffa 0008 movew %fp@(-6),%a2@(8)
pwd->pw_gid = pwgid;
432f4: 356e fffe 000a movew %fp@(-2),%a2@(10)
return 1;
432fa: 6002 bras 432fe <scanpw+0xde>
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
432fc: 4280 clrl %d0
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
432fe: 4cee 1c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a4
43304: 4e5e unlk %fp <== NOT EXECUTED
000447e2 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
447e2: 4e56 0000 linkw %fp,#0
447e6: 2f0a movel %a2,%sp@-
447e8: 246e 000c moveal %fp@(12),%a2
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
447ec: 202a 003c movel %a2@(60),%d0
447f0: 0280 0000 0e78 andil #3704,%d0
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
447f6: 2f02 movel %d2,%sp@-
447f8: 142e 000b moveb %fp@(11),%d2
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
447fc: 4a80 tstl %d0
447fe: 673a beqs 4483a <siproc+0x58> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44800: 42a7 clrl %sp@-
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
}
}
}
44802: 0282 0000 00ff andil #255,%d2
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
44808: 42a7 clrl %sp@-
4480a: 2f2a 0018 movel %a2@(24),%sp@-
4480e: 4eb9 0004 59e0 jsr 459e0 <rtems_semaphore_obtain>
i = iproc (c, tty);
44814: 2f0a movel %a2,%sp@-
44816: 2f02 movel %d2,%sp@-
44818: 4eba fe60 jsr %pc@(4467a <iproc>)
rtems_semaphore_release (tty->osem);
4481c: 2f2a 0018 movel %a2@(24),%sp@-
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
44820: 2400 movel %d0,%d2
rtems_semaphore_release (tty->osem);
44822: 4eb9 0004 5aec jsr 45aec <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
44828: 246e fffc moveal %fp@(-4),%a2
4482c: 2002 movel %d2,%d0
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
4482e: 4fef 0018 lea %sp@(24),%sp
}
else {
i = iproc (c, tty);
}
return i;
}
44832: 242e fff8 movel %fp@(-8),%d2
44836: 4e5e unlk %fp
44838: 4e75 rts
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
4483a: 2d4a 000c movel %a2,%fp@(12) <== NOT EXECUTED
}
return i;
}
4483e: 246e fffc moveal %fp@(-4),%a2 <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
44842: 0282 0000 00ff andil #255,%d2 <== NOT EXECUTED
44848: 2d42 0008 movel %d2,%fp@(8) <== NOT EXECUTED
}
return i;
}
4484c: 242e fff8 movel %fp@(-8),%d2 <== NOT EXECUTED
44850: 4e5e unlk %fp <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
44852: 6000 fe26 braw 4467a <iproc> <== NOT EXECUTED
000459f8 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
459f8: 4e56 ffdc linkw %fp,#-36
459fc: 48d7 040c moveml %d2-%d3/%a2,%sp@
45a00: 246e 0008 moveal %fp@(8),%a2
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
45a04: 240e movel %fp,%d2
45a06: 0682 ffff ffec addil #-20,%d2
45a0c: 2f0a movel %a2,%sp@-
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
45a0e: 262e 000c movel %fp@(12),%d3
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
45a12: 4eb9 0005 02d8 jsr 502d8 <strlen>
45a18: 7201 moveq #1,%d1
45a1a: 2e81 movel %d1,%sp@
45a1c: 2f02 movel %d2,%sp@-
45a1e: 42a7 clrl %sp@-
45a20: 2f00 movel %d0,%sp@-
45a22: 2f0a movel %a2,%sp@-
45a24: 4eb9 0004 4738 jsr 44738 <rtems_filesystem_evaluate_path>
45a2a: 4fef 0014 lea %sp@(20),%sp
45a2e: 4a80 tstl %d0
45a30: 6638 bnes 45a6a <statvfs+0x72> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
45a32: 4878 0038 pea 38 <DBL_MANT_DIG+0x3>
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
45a36: 246e fffc moveal %fp@(-4),%a2
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
45a3a: 42a7 clrl %sp@-
45a3c: 2f03 movel %d3,%sp@-
45a3e: 4eb9 0004 f0dc jsr 4f0dc <memset>
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
45a44: 206a 0028 moveal %a2@(40),%a0
45a48: 2f03 movel %d3,%sp@-
45a4a: 486a 001c pea %a2@(28)
45a4e: 2068 0044 moveal %a0@(68),%a0
45a52: 4e90 jsr %a0@
rtems_filesystem_freenode( &loc );
45a54: 2f02 movel %d2,%sp@-
45a56: 2d40 ffe8 movel %d0,%fp@(-24)
45a5a: 4eb9 0004 4804 jsr 44804 <rtems_filesystem_freenode>
return result;
45a60: 202e ffe8 movel %fp@(-24),%d0
45a64: 4fef 0018 lea %sp@(24),%sp
45a68: 6002 bras 45a6c <statvfs+0x74>
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
45a6a: 70ff moveq #-1,%d0 <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
rtems_filesystem_freenode( &loc );
return result;
}
45a6c: 4cee 040c ffdc moveml %fp@(-36),%d2-%d3/%a2
45a72: 4e5e unlk %fp
...
00044810 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
44810: 4e56 0000 linkw %fp,#0
44814: 206e 0008 moveal %fp@(8),%a0
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
44818: 2028 00f8 movel %a0@(248),%d0
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
4481c: 2f02 movel %d2,%sp@-
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
4481e: 4a80 tstl %d0
44820: 6728 beqs 4484a <sync_per_thread+0x3a> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
44822: 2279 0005 f1ec moveal 5f1ec <_Per_CPU_Information+0xc>,%a1
44828: 2429 00f8 movel %a1@(248),%d2
_Thread_Executing->libc_reent = this_reent;
4482c: 2340 00f8 movel %d0,%a1@(248)
_fwalk (t->libc_reent, sync_wrapper);
44830: 487a 0020 pea %pc@(44852 <sync_wrapper>)
44834: 2f28 00f8 movel %a0@(248),%sp@-
44838: 4eb9 0004 dc54 jsr 4dc54 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
4483e: 2079 0005 f1ec moveal 5f1ec <_Per_CPU_Information+0xc>,%a0
44844: 508f addql #8,%sp
44846: 2142 00f8 movel %d2,%a0@(248)
}
}
4484a: 242e fffc movel %fp@(-4),%d2
4484e: 4e5e unlk %fp <== NOT EXECUTED
0004ad64 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
4ad64: 4e56 0000 linkw %fp,#0
4ad68: 202e 000c movel %fp@(12),%d0
4ad6c: 2f03 movel %d3,%sp@-
4ad6e: 262e 0010 movel %fp@(16),%d3
4ad72: 2f02 movel %d2,%sp@-
4ad74: 242e 0008 movel %fp@(8),%d2
switch (opt) {
4ad78: 4a80 tstl %d0
4ad7a: 672c beqs 4ada8 <tcsetattr+0x44>
4ad7c: 7201 moveq #1,%d1
4ad7e: b280 cmpl %d0,%d1
4ad80: 6710 beqs 4ad92 <tcsetattr+0x2e>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
4ad82: 4eb9 0004 d690 jsr 4d690 <__errno>
4ad88: 2040 moveal %d0,%a0
4ad8a: 20bc 0000 0086 movel #134,%a0@
4ad90: 6034 bras 4adc6 <tcsetattr+0x62>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
4ad92: 42a7 clrl %sp@-
4ad94: 4878 0003 pea 3 <DIVIDE>
4ad98: 2f02 movel %d2,%sp@-
4ad9a: 4eb9 0004 aa64 jsr 4aa64 <ioctl>
4ada0: 4fef 000c lea %sp@(12),%sp
4ada4: 4a80 tstl %d0
4ada6: 6d1e blts 4adc6 <tcsetattr+0x62> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4ada8: 2d43 0010 movel %d3,%fp@(16)
4adac: 7002 moveq #2,%d0
4adae: 2d42 0008 movel %d2,%fp@(8)
}
}
4adb2: 242e fff8 movel %fp@(-8),%d2
4adb6: 262e fffc movel %fp@(-4),%d3
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4adba: 2d40 000c movel %d0,%fp@(12)
}
}
4adbe: 4e5e unlk %fp
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
4adc0: 4ef9 0004 aa64 jmp 4aa64 <ioctl>
}
}
4adc6: 242e fff8 movel %fp@(-8),%d2
4adca: 70ff moveq #-1,%d0
4adcc: 262e fffc movel %fp@(-4),%d3
4add0: 4e5e unlk %fp <== NOT EXECUTED
000484ac <unmount>:
*/
int unmount(
const char *path
)
{
484ac: 4e56 ffe0 linkw %fp,#-32
484b0: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
484b4: 246e 0008 moveal %fp@(8),%a2
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
484b8: 7401 moveq #1,%d2
484ba: 2f0a movel %a2,%sp@-
484bc: 4eb9 0005 95bc jsr 595bc <strlen>
484c2: 2e82 movel %d2,%sp@
484c4: 240e movel %fp,%d2
484c6: 0682 ffff ffec addil #-20,%d2
484cc: 2f02 movel %d2,%sp@-
484ce: 42a7 clrl %sp@-
484d0: 2f00 movel %d0,%sp@-
484d2: 2f0a movel %a2,%sp@-
484d4: 4eb9 0004 52f0 jsr 452f0 <rtems_filesystem_evaluate_path>
484da: 4fef 0014 lea %sp@(20),%sp
484de: 4a80 tstl %d0
484e0: 6600 00e8 bnew 485ca <unmount+0x11e>
return -1;
mt_entry = loc.mt_entry;
484e4: 246e fffc moveal %fp@(-4),%a2
484e8: 47f9 0004 54bc lea 454bc <rtems_filesystem_freenode>,%a3
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
484ee: 202e ffec movel %fp@(-20),%d0
484f2: b0aa 001c cmpl %a2@(28),%d0
484f6: 6716 beqs 4850e <unmount+0x62>
rtems_filesystem_freenode( &loc );
484f8: 2f02 movel %d2,%sp@-
484fa: 4e93 jsr %a3@
rtems_set_errno_and_return_minus_one( EACCES );
484fc: 4eb9 0005 7e64 jsr 57e64 <__errno>
48502: 588f addql #4,%sp
48504: 720d moveq #13,%d1
48506: 2040 moveal %d0,%a0
48508: 2081 movel %d1,%a0@
4850a: 6000 00be braw 485ca <unmount+0x11e>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
4850e: 2f02 movel %d2,%sp@-
48510: 4e93 jsr %a3@
* that made the current node thread based instead
* of system based? I thought it was but it doesn't
* look like it in this version.
*/
if ( rtems_filesystem_current.mt_entry == mt_entry )
48512: 2079 0006 8950 moveal 68950 <rtems_current_user_env>,%a0
48518: 588f addql #4,%sp
4851a: b5e8 0014 cmpal %a0@(20),%a2
4851e: 6724 beqs 48544 <unmount+0x98>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
48520: 2f2a 002c movel %a2@(44),%sp@-
48524: 487a ff6e pea %pc@(48494 <is_fs_below_mount_point>)
48528: 4eb9 0004 5cb4 jsr 45cb4 <rtems_filesystem_mount_iterate>
4852e: 508f addql #8,%sp
48530: 4a00 tstb %d0
48532: 6610 bnes 48544 <unmount+0x98>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
48534: 2f0a movel %a2,%sp@-
48536: 4eb9 0004 5808 jsr 45808 <rtems_libio_is_open_files_in_fs>
4853c: 588f addql #4,%sp
4853e: 7201 moveq #1,%d1
48540: b280 cmpl %d0,%d1
48542: 660e bnes 48552 <unmount+0xa6>
rtems_set_errno_and_return_minus_one( EBUSY );
48544: 4eb9 0005 7e64 jsr 57e64 <__errno>
4854a: 2040 moveal %d0,%a0
4854c: 7010 moveq #16,%d0
4854e: 2080 movel %d0,%a0@
48550: 6078 bras 485ca <unmount+0x11e>
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
48552: 206a 0014 moveal %a2@(20),%a0
48556: 2f0a movel %a2,%sp@-
48558: 2068 0028 moveal %a0@(40),%a0
4855c: 4e90 jsr %a0@
4855e: 588f addql #4,%sp
48560: 4a80 tstl %d0
48562: 6666 bnes 485ca <unmount+0x11e> <== NEVER TAKEN
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
48564: 206a 0028 moveal %a2@(40),%a0
48568: 2f0a movel %a2,%sp@-
4856a: 2068 002c moveal %a0@(44),%a0
4856e: 4e90 jsr %a0@
48570: 588f addql #4,%sp
48572: 4a80 tstl %d0
48574: 671a beqs 48590 <unmount+0xe4> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
48576: 206a 0014 moveal %a2@(20),%a0 <== NOT EXECUTED
4857a: 2f0a movel %a2,%sp@- <== NOT EXECUTED
4857c: 2068 0020 moveal %a0@(32),%a0 <== NOT EXECUTED
48580: 4e90 jsr %a0@ <== NOT EXECUTED
48582: 588f addql #4,%sp <== NOT EXECUTED
48584: 4a80 tstl %d0 <== NOT EXECUTED
48586: 6742 beqs 485ca <unmount+0x11e> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
48588: 42a7 clrl %sp@- <== NOT EXECUTED
4858a: 4eb9 0004 9690 jsr 49690 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
48590: 42a7 clrl %sp@-
48592: 42a7 clrl %sp@-
48594: 2f39 0006 a014 movel 6a014 <rtems_libio_semaphore>,%sp@-
4859a: 4eb9 0004 8f10 jsr 48f10 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
485a0: 2f0a movel %a2,%sp@-
485a2: 4eb9 0004 99e4 jsr 499e4 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
485a8: 2f39 0006 a014 movel 6a014 <rtems_libio_semaphore>,%sp@-
485ae: 4eb9 0004 901c jsr 4901c <rtems_semaphore_release>
/*
* Free the memory node that was allocated in mount
* Free the memory associated with the extracted mount table entry.
*/
rtems_filesystem_freenode( fs_mount_loc );
485b4: 486a 0008 pea %a2@(8)
485b8: 4e93 jsr %a3@
free( mt_entry );
485ba: 2f0a movel %a2,%sp@-
485bc: 4eb9 0004 54d0 jsr 454d0 <free>
return 0;
485c2: 4fef 001c lea %sp@(28),%sp
485c6: 4280 clrl %d0
485c8: 6002 bras 485cc <unmount+0x120>
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
rtems_fatal_error_occurred( 0 );
return -1;
485ca: 70ff moveq #-1,%d0
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
485cc: 4cee 0c04 ffe0 moveml %fp@(-32),%d2/%a2-%a3
485d2: 4e5e unlk %fp
...
00059e74 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
59e74: 4e56 fff4 linkw %fp,#-12
59e78: 202e 0008 movel %fp@(8),%d0
59e7c: 222e 000c movel %fp@(12),%d1
59e80: 206e 0010 moveal %fp@(16),%a0
59e84: 48d7 040c moveml %d2-%d3/%a2,%sp@
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
59e88: b0b9 0005 bff2 cmpl 5bff2 <rtems_libio_number_iops>,%d0
59e8e: 6434 bccs 59ec4 <write+0x50>
iop = rtems_libio_iop( fd );
59e90: 2400 movel %d0,%d2
59e92: ed88 lsll #6,%d0
59e94: e78a lsll #3,%d2
59e96: 2479 0005 d6d8 moveal 5d6d8 <rtems_libio_iops>,%a2
59e9c: 9082 subl %d2,%d0
59e9e: d5c0 addal %d0,%a2
rtems_libio_check_is_open( iop );
59ea0: 202a 0014 movel %a2@(20),%d0
59ea4: 0800 0008 btst #8,%d0
59ea8: 671a beqs 59ec4 <write+0x50>
rtems_libio_check_buffer( buffer );
59eaa: 4a81 tstl %d1
59eac: 660e bnes 59ebc <write+0x48> <== ALWAYS TAKEN
59eae: 4eb9 0004 c034 jsr 4c034 <__errno> <== NOT EXECUTED
59eb4: 7216 moveq #22,%d1 <== NOT EXECUTED
59eb6: 2040 moveal %d0,%a0 <== NOT EXECUTED
59eb8: 2081 movel %d1,%a0@ <== NOT EXECUTED
59eba: 6014 bras 59ed0 <write+0x5c> <== NOT EXECUTED
rtems_libio_check_count( count );
59ebc: 4a88 tstl %a0
59ebe: 6742 beqs 59f02 <write+0x8e>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
59ec0: 44c0 movew %d0,%ccr
59ec2: 6710 beqs 59ed4 <write+0x60>
59ec4: 4eb9 0004 c034 jsr 4c034 <__errno>
59eca: 2040 moveal %d0,%a0
59ecc: 7009 moveq #9,%d0
59ece: 2080 movel %d0,%a0@
59ed0: 70ff moveq #-1,%d0
59ed2: 6030 bras 59f04 <write+0x90>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
59ed4: 226a 0020 moveal %a2@(32),%a1
59ed8: 2f08 movel %a0,%sp@-
59eda: 2f01 movel %d1,%sp@-
59edc: 2f0a movel %a2,%sp@-
59ede: 2069 000c moveal %a1@(12),%a0
59ee2: 4e90 jsr %a0@
if ( rc > 0 )
59ee4: 4fef 000c lea %sp@(12),%sp
59ee8: 4a80 tstl %d0
59eea: 6f18 bles 59f04 <write+0x90>
iop->offset += rc;
59eec: 2600 movel %d0,%d3
59eee: 5bc2 smi %d2
59ef0: 49c2 extbl %d2
59ef2: d7aa 0010 addl %d3,%a2@(16)
59ef6: 222a 000c movel %a2@(12),%d1
59efa: d382 addxl %d2,%d1
59efc: 2541 000c movel %d1,%a2@(12)
59f00: 6002 bras 59f04 <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 );
59f02: 4280 clrl %d0
if ( rc > 0 )
iop->offset += rc;
return rc;
}
59f04: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2
59f0a: 4e5e unlk %fp
...
0004614c <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
4614c: 4e56 ffe4 linkw %fp,#-28
46150: 202e 0008 movel %fp@(8),%d0
46154: 48d7 0cdc moveml %d2-%d4/%d6-%d7/%a2-%a3,%sp@
46158: 246e 000c moveal %fp@(12),%a2
4615c: 262e 0010 movel %fp@(16),%d3
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
46160: b0b9 0005 c7f2 cmpl 5c7f2 <rtems_libio_number_iops>,%d0
46166: 641e bccs 46186 <writev+0x3a>
iop = rtems_libio_iop( fd );
46168: 2200 movel %d0,%d1
4616a: ed88 lsll #6,%d0
4616c: e789 lsll #3,%d1
4616e: 2679 0005 ded8 moveal 5ded8 <rtems_libio_iops>,%a3
46174: 9081 subl %d1,%d0
46176: d7c0 addal %d0,%a3
rtems_libio_check_is_open( iop );
46178: 202b 0014 movel %a3@(20),%d0
4617c: 0800 0008 btst #8,%d0
46180: 6704 beqs 46186 <writev+0x3a>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
46182: 44c0 movew %d0,%ccr
46184: 6710 beqs 46196 <writev+0x4a> <== ALWAYS TAKEN
46186: 4eb9 0004 caa4 jsr 4caa4 <__errno>
4618c: 7209 moveq #9,%d1
4618e: 2040 moveal %d0,%a0
46190: 2081 movel %d1,%a0@
46192: 6000 0098 braw 4622c <writev+0xe0>
/*
* Argument validation on IO vector
*/
if ( !iov )
46196: 4a8a tstl %a2
46198: 672a beqs 461c4 <writev+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
4619a: 4a83 tstl %d3
4619c: 6f26 bles 461c4 <writev+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
4619e: 0c83 0000 0400 cmpil #1024,%d3
461a4: 6e1e bgts 461c4 <writev+0x78> <== NEVER TAKEN
461a6: 204a moveal %a2,%a0
461a8: 93c9 subal %a1,%a1
461aa: 4281 clrl %d1
461ac: 7001 moveq #1,%d0
461ae: 6002 bras 461b2 <writev+0x66>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
461b0: 2202 movel %d2,%d1
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
461b2: 4a90 tstl %a0@
461b4: 670e beqs 461c4 <writev+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
461b6: 2428 0004 movel %a0@(4),%d2
all_zeros = false;
461ba: 57c4 seq %d4
/* check for wrap */
old = total;
total += iov[v].iov_len;
461bc: d481 addl %d1,%d2
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
461be: c084 andl %d4,%d0
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
461c0: b282 cmpl %d2,%d1
461c2: 6f0e bles 461d2 <writev+0x86>
rtems_set_errno_and_return_minus_one( EINVAL );
461c4: 4eb9 0004 caa4 jsr 4caa4 <__errno>
461ca: 2040 moveal %d0,%a0
461cc: 7016 moveq #22,%d0
461ce: 2080 movel %d0,%a0@
461d0: 605a bras 4622c <writev+0xe0>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
461d2: 5289 addql #1,%a1
461d4: 5088 addql #8,%a0
461d6: b689 cmpl %a1,%d3
461d8: 66d6 bnes 461b0 <writev+0x64>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
461da: 4a00 tstb %d0
461dc: 664a bnes 46228 <writev+0xdc> <== NEVER TAKEN
461de: 4284 clrl %d4
461e0: 4282 clrl %d2
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
461e2: 202a 0004 movel %a2@(4),%d0
461e6: 6736 beqs 4621e <writev+0xd2> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
461e8: 206b 0020 moveal %a3@(32),%a0
461ec: 2f00 movel %d0,%sp@-
461ee: 2f12 movel %a2@,%sp@-
461f0: 2f0b movel %a3,%sp@-
461f2: 2068 000c moveal %a0@(12),%a0
461f6: 4e90 jsr %a0@
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
461f8: 4fef 000c lea %sp@(12),%sp
461fc: 4a80 tstl %d0
461fe: 6d2c blts 4622c <writev+0xe0> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
46200: 6716 beqs 46218 <writev+0xcc> <== NEVER TAKEN
iop->offset += bytes;
total += bytes;
46202: d480 addl %d0,%d2
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
46204: 2e00 movel %d0,%d7
46206: 5bc6 smi %d6
46208: 49c6 extbl %d6
4620a: dfab 0010 addl %d7,%a3@(16)
4620e: 222b 000c movel %a3@(12),%d1
46212: d386 addxl %d6,%d1
46214: 2741 000c movel %d1,%a3@(12)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
46218: b0aa 0004 cmpl %a2@(4),%d0
4621c: 6610 bnes 4622e <writev+0xe2> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
4621e: 5284 addql #1,%d4
46220: 508a addql #8,%a2
46222: b684 cmpl %d4,%d3
46224: 66bc bnes 461e2 <writev+0x96> <== NEVER TAKEN
46226: 6006 bras 4622e <writev+0xe2>
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
46228: 4282 clrl %d2
4622a: 6002 bras 4622e <writev+0xe2>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
4622c: 74ff moveq #-1,%d2
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
4622e: 2002 movel %d2,%d0
46230: 4cee 0cdc ffe4 moveml %fp@(-28),%d2-%d4/%d6-%d7/%a2-%a3
46236: 4e5e unlk %fp
...