void
del_ramdisk (void)
{
int rc = 0;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rc = rtems_disk_delete (dev);
rtems_test_assert (rc == 0);
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_test_assert (major >= 0);
rtems_test_assert (minor >= 0);
rc = rtems_io_unregister_driver (major);
rtems_test_assert (rc == 0);
rc = rtems_disk_io_done ();
rtems_test_assert (rc == 0);
}
static int pty_do_finalize(void)
{
int ndx;
rtems_status_code status;
if ( !telnet_pty_inited )
return 0;
for (ndx=0;ndx<rtems_telnetd_maximum_ptys;ndx++) {
if (telnet_ptys[ndx].opened) {
fprintf(stderr,
"There are still opened PTY devices, unable to proceed\n");
return -1;
}
}
if (RTEMS_SUCCESSFUL != rtems_io_unregister_driver(pty_major)) {
fprintf(stderr,"Unable to remove this driver\n");
return -1;
}
for (ndx=0;ndx<rtems_telnetd_maximum_ptys;ndx++) {
/* rtems_io_register_name() actually creates a node in the filesystem
* (mknod())
*/
status = (rtems_status_code)unlink(telnet_ptys[ndx].devname);
if (status != RTEMS_SUCCESSFUL)
perror("removing pty device node from file system");
else
free(telnet_ptys[ndx].devname);
};
free ( telnet_ptys );
fprintf(stderr,"PTY driver unloaded successfully\n");
telnet_pty_inited=FALSE;
return 0;
}
static void test_diskdevs(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_disk_device *physical_dd = NULL;
rtems_disk_device *logical_dd = NULL;
rtems_disk_device *dd = NULL;
dev_t physical_dev = 0;
dev_t logical_dev = 0;
dev_t logical_2_dev = 0;
dev_t const big_major_dev = rtems_filesystem_make_dev_t((rtems_device_major_number) -2, 0);
dev_t const big_minor_dev = rtems_filesystem_make_dev_t(0, (rtems_device_minor_number) -2);
ramdisk *const rd = ramdisk_allocate(NULL, BLOCK_SIZE, BLOCK_COUNT, false);
rtems_test_assert(rd != NULL);
sc = rtems_disk_io_initialize();
ASSERT_SC(sc);
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
ASSERT_SC(sc);
physical_dev = rtems_filesystem_make_dev_t(major, minor);
logical_dev = rtems_filesystem_make_dev_t(major, minor + 1);
logical_2_dev = rtems_filesystem_make_dev_t(major, minor + 2);
/* Consistency checks for physical disks creation */
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, NULL, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_INVALID_ADDRESS);
sc = rtems_disk_create_phys(physical_dev, 0, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
sc = rtems_disk_create_phys(big_major_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
sc = rtems_disk_create_phys(big_minor_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, NULL);
ASSERT_SC(sc);
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, NULL);
ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
sc = rtems_disk_delete(physical_dev);
ASSERT_SC(sc);
/* Consistency checks for logical disks creation */
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_ID);
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC(sc);
sc = rtems_disk_create_log(big_major_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
sc = rtems_disk_create_log(big_minor_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
sc = rtems_disk_create_log(logical_dev, physical_dev, BLOCK_COUNT, 0, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, BLOCK_COUNT + 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
sc = rtems_disk_create_log(logical_dev, physical_dev, 1, BLOCK_COUNT, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC(sc);
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
sc = rtems_disk_create_log(logical_2_dev, logical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_ID);
sc = rtems_disk_delete(logical_dev);
ASSERT_SC(sc);
/* Consistency checks delete */
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC(sc);
physical_dd = rtems_disk_obtain(physical_dev);
rtems_test_assert(physical_dd != NULL && physical_dd->uses == 2);
sc = rtems_disk_release(physical_dd);
ASSERT_SC(sc);
logical_dd = rtems_disk_obtain(logical_dev);
rtems_test_assert(logical_dd != NULL && logical_dd->uses == 1);
sc = rtems_disk_delete(physical_dev);
ASSERT_SC(sc);
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
dd = rtems_disk_obtain(physical_dev);
rtems_test_assert(dd == NULL);
dd = rtems_disk_obtain(logical_dev);
rtems_test_assert(dd == NULL);
sc = rtems_disk_release(logical_dd);
ASSERT_SC(sc);
/* Cleanup */
sc = rtems_io_unregister_driver(major);
ASSERT_SC(sc);
ramdisk_free(rd);
sc = rtems_disk_io_done();
ASSERT_SC(sc);
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code sc;
rtems_device_major_number registered;
rtems_device_major_number registered_not;
rtems_device_major_number invalid_major = _IO_Number_of_drivers + 1;
rtems_interrupt_level level;
bool do_interrupt_context_test = true;
TEST_BEGIN();
/* Ensure that this test works as expected */
test_interrupt_context_enter( level );
do_interrupt_context_test = rtems_interrupt_is_in_progress();
test_interrupt_context_leave( level );
/*
* Register a driver with init == NULL and open != NULL
*/
puts( "Init - rtems_io_register_driver - init == NULL, open != NULL OK" );
sc = rtems_io_register_driver( 0, &test_driver, ®istered );
printf( "Init - Major slot returned = %d\n", (int) registered );
directive_failed( sc, "rtems_io_register_driver" );
puts( "Init - rtems_io_register_driver - init == NULL, open != NULL OK" );
sc = rtems_io_register_driver( 0, &test_driver, ®istered_not );
printf( "Init - Major slot returned = %d\n", (int) registered_not );
fatal_directive_status(
sc,
RTEMS_TOO_MANY,
"rtems_io_register_driver too many"
);
puts( "Init - rtems_io_register_driver - used slot" );
sc = rtems_io_register_driver( registered, &test_driver, ®istered_not );
fatal_directive_status(
sc,
RTEMS_RESOURCE_IN_USE,
"rtems_io_register_driver slot in use"
);
puts( "Init - rtems_io_unregister_driver - used slot" );
sc = rtems_io_unregister_driver( registered );
directive_failed( sc, "rtems_io_unregister_driver" );
puts( "Init - rtems_io_register_driver - free slot" );
sc = rtems_io_register_driver( registered, &test_driver, ®istered );
directive_failed( sc, "rtems_io_register_driver" );
puts( "Init - rtems_io_register_driver - called from interrupt context" );
if ( do_interrupt_context_test ) {
test_interrupt_context_enter( level );
sc = rtems_io_register_driver( 0, NULL, NULL );
test_interrupt_context_leave( level );
fatal_directive_status(
sc,
RTEMS_CALLED_FROM_ISR,
"rtems_io_register_driver"
);
}
puts( "Init - rtems_io_register_driver - invalid registered major pointer" );
sc = rtems_io_register_driver( 0, NULL, NULL );
fatal_directive_status(
sc,
RTEMS_INVALID_ADDRESS,
"rtems_io_register_driver"
);
puts( "Init - rtems_io_register_driver - invalid driver table pointer" );
sc = rtems_io_register_driver( 0, NULL, ®istered );
fatal_directive_status(
sc,
RTEMS_INVALID_ADDRESS,
"rtems_io_register_driver"
);
puts( "Init - rtems_io_register_driver - invalid empty driver table" );
test_driver.open_entry = NULL;
sc = rtems_io_register_driver( 0, &test_driver, ®istered );
test_driver.open_entry = test_open;
fatal_directive_status(
sc,
RTEMS_INVALID_ADDRESS,
"rtems_io_register_driver"
);
puts( "Init - rtems_io_register_driver - invalid major" );
sc = rtems_io_register_driver( invalid_major, &test_driver, ®istered );
fatal_directive_status(
sc,
RTEMS_INVALID_NUMBER,
"rtems_io_register_driver"
);
puts( "Init - rtems_io_unregister_driver - called from interrupt context" );
if ( do_interrupt_context_test ) {
test_interrupt_context_enter( level );
sc = rtems_io_unregister_driver( 0 );
test_interrupt_context_leave( level );
fatal_directive_status(
sc,
RTEMS_CALLED_FROM_ISR,
"rtems_io_unregister_driver"
);
}
puts( "Init - rtems_io_unregister_driver - invalid major number" );
sc = rtems_io_unregister_driver( invalid_major );
fatal_directive_status(
sc,
RTEMS_UNSATISFIED,
"rtems_io_unregister_driver"
);
TEST_END();
rtems_test_exit( 0 );
}
void do_test_io_manager(void)
{
rtems_status_code status;
rtems_device_major_number registered;
rtems_device_major_number registered_worked;
puts( "----- TESTING THE NULL DRIVER CHECKS -----" );
status = rtems_io_initialize( NO_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_initialize" );
puts( "rtems_io_initialize - NULL DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_open( NO_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_open" );
puts( "rtems_io_open - NULL DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_close( NO_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_close" );
puts( "rtems_io_close - NULL DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_read( NO_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_read" );
puts( "rtems_io_read - NULL DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_write( NO_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_write" );
puts( "rtems_io_write - NULL DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_control( NO_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_control" );
puts( "rtems_io_control - NULL DRIVER RTEMS_SUCCESSFUL" );
puts( "----- TESTING THE I/O MANAGER DIRECTIVES -----" );
status = rtems_io_initialize( STUB_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_initialize" );
puts( "rtems_io_initialize - STUB DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_open( STUB_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_open" );
puts( "rtems_io_open - STUB DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_close( STUB_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_close" );
puts( "rtems_io_close - STUB DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_read( STUB_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_read" );
puts( "rtems_io_read - STUB DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_write( STUB_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_write" );
puts( "rtems_io_write - STUB DRIVER RTEMS_SUCCESSFUL" );
status = rtems_io_control( STUB_DRIVER_MAJOR, 0, NULL );
directive_failed( status, "rtems_io_control" );
puts( "rtems_io_control - STUB DRIVER RTEMS_SUCCESSFUL" );
/*
* Invalid major number
*/
puts( "----- RETURNING INVALID MAJOR NUMBER -----" );
status = rtems_io_initialize( INVALID_DRIVER_MAJOR, 0, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_NUMBER,
"rtems_io_initialize"
);
puts( "rtems_io_initialize - RTEMS_INVALID_NUMBER" );
status = rtems_io_open( INVALID_DRIVER_MAJOR, 0, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_NUMBER,
"rtems_io_open"
);
puts( "rtems_io_open - RTEMS_INVALID_NUMBER" );
/*
* Exercise the io register driver directive
*/
puts( "----- EXERCISE DRIVER REGISTER -----" );
status = rtems_io_register_driver( 0, &GoodDriver, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_io_register_driver"
);
puts(
"rtems_io_register_driver - RTEMS_INVALID_ADDRESS - NULL registered"
);
status = rtems_io_register_driver( 0, NULL, ®istered );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_io_register_driver"
);
puts(
"rtems_io_register_driver - RTEMS_INVALID_ADDRESS - NULL device"
);
status = rtems_io_register_driver( 0, &BadDriver_Nothing, ®istered );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_io_register_driver"
);
puts(
"rtems_io_register_driver - RTEMS_INVALID_ADDRESS - no callouts"
);
status = rtems_io_register_driver(
INVALID_DRIVER_MAJOR, &GoodDriver, ®istered );
fatal_directive_status(
status,
RTEMS_INVALID_NUMBER,
"rtems_io_register_driver"
);
puts( "rtems_io_register_driver - RTEMS_INVALID_NUMBER - bad major" );
/* this has to succeed to overwrite NULL driver entry required above. */
status = rtems_io_register_driver( 0, &GoodDriver, ®istered_worked );
directive_failed( status, "rtems_io_register_driver" );
puts( "rtems_io_register_driver - RTEMS_SUCCESSFUL - overwrite NULL" );
status = rtems_io_register_driver( 0, &GoodDriver, ®istered );
if ( status == RTEMS_SUCCESSFUL )
printf(
"registered major = %" PRIurtems_device_major_number "\n", registered );
fatal_directive_status(
status,
RTEMS_TOO_MANY,
"rtems_io_register_driver"
);
puts( "rtems_io_register_driver - RTEMS_TOO_MANY - no slots" );
/* there should be a driver at major 1 -- clock, console, or stub */
status = rtems_io_register_driver( 1, &GoodDriver, ®istered );
fatal_directive_status(
status,
RTEMS_RESOURCE_IN_USE,
"rtems_io_register_driver"
);
puts(
"rtems_io_register_driver - RTEMS_RESOURCE_IN_USE - major in use"
);
/* this should unregister the device driver we registered above */
status = rtems_io_unregister_driver( registered_worked );
directive_failed( status, "rtems_io_unregister_driver" );
puts( "rtems_io_unregister_driver - RTEMS_SUCCESSFUL" );
}
