static void test_imfs_make_generic_node_errors(void)
{
int rv = 0;
const char *path = "generic";
rtems_chain_control *chain = &rtems_filesystem_mount_table;
rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) rtems_chain_first(chain);
const char *type = mt_entry->type;
void *opaque = NULL;
errno = 0;
rv = IMFS_make_generic_node(
path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_invalid_control,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == EINVAL);
errno = 0;
rv = IMFS_make_generic_node(
path,
S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == EINVAL);
mt_entry->type = "XXX";
errno = 0;
rv = IMFS_make_generic_node(
path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
mt_entry->type = type;
opaque = rtems_heap_greedy_allocate(NULL, 0);
errno = 0;
rv = IMFS_make_generic_node(
path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOMEM);
rtems_heap_greedy_free(opaque);
}
rtems_status_code rtems_blkdev_create(
const char *device,
uint32_t block_size,
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block_count > 0) {
rtems_blkdev_imfs_context *ctx = calloc(1, sizeof(*ctx));
if (ctx != NULL) {
rtems_disk_device *dd = &ctx->dd;
ctx->fd = -1;
dd->phys_dev = dd;
dd->size = block_count;
dd->media_block_size = block_size;
dd->ioctl = handler;
dd->driver_data = driver_data;
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) != 0) {
dd->capabilities = 0;
}
sc = rtems_bdbuf_set_block_size(dd, block_size);
if (sc == RTEMS_SUCCESSFUL) {
int rv = IMFS_make_generic_node(
device,
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
free(ctx);
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
}
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
static void test_imfs_make_generic_node(void)
{
int rv = 0;
int fd = 0;
const char *path = "generic";
char buf [1];
ssize_t n = 0;
off_t off = 0;
rv = IMFS_make_generic_node(
path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
&global_state
);
rtems_test_assert(rv == 0);
fd = open(path, O_RDWR);
rtems_test_assert(fd >= 0);
n = read(fd, buf, sizeof(buf));
rtems_test_assert(n == 0);
n = write(fd, buf, sizeof(buf));
rtems_test_assert(n == 0);
rv = ioctl(fd, 0);
rtems_test_assert(rv == 0);
off = lseek(fd, off, SEEK_SET);
rtems_test_assert(off == 0);
rv = ftruncate(fd, 0);
rtems_test_assert(rv == 0);
rv = fsync(fd);
rtems_test_assert(rv == 0);
rv = fdatasync(fd);
rtems_test_assert(rv == 0);
rv = fcntl(fd, F_GETFD);
rtems_test_assert(rv >= 0);
rv = close(fd);
rtems_test_assert(rv == 0);
rv = unlink(path);
rtems_test_assert(rv == 0);
rtems_test_assert(global_state == TEST_DESTROYED);
}
int i2c_dev_register(
i2c_dev *dev,
const char *dev_path
)
{
int rv;
rv = IMFS_make_generic_node(
dev_path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&i2c_dev_node_control,
dev
);
if (rv != 0) {
(*dev->destroy)(dev);
}
return rv;
}
rtems_status_code rtems_blkdev_create(
const char *device,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
rtems_block_device_ioctl handler,
void *driver_data
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
if (ctx != NULL) {
sc = rtems_disk_init_phys(
&ctx->dd,
media_block_size,
media_block_count,
handler,
driver_data
);
ctx->fd = -1;
if (sc == RTEMS_SUCCESSFUL) {
int rv = IMFS_make_generic_node(
device,
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
free(ctx);
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
}
} else {
sc = RTEMS_NO_MEMORY;
}
return sc;
}
static void test(void)
{
test_context *ctx = &test_instance;
rtems_status_code sc;
int rv;
rtems_resource_snapshot snapshot;
ctx->main_task_id = rtems_task_self();
rtems_resource_snapshot_take(&snapshot);
rv = IMFS_make_generic_node(
&file_path[0],
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == 0);
sc = rtems_task_create(
rtems_build_name('W', 'O', 'R', 'K'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->worker_task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(ctx->worker_task_id, worker_task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wait();
sc = rtems_task_delete(ctx->worker_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rv = unlink(&file_path[0]);
rtems_test_assert(rv == 0);
rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
}
static void test(test_context *ctx)
{
const char *path = "generic";
int rv;
rv = IMFS_make_generic_node(
path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
ctx
);
rtems_test_assert(rv == 0);
interrupt_critical_section_test(test_body, ctx, do_fcntl);
/* There is no reliable indicator if the test case has been hit */
rtems_test_assert(ctx->append_count > 0);
rtems_test_assert(ctx->no_append_count > 0);
rv = unlink(path);
rtems_test_assert(rv == 0);
}
void *POSIX_Init(
void *argument
)
{
int rv;
TEST_BEGIN();
rv = IMFS_make_generic_node(
&test_driver_name[0],
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == 0);
puts( "Init: mmap - map at zero" );
mmap_map_at_zero();
puts( "Init: mmap - bad arguments" );
mmap_bad_arguments();
/*
* The following test does not work on RTEMS because /dev/zero is
* implemented as a character device which does not support MAP_PRIVATE.
*/
puts( "Init: mmap - /dev/zero private" );
mmap_dev_zero_private();
/*
* The following test does not work on RTEMS because /dev/zero does not
* implemented the mmap handler.
*/
puts( "Init: mmap - /dev/zero shared" );
mmap_dev_zero_shared();
TEST_END();
rtems_test_exit(0);
return 0;
}
rtems_status_code rtems_blkdev_create_partition(
const char *partition,
const char *parent_block_device,
rtems_blkdev_bnum media_block_begin,
rtems_blkdev_bnum media_block_count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
if (fd >= 0) {
int rv;
struct stat st;
rv = fstat(fd, &st);
if (rv == 0 && S_ISBLK(st.st_mode)) {
rtems_disk_device *phys_dd;
rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);
if (rv == 0) {
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
if (ctx != NULL) {
sc = rtems_disk_init_log(
&ctx->dd,
phys_dd,
media_block_begin,
media_block_count
);
if (sc == RTEMS_SUCCESSFUL) {
ctx->fd = fd;
rv = IMFS_make_generic_node(
partition,
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
free(ctx);
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
}
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_NOT_IMPLEMENTED;
}
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
}
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
static void Init(rtems_task_argument arg)
{
struct utimbuf times;
const char *generic = "generic";
const char *mnt = "mnt";
const char *dev = "device";
const char *file = "file";
const char *fifo = "fifo";
int rv;
int fd;
DIR *dirp;
struct dirent *dire;
struct stat st;
TEST_BEGIN();
rv = IMFS_make_generic_node(
generic,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == 0);
errno = 0;
rv = chown(generic, 0, 0);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
errno = 0;
rv = chmod(generic, 0);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
errno = 0;
rv = link(generic, "link");
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
rv = mkdir(mnt, S_IRWXU);
rtems_test_assert(rv == 0);
rv = mknod(dev, S_IFCHR | S_IRWXU, 0);
rtems_test_assert(rv == 0);
errno = 0;
fd = creat(file, S_IRWXU);
rtems_test_assert(fd == -1);
rtems_test_assert(errno == ENOSYS);
errno = 0;
rv = mkfifo(fifo, S_IRWXU);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOSYS);
dirp = opendir(mnt);
rtems_test_assert(dirp != NULL);
errno = 0;
dire = readdir(dirp);
rtems_test_assert(dire == NULL);
rtems_test_assert(errno == ENOTSUP);
rv = closedir(dirp);
rtems_test_assert(rv == 0);
rv = stat(mnt, &st);
rtems_test_assert(rv == 0);
rtems_test_assert(st.st_size == 0);
errno = 0;
rv = mount(
"",
mnt,
RTEMS_FILESYSTEM_TYPE_IMFS,
RTEMS_FILESYSTEM_READ_ONLY,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
errno = 0;
rv = rename(generic, "new");
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
errno = 0;
rv = symlink(generic, "link");
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
errno = 0;
rv = utime(generic, ×);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
errno = 0;
rv = unlink(generic);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
TEST_END();
rtems_test_exit(0);
}
rtems_status_code rtems_blkdev_create_partition(
const char *partition,
const char *device,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(device, O_RDWR);
if (fd >= 0) {
int rv;
struct stat st;
rv = fstat(fd, &st);
if (rv == 0 && S_ISBLK(st.st_mode)) {
rtems_disk_device *dd;
rv = ioctl(fd, RTEMS_BLKIO_GETDISKDEV, &dd);
if (rv == 0) {
rtems_blkdev_bnum device_block_count = rtems_disk_get_block_count(dd);
if (
block_begin < device_block_count
&& block_count > 0
&& block_count <= device_block_count - block_begin
) {
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
if (ctx != NULL) {
memcpy(&ctx->dd, dd, sizeof(ctx->dd));
ctx->dd.start = block_begin;
ctx->dd.size = block_count;
ctx->fd = fd;
rv = IMFS_make_generic_node(
partition,
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
free(ctx);
sc = RTEMS_UNSATISFIED;
}
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_NUMBER;
}
} else {
sc = RTEMS_NOT_IMPLEMENTED;
}
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
}
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
