libtests/block01/init.c

0001 /* SPDX-License-Identifier: BSD-2-Clause */
0002
0003 /**
0004  * @file
0005  *
0006  * @ingroup tests
0007  *
0008  * @brief Block device tests.
0009  */
0010
0011 /*
0012  * Copyright (C) 2009, 2018 embedded brains GmbH & Co. KG
0013  *
0014  * Redistribution and use in source and binary forms, with or without
0015  * modification, are permitted provided that the following conditions
0016  * are met:
0017  * 1. Redistributions of source code must retain the above copyright
0018  *    notice, this list of conditions and the following disclaimer.
0019  * 2. Redistributions in binary form must reproduce the above copyright
0020  *    notice, this list of conditions and the following disclaimer in the
0021  *    documentation and/or other materials provided with the distribution.
0022  *
0023  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
0024  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
0025  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
0026  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
0027  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
0028  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
0029  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
0030  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
0031  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
0032  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
0033  * POSSIBILITY OF SUCH DAMAGE.
0034  */
0035
0036 #ifdef HAVE_CONFIG_H
0037 #include "config.h"
0038 #endif
0039
0040 #include <sys/stat.h>
0041 #include <stdio.h>
0042 #include <fcntl.h>
0043 #include "tmacros.h"
0044
0045 #include <rtems.h>
0046 #include <rtems/ramdisk.h>
0047 #include <rtems/diskdevs.h>
0048
0049 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
0050
0051 const char rtems_test_name[] = "BLOCK 1";
0052
0053 #define ASSERT_SC(sc) rtems_test_assert((sc) == RTEMS_SUCCESSFUL)
0054
0055 #define ASSERT_SC_EQ(sc, sc_expected) rtems_test_assert((sc) == (sc_expected))
0056
0057 #define BLOCK_SIZE 512U
0058
0059 #define BLOCK_COUNT 16U
0060
0061 static const rtems_driver_address_table ramdisk_ops = {
0062   .initialization_entry = NULL,
0063   RTEMS_GENERIC_BLOCK_DEVICE_DRIVER_ENTRIES
0064 };
0065
0066 static void test_block_io_control_api(dev_t dev, ramdisk *rd)
0067 {
0068   rtems_status_code sc = RTEMS_SUCCESSFUL;
0069   rtems_disk_device *dd = NULL;
0070   rtems_disk_device *fd_dd = NULL;
0071   int fd = -1;
0072   int rv = -1;
0073   uint32_t value = 0;
0074   rtems_blkdev_bnum block_count = 0;
0075
0076   sc = rtems_disk_create_phys(dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
0077   ASSERT_SC(sc);
0078
0079   dd = rtems_disk_obtain(dev);
0080   rtems_test_assert(dd != NULL);
0081
0082   fd = open("/dev/rda", O_RDWR);
0083   rtems_test_assert(fd >= 0);
0084
0085   value = 0;
0086   rv = rtems_disk_fd_get_media_block_size(fd, &value);
0087   rtems_test_assert(rv == 0);
0088   rtems_test_assert(value == BLOCK_SIZE);
0089
0090   value = 0;
0091   rv = rtems_disk_fd_get_block_size(fd, &value);
0092   rtems_test_assert(rv == 0);
0093   rtems_test_assert(value == BLOCK_SIZE);
0094
0095   value = 1024;
0096   rv = rtems_disk_fd_set_block_size(fd, value);
0097   rtems_test_assert(rv == 0);
0098
0099   value = 0;
0100   rv = rtems_disk_fd_get_block_size(fd, &value);
0101   rtems_test_assert(rv == 0);
0102   rtems_test_assert(value == 1024);
0103
0104   block_count = 0;
0105   rv = rtems_disk_fd_get_block_count(fd, &block_count);
0106   rtems_test_assert(rv == 0);
0107   rtems_test_assert(block_count == BLOCK_COUNT);
0108
0109   rv = rtems_disk_fd_get_disk_device(fd, &fd_dd);
0110   rtems_test_assert(rv == 0);
0111   rtems_test_assert(fd_dd == dd);
0112
0113   rv = rtems_disk_fd_sync(fd);
0114   rtems_test_assert(rv == 0);
0115
0116   rv = close(fd);
0117   rtems_test_assert(rv == 0);
0118
0119   sc = rtems_disk_release(dd);
0120   ASSERT_SC(sc);
0121
0122   sc = rtems_disk_delete(dev);
0123   ASSERT_SC(sc);
0124 }
0125
0126 static void test_diskdevs(void)
0127 {
0128   rtems_status_code sc = RTEMS_SUCCESSFUL;
0129   rtems_device_major_number major = 0;
0130   rtems_device_minor_number minor = 0;
0131   rtems_disk_device *physical_dd = NULL;
0132   rtems_disk_device *logical_dd = NULL;
0133   rtems_disk_device *dd = NULL;
0134   dev_t physical_dev = 0;
0135   dev_t logical_dev = 0;
0136   dev_t logical_2_dev = 0;
0137   dev_t const big_major_dev = rtems_filesystem_make_dev_t((rtems_device_major_number) -2, 0);
0138   dev_t const big_minor_dev = rtems_filesystem_make_dev_t(0, (rtems_device_minor_number) -2);
0139   ramdisk *const rd = ramdisk_allocate(NULL, BLOCK_SIZE, BLOCK_COUNT, false);
0140
0141   rtems_test_assert(rd != NULL);
0142
0143   sc = rtems_disk_io_initialize();
0144   ASSERT_SC(sc);
0145
0146   sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
0147   ASSERT_SC(sc);
0148
0149   physical_dev = rtems_filesystem_make_dev_t(major, minor);
0150   logical_dev = rtems_filesystem_make_dev_t(major, minor + 1);
0151   logical_2_dev = rtems_filesystem_make_dev_t(major, minor + 2);
0152
0153   /* Consistency checks for physical disks creation */
0154
0155   sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, NULL, rd, "/dev/rda");
0156   ASSERT_SC_EQ(sc, RTEMS_INVALID_ADDRESS);
0157
0158   sc = rtems_disk_create_phys(physical_dev, 0, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
0159   ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
0160
0161   sc = rtems_disk_create_phys(big_major_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
0162   ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
0163
0164   sc = rtems_disk_create_phys(big_minor_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
0165   ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
0166
0167   sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, NULL);
0168   ASSERT_SC(sc);
0169
0170   sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, NULL);
0171   ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
0172
0173   sc = rtems_disk_delete(physical_dev);
0174   ASSERT_SC(sc);
0175
0176   /* Consistency checks for logical disks creation */
0177
0178   sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
0179   ASSERT_SC_EQ(sc, RTEMS_INVALID_ID);
0180
0181   sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
0182   ASSERT_SC(sc);
0183
0184   sc = rtems_disk_create_log(big_major_dev, physical_dev, 0, 1, "/dev/rda1");
0185   ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
0186
0187   sc = rtems_disk_create_log(big_minor_dev, physical_dev, 0, 1, "/dev/rda1");
0188   ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
0189
0190   sc = rtems_disk_create_log(logical_dev, physical_dev, BLOCK_COUNT, 0, "/dev/rda1");
0191   ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
0192
0193   sc = rtems_disk_create_log(logical_dev, physical_dev, 0, BLOCK_COUNT + 1, "/dev/rda1");
0194   ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
0195
0196   sc = rtems_disk_create_log(logical_dev, physical_dev, 1, BLOCK_COUNT, "/dev/rda1");
0197   ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
0198
0199   sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
0200   ASSERT_SC(sc);
0201
0202   sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
0203   ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
0204
0205   sc = rtems_disk_create_log(logical_2_dev, logical_dev, 0, 1, "/dev/rda2");
0206   ASSERT_SC_EQ(sc, RTEMS_INVALID_ID);
0207
0208   sc = rtems_disk_delete(logical_dev);
0209   ASSERT_SC(sc);
0210
0211   /* Consistency checks delete */
0212
0213   sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
0214   ASSERT_SC(sc);
0215
0216   physical_dd = rtems_disk_obtain(physical_dev);
0217   rtems_test_assert(physical_dd != NULL && physical_dd->uses == 2);
0218
0219   sc = rtems_disk_release(physical_dd);
0220   ASSERT_SC(sc);
0221
0222   logical_dd = rtems_disk_obtain(logical_dev);
0223   rtems_test_assert(logical_dd != NULL && logical_dd->uses == 1);
0224
0225   sc = rtems_disk_delete(physical_dev);
0226   ASSERT_SC(sc);
0227
0228   sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
0229   ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
0230
0231   dd = rtems_disk_obtain(physical_dev);
0232   rtems_test_assert(dd == NULL);
0233
0234   dd = rtems_disk_obtain(logical_dev);
0235   rtems_test_assert(dd == NULL);
0236
0237   sc = rtems_disk_release(logical_dd);
0238   ASSERT_SC(sc);
0239
0240   /* Test block IO control API */
0241
0242   test_block_io_control_api(physical_dev, rd);
0243
0244   /* Cleanup */
0245
0246   sc = rtems_io_unregister_driver(major);
0247   ASSERT_SC(sc);
0248
0249   ramdisk_free(rd);
0250
0251   sc = rtems_disk_io_done();
0252   ASSERT_SC(sc);
0253 }
0254
0255 static rtems_task Init(rtems_task_argument argument)
0256 {
0257   TEST_BEGIN();
0258
0259   test_diskdevs();
0260
0261   TEST_END();
0262
0263   exit(0);
0264 }
0265
0266 #define CONFIGURE_INIT
0267
0268 #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER
0269 #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
0270 #define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
0271
0272 #define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 4
0273
0274 #define CONFIGURE_MAXIMUM_TASKS 1
0275 #define CONFIGURE_MAXIMUM_DRIVERS 2
0276
0277 #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
0278
0279 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE
0280
0281 #include <rtems/confdefs.h>