* apps/testing/rpmsg/rpmsgblk.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
* Included Files
****************************************************************************/
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <stdint.h>
#include <cmocka.h>
#include <fcntl.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/random.h>
#include <nuttx/fs/fs.h>
#include <nuttx/drivers/ramdisk.h>
#include <nuttx/drivers/rpmsgblk.h>
* Pre-processor Definitions
****************************************************************************/
#define BLK_NSECTORS 8
#define BLK_SECTSIZE 512
#define MTD_NAMESIZE 32
* Private Types
****************************************************************************/
struct pre_build_s
{
FAR struct inode *driver;
char source[MTD_NAMESIZE];
struct geometry cfg;
int fd;
FAR char *cpu;
bool server;
};
* Private Functions
****************************************************************************/
#ifdef CONFIG_BLK_RPMSG_SERVER
* Name: rpmsgblk_server_register
*
* Description:
* Non-standard function to register a ramdisk or a romdisk
*
* Input Parameters:
* path: device name
* nsectors: Number of sectors on device
* sectize: The size of one sector
* rdflags: See RDFLAG_* definitions
* buffer: RAM disk backup memory
*
* Returned Value:
* Zero on success; a negated errno value on failure.
*
****************************************************************************/
static int rpmsgblk_server_register(FAR const char *path)
{
struct ramdisk_config_s config;
FAR uint8_t *buffer;
int ret;
buffer = (FAR uint8_t *)malloc(BLK_NSECTORS * BLK_SECTSIZE);
assert_true(buffer != NULL);
config.nsectors = BLK_NSECTORS;
config.sectsize = BLK_SECTSIZE;
config.buffer = buffer;
config.rdflags = RDFLAG_WRENABLED | RDFLAG_FUNLINK;
config.name = path;
ret = ramdisk_register_with_config(&config);
if (ret < 0)
{
syslog(LOG_ERR, "register_blockdriver failed: %d\n", -ret);
free(buffer);
}
return ret;
}
* Name: rpmsgblk_server_unregister
****************************************************************************/
static int rpmsgblk_server_unregister(FAR const char *path)
{
FAR void *buffer;
int ret;
int fd;
fd = open(path, O_RDWR | O_DIRECT);
if (fd < 0)
{
syslog(LOG_ERR, "open block device failed: %d\n", fd);
return fd;
}
ret = ioctl(fd, BIOC_XIPBASE, (unsigned long)((uintptr_t)&buffer));
if (ret < 0)
{
syslog(LOG_ERR, "get RAM disk backup memory failed: %d\n", ret);
close(fd);
return ret;
}
close(fd);
ret = ramdisk_unregister(path);
if (ret < 0)
{
syslog(LOG_ERR, "unregister blockdriver failed: %d\n", ret);
return ret;
}
free(buffer);
return ret;
}
#else
* Name: testcase1
****************************************************************************/
static void testcase1(FAR void **state)
{
FAR struct pre_build_s *pre = (FAR struct pre_build_s *)(*state);
pre->fd = open(pre->source, O_RDWR | O_DIRECT);
assert_true(pre->fd >= 0);
assert_true(close(pre->fd) == 0);
}
* Name: testcase2
****************************************************************************/
static void testcase2(FAR void **state)
{
FAR struct pre_build_s *pre = (FAR struct pre_build_s *)(*state);
int ret;
pre->fd = open(pre->source, O_RDWR | O_DIRECT);
assert_true(pre->fd >= 0);
ret = ioctl(pre->fd, BIOC_GEOMETRY, (unsigned long)((uintptr_t)&pre->cfg));
assert_true(ret >= 0);
assert_true(pre->cfg.geo_nsectors == BLK_NSECTORS);
assert_true(pre->cfg.geo_sectorsize == BLK_SECTSIZE);
assert_true(pre->cfg.geo_writeenabled == RDFLAG_WRENABLED);
assert_true(close(pre->fd) == 0);
}
* Name: testcase3_setup
****************************************************************************/
static int testcase3_setup(FAR void **state)
{
FAR struct pre_build_s *pre = (FAR struct pre_build_s *)(*state);
int ret;
pre->fd = open(pre->source, O_RDWR | O_DIRECT);
assert_true(pre->fd >= 0);
ret = ioctl(pre->fd, BIOC_GEOMETRY, (unsigned long)((uintptr_t)&pre->cfg));
assert_true(ret >= 0);
return 0;
}
* Name: testcase3
*
* Description:
* Test rpmsgblk device read, write option.
*
* Returned Value:
* Zero on success; a negated errno value on failure.
*
****************************************************************************/
static void testcase3(FAR void** state)
{
FAR struct pre_build_s *pre = (FAR struct pre_build_s *)(*state);
FAR void *input;
FAR void *output;
off_t offset;
int ret;
input = malloc(pre->cfg.geo_sectorsize * 2);
assert_true(input != NULL);
output = input + pre->cfg.geo_sectorsize;
* 'sectors' by bch, and fill each 'sector' with random characters, then
* read it out and compare whether the writing and The difference between
* write and store is verified by memcompare.
* This behavior simulates the behavior of commands such as 'dd' in the
* system. The general flow is user->bch->ftl->driver
*/
for (offset = 0; offset < pre->cfg.geo_nsectors; offset++)
{
assert_false(lseek(pre->fd, offset * pre->cfg.geo_sectorsize,
SEEK_SET) < 0);
getrandom(input, pre->cfg.geo_sectorsize, 0);
ret = write(pre->fd, input, pre->cfg.geo_sectorsize);
assert_false(ret != pre->cfg.geo_sectorsize);
* beginning
*/
assert_false(lseek(pre->fd, offset * pre->cfg.geo_sectorsize,
SEEK_SET) < 0);
ret = read(pre->fd, output, pre->cfg.geo_sectorsize);
assert_false(ret != pre->cfg.geo_sectorsize);
assert_true(memcmp(input, output, pre->cfg.geo_sectorsize) == 0);
}
assert_true(close(pre->fd) == 0);
free(input);
}
#endif
* Name: show_usage
****************************************************************************/
static void show_usage(FAR const char *progname, int exitcode)
{
printf("Usage: %s [-m <is server>] [-c <remote cpu>] [-d <dev_name>]\n",
progname);
printf("Where:\n");
printf(" -c: <name> remote cpu which regists test driver\n"
" -d: <path> register rpmsgblk device\n"
" -u: <path> unregister rpmsgmtd driver\n"
" -m: <server>: is server\n");
exit(exitcode);
}
* Name: parse_commandline
****************************************************************************/
static void parse_commandline(int argc, FAR char **argv,
FAR struct pre_build_s *pre)
{
int option;
int ret = ERROR;
pre->server = true;
while ((option = getopt(argc, argv, "c:d:u:m:")) != ERROR)
{
switch (option)
{
case 'c':
pre->cpu = optarg;
break;
case 'm':
pre->server = atoi(optarg);
break;
case 'd':
strlcpy(pre->source, optarg, sizeof(pre->source));
if (pre->server)
{
#ifdef CONFIG_BLK_RPMSG_SERVER
ret = rpmsgblk_server_register(pre->source);
#endif
}
else
{
#ifdef CONFIG_BLK_RPMSG
ret = rpmsgblk_register(pre->cpu, pre->source, NULL);
#endif
}
if (ret == 0)
{
syslog(LOG_INFO, "register rpmsgblk device success.\n");
}
else
{
syslog(LOG_INFO, "register rpmsgblk dev failed: %d\n", ret);
}
break;
case 'u':
strlcpy(pre->source, optarg, sizeof(pre->source));
#ifdef CONFIG_BLK_RPMSG_SERVER
if ((ret = rpmsgblk_server_unregister(pre->source)) < 0)
{
syslog(LOG_INFO, "unregister block device fail: %d\n", ret);
}
else
{
syslog(LOG_INFO, "unregister block device success.\n");
}
#else
syslog(LOG_ERR, "ERROR: Client unsupport ops: -u.\n");
#endif
break;
case '?':
printf("Unknown option: %c\n", optopt);
show_usage(argv[0], EXIT_FAILURE);
break;
}
}
}
* Public Functions
****************************************************************************/
int main(int argc, char *argv[])
{
FAR struct pre_build_s *pre;
pre = (FAR struct pre_build_s *)malloc(sizeof(struct pre_build_s));
assert_true(pre != NULL);
parse_commandline(argc, argv, pre);
#ifdef CONFIG_BLK_RPMSG
const struct CMUnitTest tests[] =
{
cmocka_unit_test_prestate_setup_teardown(testcase1, NULL, NULL,
(FAR void *)pre),
cmocka_unit_test_prestate_setup_teardown(testcase2, NULL, NULL,
(FAR void *)pre),
cmocka_unit_test_prestate_setup_teardown(testcase3, testcase3_setup,
NULL, (FAR void *)pre),
};
cmocka_run_group_tests(tests, NULL, NULL);
rpmsgblk_unregister(pre->source);
#endif
free(pre);
return 0;
}