M .vscode/settings.json => .vscode/settings.json +5 -1
@@ 76,6 76,10 @@
"typeindex": "cpp",
"valarray": "cpp",
"variant": "cpp",
- "*.ipp": "cpp"
+ "*.ipp": "cpp",
+ "pointers": "cpp",
+ "any": "cpp",
+ "charconv": "cpp",
+ "scoped_allocator": "cpp"
},
}=
\ No newline at end of file
M board/linux/libiosyscalls/include/debug.hpp => board/linux/libiosyscalls/include/debug.hpp +12 -7
@@ 1,15 1,20 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
#pragma once
#ifdef DEBUG_SHARED_LIBRARY_FS_LIB
-namespace vfsn::linux::internal {
- void debug_trace_syscall(const char* fn, const char* format, ...);
+namespace vfsn::linux::internal
+{
+ void debug_trace_syscall(const char *fn, const char *format, ...);
}
-#define TRACE_SYSCALL() vfsn::linux::internal::debug_trace_syscall(__PRETTY_FUNCTION__,"")
-#define TRACE_SYSCALLN(format,...) vfsn::linux::internal::debug_trace_syscall(__PRETTY_FUNCTION__,format,__VA_ARGS__)
+#define TRACE_SYSCALL() vfsn::linux::internal::debug_trace_syscall(__PRETTY_FUNCTION__, "")
+#define TRACE_SYSCALLN(format, ...) vfsn::linux::internal::debug_trace_syscall(__PRETTY_FUNCTION__, format, __VA_ARGS__)
#else
-#define TRACE_SYSCALL() do {} while(0)
-#define TRACE_SYSCALLN(format,...) do {} while(0)
+#define TRACE_SYSCALL() \
+ do { \
+ } while (0)
+#define TRACE_SYSCALLN(format, ...) \
+ do { \
+ } while (0)
#endif
M board/linux/libiosyscalls/include/iosyscalls.hpp => board/linux/libiosyscalls/include/iosyscalls.hpp +18 -19
@@ 11,44 11,43 @@ struct __dirstream;
namespace vfsn::linux::internal
{
bool redirect_to_image();
- bool is_image_handle(const FILE* fil);
+ bool is_image_handle(const FILE *fil);
bool is_image_fd(int fd);
- bool redirect_to_image(const char* inpath);
- const char* npath_translate(const char* inpath, char *buffer);
+ bool redirect_to_image(const char *inpath);
+ const char *npath_translate(const char *inpath, char *buffer);
- struct FILEX {
- int fd {0};
- int error {0};
- int ungetchar {-1};
+ struct FILEX
+ {
+ int fd{0};
+ int error{0};
+ int ungetchar{-1};
};
int to_native_fd(int fd);
int to_image_fd(int fd);
- FILEX* allocate_filex(int fd);
- bool is_filex(const void* fd);
+ FILEX *allocate_filex(int fd);
+ bool is_filex(const void *fd);
void remove_filex(FILEX *fil);
-
- void add_DIR_to_image_list(__dirstream* indir);
- void remove_DIR_from_image_list(__dirstream* indir);
- bool is_image_DIR(__dirstream* indir);
+ void add_DIR_to_image_list(__dirstream *indir);
+ void remove_DIR_from_image_list(__dirstream *indir);
+ bool is_image_DIR(__dirstream *indir);
template <class Base, typename T, typename... Args>
- auto invoke_fs( T Base::*lfs_fun, Args&& ... args)
+ auto invoke_fs(T Base::*lfs_fun, Args &&... args)
-> decltype((static_cast<Base *>(nullptr)->*lfs_fun)(std::forward<Args>(args)...))
{
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
errno = EIO;
return -1;
}
auto ret = (vfs.get()->*lfs_fun)(std::forward<Args>(args)...);
- if(ret < 0) {
+ if (ret < 0) {
errno = -ret;
- ret = -1;
+ ret = -1;
}
return ret;
}
-}
-
+} // namespace vfsn::linux::internal
M board/linux/libiosyscalls/src/iosyscalls.cpp => board/linux/libiosyscalls/src/iosyscalls.cpp +53 -58
@@ 12,70 12,67 @@
#include <debug.hpp>
#include <dirent.h>
-namespace {
- constexpr auto ENV_NAME = "IOSYSCALLS_REDIRECT_TO_IMAGE";
+namespace
+{
+ constexpr auto ENV_NAME = "IOSYSCALLS_REDIRECT_TO_IMAGE";
constexpr auto FIRST_FILEDESC = 64'566'756;
- bool g_readed = false;
- bool g_redirect = false;
-
- constexpr const char * LINUX_PATHS[] {
- "/dev/",
- "/etc/",
- "/usr/share",
- "/run/user",
- "/home",
- "/proc",
- "/dev/shm",
- "PurePhone.img",
- "MuditaOS.log",
- nullptr
- };
-
- constexpr const char * IMAGE_PATHS[] {
- "/sys",
- nullptr
- };
+ bool g_evaluated = false;
+ bool g_redirect = false;
+
+ constexpr const char *LINUX_PATHS[]{"/dev/",
+ "/etc/",
+ "/sys/.boot.json",
+ "/usr/share",
+ "/run/user",
+ "/home",
+ "/proc",
+ "/dev/shm",
+ "PurePhone.img",
+ "MuditaOS.log",
+ nullptr};
+
+ constexpr const char *IMAGE_PATHS[]{"/sys", nullptr};
pthread_mutex_t g_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
- phmap::flat_hash_set<vfsn::linux::internal::FILEX*> g_fdlist;
- phmap::flat_hash_set<DIR*> g_dirlist;
-}
+ phmap::flat_hash_set<vfsn::linux::internal::FILEX *> g_fdlist;
+ phmap::flat_hash_set<DIR *> g_dirlist;
+} // namespace
namespace vfsn::linux::internal
{
bool redirect_to_image()
{
- if(!g_readed) {
+ if (!g_evaluated) {
const auto env = std::getenv(ENV_NAME);
- g_redirect = env && !std::strcmp(env,"1");
- g_readed = true;
+ g_redirect = env && !std::strcmp(env, "1");
+ g_evaluated = true;
}
return g_redirect;
}
- bool redirect_to_image(const char* inpath)
+ bool redirect_to_image(const char *inpath)
{
if (!redirect_to_image())
return false;
- for(auto path=LINUX_PATHS; *path; ++path)
- if( std::strstr(inpath,*path)==inpath)
+ for (auto path = LINUX_PATHS; *path; ++path)
+ if (std::strstr(inpath, *path) == inpath)
return false;
return true;
}
- const char* npath_translate(const char* inpath, char *buffer)
+ const char *npath_translate(const char *inpath, char *buffer)
{
- for(auto path=IMAGE_PATHS; *path; ++path)
- if(std::strstr(inpath, *path) == inpath) {
+ for (auto path = IMAGE_PATHS; *path; ++path)
+ if (std::strstr(inpath, *path) == inpath) {
std::strncpy(buffer, inpath + 1, PATH_MAX);
return buffer;
}
return inpath;
}
- bool is_image_handle(const FILE* fil)
+ bool is_image_handle(const FILE *fil)
{
return false;
}
@@ 95,54 92,53 @@ namespace vfsn::linux::internal
return fd >= FIRST_FILEDESC;
}
- FILEX* allocate_filex(int fd)
+ FILEX *allocate_filex(int fd)
{
auto ret = new FILEX;
- ret->fd = fd;
+ ret->fd = fd;
pthread_mutex_lock(&g_lock);
- g_fdlist.emplace( ret );
+ g_fdlist.emplace(ret);
pthread_mutex_unlock(&g_lock);
return ret;
}
- void add_DIR_to_image_list(DIR* indir)
+ void add_DIR_to_image_list(DIR *indir)
{
pthread_mutex_lock(&g_lock);
- g_dirlist.emplace( indir );
+ g_dirlist.emplace(indir);
pthread_mutex_unlock(&g_lock);
}
- void remove_DIR_from_image_list(DIR* indir)
+ void remove_DIR_from_image_list(DIR *indir)
{
pthread_mutex_lock(&g_lock);
auto fres = g_dirlist.find(indir);
- if(fres != g_dirlist.end())
- {
+ if (fres != g_dirlist.end()) {
g_dirlist.erase(fres);
}
pthread_mutex_unlock(&g_lock);
}
- bool is_image_DIR(DIR* indir)
+ bool is_image_DIR(DIR *indir)
{
- if(indir==nullptr) {
+ if (indir == nullptr) {
return false;
}
pthread_mutex_lock(&g_lock);
- auto fres = g_dirlist.find(indir);
- auto isntdir = ( fres != g_dirlist.end() );
+ auto fres = g_dirlist.find(indir);
+ auto isntdir = (fres != g_dirlist.end());
pthread_mutex_unlock(&g_lock);
return isntdir;
}
- bool is_filex(const void* fd)
+ bool is_filex(const void *fd)
{
- if(fd==nullptr) {
+ if (fd == nullptr) {
return false;
}
pthread_mutex_lock(&g_lock);
- auto fres = g_fdlist.find(reinterpret_cast<const FILEX*>(fd));
- auto isfilex = ( fres != g_fdlist.end() );
+ auto fres = g_fdlist.find(reinterpret_cast<const FILEX *>(fd));
+ auto isfilex = (fres != g_fdlist.end());
pthread_mutex_unlock(&g_lock);
return isfilex;
}
@@ 151,23 147,22 @@ namespace vfsn::linux::internal
{
pthread_mutex_lock(&g_lock);
auto fres = g_fdlist.find(fil);
- if(fres != g_fdlist.end())
- {
+ if (fres != g_fdlist.end()) {
g_fdlist.erase(fres);
delete fil;
}
pthread_mutex_unlock(&g_lock);
}
- void debug_trace_syscall(const char* fn, const char* format, ...)
+ void debug_trace_syscall(const char *fn, const char *format, ...)
{
auto rvprint = reinterpret_cast<decltype(&vfprintf)>(dlsym(RTLD_NEXT, "vfprintf"));
- auto rprint = reinterpret_cast<decltype(&fprintf)>(dlsym(RTLD_NEXT, "fprintf"));
- rprint(stderr,">>>>>>> IOFUNC: [%s] ", fn);
+ auto rprint = reinterpret_cast<decltype(&fprintf)>(dlsym(RTLD_NEXT, "fprintf"));
+ rprint(stderr, ">>>>>>> IOFUNC: [%s] ", fn);
va_list args;
va_start(args, format);
rvprint(stderr, format, args);
va_end(args);
- rprint(stderr," >>>>>>>>>>>\n");
+ rprint(stderr, " >>>>>>>>>>>\n");
}
-}
+} // namespace vfsn::linux::internal
M board/linux/libiosyscalls/src/syscalls_posix.cpp => board/linux/libiosyscalls/src/syscalls_posix.cpp +154 -208
@@ 12,8 12,8 @@
#include <poll.h>
#include <fcntl.h>
#include <errno.h>
-#include <stdarg.h> // for va_*
-#include <limits.h> // for PATH_MAX
+#include <stdarg.h> // for va_*
+#include <limits.h> // for PATH_MAX
#include "syscalls_real.hpp"
@@ 21,7 21,8 @@
namespace
{
- namespace real {
+ namespace real
+ {
__REAL_DECL(link);
__REAL_DECL(unlink);
__REAL_DECL(symlink);
@@ 109,33 110,29 @@ namespace
__REAL_DLSYM(poll);
__REAL_DLSYM(statvfs);
- if (!(real::link && real::unlink && real::symlink && real::fcntl && real::fcntl64
- && real::chdir && real::fchdir && real::getcwd && real::getwd
- && real::get_current_dir_name && real::mkdir && real::chmod && real::fchmod
- && real::fsync && real::fdatasync
- && real::__xstat && real::__lxstat && real::__fxstat
- && real::__xstat64 && real::__lxstat64 && real::__fxstat64
- && real::read && real::write && real::lseek && real::lseek64
- && real::mount && real::umount && real::ioctl && real::poll
- && real::statvfs))
- {
+ if (!(real::link && real::unlink && real::symlink && real::fcntl && real::fcntl64 && real::chdir &&
+ real::fchdir && real::getcwd && real::getwd && real::get_current_dir_name && real::mkdir && real::chmod &&
+ real::fchmod && real::fsync && real::fdatasync && real::__xstat && real::__lxstat && real::__fxstat &&
+ real::__xstat64 && real::__lxstat64 && real::__fxstat64 && real::read && real::write && real::lseek &&
+ real::lseek64 && real::mount && real::umount && real::ioctl && real::poll && real::statvfs)) {
abort();
}
}
-} //namespace
+} // namespace
-extern "C" {
+extern "C"
+{
namespace vfs = vfsn::linux::internal;
- using fs = purefs::fs::filesystem;
+ using fs = purefs::fs::filesystem;
int _iosys_read(int __fd, void *__buf, size_t __nbyte)
{
int ret;
- if (vfs::is_image_fd(__fd))
- {
+ if (vfs::is_image_fd(__fd)) {
TRACE_SYSCALLN("(%d, %p, %u) -> VFS", __fd, __buf, __nbyte);
- ret = vfs::invoke_fs(&fs::read,vfs::to_image_fd(__fd),(char*)__buf,__nbyte);
- } else {
+ ret = vfs::invoke_fs(&fs::read, vfs::to_image_fd(__fd), (char *)__buf, __nbyte);
+ }
+ else {
TRACE_SYSCALLN("(%d, %p, %u) -> linux fs", __fd, __buf, __nbyte);
// returning result via a variable causes strange
// sanitizer errors on debug build
@@ 149,11 146,11 @@ extern "C" {
int _iosys_write(int __fd, const void *__buf, size_t __nbyte)
{
int ret;
- if (vfs::is_image_fd(__fd))
- {
+ if (vfs::is_image_fd(__fd)) {
TRACE_SYSCALLN("(%d, %p, %u) -> VFS", __fd, __buf, __nbyte);
- ret = vfs::invoke_fs(&fs::write,vfs::to_image_fd(__fd),(const char*)__buf,__nbyte);
- } else {
+ ret = vfs::invoke_fs(&fs::write, vfs::to_image_fd(__fd), (const char *)__buf, __nbyte);
+ }
+ else {
TRACE_SYSCALLN("(%d, %p, %u) -> linux fs", __fd, __buf, __nbyte);
ret = real::write(__fd, __buf, __nbyte);
}
@@ 164,11 161,11 @@ extern "C" {
int _iosys_lseek(int __fildes, off_t __offset, int __whence)
{
- if (vfs::is_image_fd(__fildes))
- {
+ if (vfs::is_image_fd(__fildes)) {
TRACE_SYSCALLN("(%d) -> VFS", __fildes);
- return vfs::invoke_fs(&fs::seek,vfs::to_image_fd(__fildes),__offset,__whence);
- } else {
+ return vfs::invoke_fs(&fs::seek, vfs::to_image_fd(__fildes), __offset, __whence);
+ }
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", __fildes);
return real::lseek(__fildes, __offset, __whence);
}
@@ 177,11 174,11 @@ extern "C" {
int _iosys_lseek64(int __fd, loff_t __offset, int __whence)
{
- if (vfs::is_image_fd(__fd))
- {
+ if (vfs::is_image_fd(__fd)) {
TRACE_SYSCALLN("%s", "-> lseek");
return lseek(__fd, __offset, __whence);
- } else {
+ }
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", __fd);
return real::lseek64(__fd, __offset, __whence);
}
@@ 193,17 190,18 @@ extern "C" {
int ret;
uintptr_t param;
va_list args;
- va_start(args,__request);
- param = va_arg(args,uintptr_t);
+ va_start(args, __request);
+ param = va_arg(args, uintptr_t);
if (vfs::is_image_fd(__fd)) {
TRACE_SYSCALLN("(%d) -> VFS", __fd);
// VFS's ioctl works on paths, not file descriptors
// so we can't handle it the easy way, f ex.
// ret = vfs::invoke_fs(__VFS(ioctl), __fd, __request, param);
errno = ENOTSUP;
- std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
+ std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
ret = -1;
- } else {
+ }
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", __fd);
ret = real::ioctl(__fd, __request, param);
}
@@ 218,7 216,7 @@ extern "C" {
TRACE_SYSCALLN("(%d) -> VFS", __fds->fd);
// there's no point in translating this call
errno = ENOTSUP;
- std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
+ std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
return -1;
}
TRACE_SYSCALLN("(%d) -> linux fs", __fds ? __fds->fd : 0);
@@ 228,128 226,116 @@ extern "C" {
int _iosys_link(const char *oldpath, const char *newpath)
{
- if(vfs::redirect_to_image(oldpath))
- {
+ if (vfs::redirect_to_image(oldpath)) {
TRACE_SYSCALLN("(%s,%s) -> VFS", oldpath, newpath);
errno = ENOSYS;
- std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
+ std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
return -1;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s,%s) -> linux fs", oldpath, newpath);
char tmp[PATH_MAX], tmp2[PATH_MAX];
- const auto oldp = vfs::npath_translate(oldpath,tmp);
- const auto newp = vfs::npath_translate(newpath,tmp2);
- return real::link(oldp,newp);
+ const auto oldp = vfs::npath_translate(oldpath, tmp);
+ const auto newp = vfs::npath_translate(newpath, tmp2);
+ return real::link(oldp, newp);
}
}
__asm__(".symver _iosys_link,link@GLIBC_2.2.5");
- int _iosys_unlink(const char *name)
- {
- if(vfs::redirect_to_image(name))
- {
+ int _iosys_unlink(const char *name)
+ {
+ if (vfs::redirect_to_image(name)) {
TRACE_SYSCALLN("(%s) -> VFS", name);
return vfs::invoke_fs(&fs::unlink, name);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", name);
char tmp[PATH_MAX];
- const auto path = vfs::npath_translate(name,tmp);
+ const auto path = vfs::npath_translate(name, tmp);
return real::unlink(path);
}
- }
+ }
__asm__(".symver _iosys_unlink,unlink@GLIBC_2.2.5");
int _iosys_stat(const char *file, struct stat *pstat)
{
- if(vfs::redirect_to_image(file))
- {
+ if (vfs::redirect_to_image(file)) {
TRACE_SYSCALLN("(%s) -> VFS", file);
return vfs::invoke_fs(&fs::stat, file, *pstat);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", file);
char tmp[PATH_MAX];
- const auto newfile = vfs::npath_translate(file,tmp);
- return real::__xstat(1,newfile,pstat);
+ const auto newfile = vfs::npath_translate(file, tmp);
+ return real::__xstat(1, newfile, pstat);
}
}
__asm__(".symver _iosys_stat,stat@GLIBC_2.2.5");
int _iosys_lstat(const char *pathname, struct stat *statbuf)
{
- if(vfs::redirect_to_image(pathname))
- {
+ if (vfs::redirect_to_image(pathname)) {
TRACE_SYSCALLN("(%s) -> VFS", pathname);
return vfs::invoke_fs(&fs::stat, pathname, *statbuf);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", pathname);
char tmp[PATH_MAX];
- const auto newpath = vfs::npath_translate(pathname,tmp);
- return real::__lxstat(1,newpath,statbuf);
+ const auto newpath = vfs::npath_translate(pathname, tmp);
+ return real::__lxstat(1, newpath, statbuf);
}
}
__asm__(".symver _iosys_lstat,lstat@GLIBC_2.2.5");
int _iosys_fstat(int fd, struct stat *pstat)
{
- if(vfs::is_image_fd(fd))
- {
+ if (vfs::is_image_fd(fd)) {
TRACE_SYSCALLN("(%d) -> VFS", fd);
- return vfs::invoke_fs(&fs::fstat,vfs::to_image_fd(fd),*pstat);
+ return vfs::invoke_fs(&fs::fstat, vfs::to_image_fd(fd), *pstat);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fd);
- return real::__fxstat(1,fd,pstat);
+ return real::__fxstat(1, fd, pstat);
}
}
__asm__(".symver _iosys_fstat,fstat@GLIBC_2.2.5");
- int _iosys_fcntl(int fd, int cmd, ... /* arg */ )
+ int _iosys_fcntl(int fd, int cmd, ... /* arg */)
{
- if(vfs::is_image_fd(fd))
- {
+ if (vfs::is_image_fd(fd)) {
TRACE_SYSCALLN("(%d) -> VFS", fd);
errno = ENOSYS;
std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
return -1;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fd);
uintptr_t param;
va_list args;
- va_start(args,cmd);
- param = va_arg(args,uintptr_t);
- auto ret = real::fcntl(fd, cmd, param );
+ va_start(args, cmd);
+ param = va_arg(args, uintptr_t);
+ auto ret = real::fcntl(fd, cmd, param);
va_end(args);
return ret;
}
}
__asm__(".symver _iosys_fcntl,fcntl@GLIBC_2.2.5");
- int _iosys_fcntl64(int fd, int cmd, ... /* arg */ )
+ int _iosys_fcntl64(int fd, int cmd, ... /* arg */)
{
- if(vfs::is_image_fd(fd))
- {
+ if (vfs::is_image_fd(fd)) {
TRACE_SYSCALLN("(%d) -> VFS", fd);
errno = ENOSYS;
std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
return -1;
- } else {
+ }
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fd);
uintptr_t param;
va_list args;
- va_start(args,cmd);
- param = va_arg(args,uintptr_t);
- auto ret = real::fcntl64(fd, cmd, param);
+ va_start(args, cmd);
+ param = va_arg(args, uintptr_t);
+ auto ret = real::fcntl64(fd, cmd, param);
va_end(args);
return ret;
}
@@ 358,16 344,14 @@ extern "C" {
int _iosys_chdir(const char *path)
{
- if(vfs::redirect_to_image(path))
- {
+ if (vfs::redirect_to_image(path)) {
TRACE_SYSCALLN("(%s) -> VFS", path);
return vfs::invoke_fs(&fs::chdir, path);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", path);
char tmp[PATH_MAX];
- const auto newpath = vfs::npath_translate(path,tmp);
+ const auto newpath = vfs::npath_translate(path, tmp);
return real::chdir(newpath);
}
}
@@ 375,15 359,13 @@ extern "C" {
int _iosys_fchdir(int fd)
{
- if(vfs::is_image_fd(fd))
- {
+ if (vfs::is_image_fd(fd)) {
TRACE_SYSCALLN("(%d) -> VFS", fd);
errno = ENOSYS;
std::cerr << "Unsupported syscall " << __PRETTY_FUNCTION__ << std::endl;
return -1;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fd);
return real::fchdir(fd);
}
@@ 392,67 374,60 @@ extern "C" {
char *_iosys_getcwd(char *buf, size_t size)
{
- if(vfs::redirect_to_image())
- {
+ if (vfs::redirect_to_image()) {
TRACE_SYSCALLN("%s", "() -> VFS");
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
errno = EIO;
return nullptr;
}
auto xwd = vfs->getcwd();
- xwd.copy(buf,size);
+ xwd.copy(buf, size);
return buf;
}
- else
- {
+ else {
TRACE_SYSCALLN("%s", "() -> linux fs");
- return real::getcwd(buf,size);
+ return real::getcwd(buf, size);
}
}
__asm__(".symver _iosys_getcwd,getcwd@GLIBC_2.2.5");
char *_iosys_getwd(char *buf)
{
- if(vfs::redirect_to_image())
- {
+ if (vfs::redirect_to_image()) {
TRACE_SYSCALLN("%s", "() -> VFS");
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
errno = EIO;
return nullptr;
}
auto xwd = vfs->getcwd();
- xwd.copy(buf,xwd.size());
+ xwd.copy(buf, xwd.size());
return buf;
}
- else
- {
+ else {
TRACE_SYSCALLN("%s", "() -> linux fs");
return real::getwd(buf);
}
}
__asm__(".symver _iosys_getwd,getwd@GLIBC_2.2.5");
-
char *_iosys_get_current_dir_name(void)
{
- if(vfs::redirect_to_image())
- {
+ if (vfs::redirect_to_image()) {
TRACE_SYSCALLN("%s", "() -> VFS");
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
errno = EIO;
return nullptr;
}
auto xwd = vfs->getcwd();
- auto ret = new char[xwd.size()+1];
- xwd.copy(ret,xwd.size());
+ auto ret = new char[xwd.size() + 1];
+ xwd.copy(ret, xwd.size());
ret[xwd.size()] = '\0';
return ret;
}
- else
- {
+ else {
TRACE_SYSCALLN("%s", "() -> linux fs");
return real::get_current_dir_name();
}
@@ 461,62 436,54 @@ extern "C" {
int _iosys_mkdir(const char *pathname, mode_t mode)
{
- if(vfs::redirect_to_image(pathname))
- {
+ if (vfs::redirect_to_image(pathname)) {
TRACE_SYSCALLN("(%s) -> VFS", pathname);
return vfs::invoke_fs(&fs::mkdir, pathname, mode);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", pathname);
char tmp[PATH_MAX];
- const auto path = vfs::npath_translate(pathname,tmp);
- return real::mkdir(path,mode);
+ const auto path = vfs::npath_translate(pathname, tmp);
+ return real::mkdir(path, mode);
}
}
__asm__(".symver _iosys_mkdir,mkdir@GLIBC_2.2.5");
int _iosys_chmod(const char *pathname, mode_t mode)
{
- if(vfs::redirect_to_image(pathname))
- {
+ if (vfs::redirect_to_image(pathname)) {
TRACE_SYSCALLN("(%s) -> VFS", pathname);
- return vfs::invoke_fs(&fs::chmod,pathname,mode);
+ return vfs::invoke_fs(&fs::chmod, pathname, mode);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", pathname);
char tmp[PATH_MAX];
- const auto path = vfs::npath_translate(pathname,tmp);
- return real::chmod(path,mode);
+ const auto path = vfs::npath_translate(pathname, tmp);
+ return real::chmod(path, mode);
}
}
__asm__(".symver _iosys_chmod,chmod@GLIBC_2.2.5");
int _iosys_fchmod(int fd, mode_t mode)
{
- if(vfs::is_image_fd(fd))
- {
+ if (vfs::is_image_fd(fd)) {
TRACE_SYSCALLN("(%d) -> VFS", fd);
- return vfs::invoke_fs(&fs::fchmod,vfs::to_image_fd(fd),mode);
+ return vfs::invoke_fs(&fs::fchmod, vfs::to_image_fd(fd), mode);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fd);
- return real::fchmod(fd,mode);
+ return real::fchmod(fd, mode);
}
}
__asm__(".symver _iosys_fchmod,fchmod@GLIBC_2.2.5");
int _iosys_fsync(int fd)
{
- if(vfs::is_image_fd(fd))
- {
+ if (vfs::is_image_fd(fd)) {
TRACE_SYSCALLN("(%d) -> VFS", fd);
return vfs::invoke_fs(&fs::fsync, vfs::to_image_fd(fd));
}
- else
- {
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fd);
return real::fsync(fd);
}
@@ 525,13 492,11 @@ extern "C" {
int _iosys_fdatasync(int fd)
{
- if(vfs::is_image_fd(fd))
- {
+ if (vfs::is_image_fd(fd)) {
TRACE_SYSCALLN("(%d) -> VFS", fd);
return vfs::invoke_fs(&fs::fsync, vfs::to_image_fd(fd));
}
- else
- {
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fd);
return real::fdatasync(fd);
}
@@ 540,67 505,59 @@ extern "C" {
int _iosys_symlink(const char *target, const char *linkpath)
{
- if(vfs::redirect_to_image(target))
- {
+ if (vfs::redirect_to_image(target)) {
TRACE_SYSCALLN("(%s,%s) -> VFS", target, linkpath);
- return vfs::invoke_fs(&fs::symlink,target,linkpath);
+ return vfs::invoke_fs(&fs::symlink, target, linkpath);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s,%s) -> linux fs", target, linkpath);
char tmp[PATH_MAX], tmp2[PATH_MAX];
- const auto tgtp = vfs::npath_translate(target,tmp);
- const auto linp = vfs::npath_translate(linkpath,tmp2);
- return real::symlink(tgtp,linp);
+ const auto tgtp = vfs::npath_translate(target, tmp);
+ const auto linp = vfs::npath_translate(linkpath, tmp2);
+ return real::symlink(tgtp, linp);
}
}
__asm__(".symver _iosys_symlink,symlink@GLIBC_2.2.5");
- int _iosys_xstat(int ver, const char * path, struct stat * stat_buf)
+ int _iosys_xstat(int ver, const char *path, struct stat *stat_buf)
{
- if(vfs::redirect_to_image(path))
- {
+ if (vfs::redirect_to_image(path)) {
TRACE_SYSCALLN("(%s) -> VFS", path);
return vfs::invoke_fs(&fs::stat, path, *stat_buf);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", path);
char tmp[PATH_MAX];
- const auto newp = vfs::npath_translate(path,tmp);
- return real::__xstat(ver,newp,stat_buf);
+ const auto newp = vfs::npath_translate(path, tmp);
+ return real::__xstat(ver, newp, stat_buf);
}
}
__asm__(".symver _iosys_xstat,__xstat@GLIBC_2.2.5");
- int _iosys_lxstat(int ver, const char * path, struct stat * stat_buf)
+ int _iosys_lxstat(int ver, const char *path, struct stat *stat_buf)
{
- if(vfs::redirect_to_image(path))
- {
+ if (vfs::redirect_to_image(path)) {
TRACE_SYSCALLN("(%s) -> VFS", path);
return vfs::invoke_fs(&fs::stat, path, *stat_buf);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", path);
char tmp[PATH_MAX];
- const auto newp = vfs::npath_translate(path,tmp);
- return real::__lxstat(ver,newp,stat_buf);
+ const auto newp = vfs::npath_translate(path, tmp);
+ return real::__lxstat(ver, newp, stat_buf);
}
}
__asm__(".symver _iosys_lxstat,__lxstat@GLIBC_2.2.5");
- int _iosys_fxstat(int ver, int fildes, struct stat * stat_buf)
+ int _iosys_fxstat(int ver, int fildes, struct stat *stat_buf)
{
- if(vfs::is_image_fd(fildes))
- {
+ if (vfs::is_image_fd(fildes)) {
TRACE_SYSCALLN("(%d) -> VFS", fildes);
return vfs::invoke_fs(&fs::fstat, vfs::to_image_fd(fildes), *stat_buf);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fildes);
- return real::__fxstat(ver,fildes,stat_buf);
+ return real::__fxstat(ver, fildes, stat_buf);
}
}
__asm__(".symver _iosys_fxstat,__fxstat@GLIBC_2.2.5");
@@ 613,51 570,45 @@ extern "C" {
}
__asm__(".symver _iosys_fxstatat,__fxstatat@GLIBC_2.4");
- int _iosys_xstat64(int ver, const char * path, struct stat64 * stat_buf)
+ int _iosys_xstat64(int ver, const char *path, struct stat64 *stat_buf)
{
- if(vfs::redirect_to_image(path))
- {
+ if (vfs::redirect_to_image(path)) {
TRACE_SYSCALLN("(%s) -> VFS", path);
- return vfs::invoke_fs(&fs::stat, path, *(struct stat*)stat_buf);
+ return vfs::invoke_fs(&fs::stat, path, *(struct stat *)stat_buf);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", path);
char tmp[PATH_MAX];
- const auto newp = vfs::npath_translate(path,tmp);
- return real::__xstat64(ver,newp,stat_buf);
+ const auto newp = vfs::npath_translate(path, tmp);
+ return real::__xstat64(ver, newp, stat_buf);
}
}
__asm__(".symver _iosys_xstat64,__xstat64@GLIBC_2.2.5");
- int _iosys_lxstat64(int ver, const char * path, struct stat64 * stat_buf)
+ int _iosys_lxstat64(int ver, const char *path, struct stat64 *stat_buf)
{
- if(vfs::redirect_to_image(path))
- {
+ if (vfs::redirect_to_image(path)) {
TRACE_SYSCALLN("(%s) -> VFS", path);
- return vfs::invoke_fs(&fs::stat, path, *(struct stat*)stat_buf);
+ return vfs::invoke_fs(&fs::stat, path, *(struct stat *)stat_buf);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", path);
char tmp[PATH_MAX];
- const auto newp = vfs::npath_translate(path,tmp);
- return real::__lxstat64(ver,newp,stat_buf);
+ const auto newp = vfs::npath_translate(path, tmp);
+ return real::__lxstat64(ver, newp, stat_buf);
}
}
__asm__(".symver _iosys_lxstat64,__lxstat64@GLIBC_2.2.5");
- int _iosys_fxstat64(int ver, int fildes, struct stat64 * stat_buf)
+ int _iosys_fxstat64(int ver, int fildes, struct stat64 *stat_buf)
{
- if(vfs::is_image_fd(fildes))
- {
+ if (vfs::is_image_fd(fildes)) {
TRACE_SYSCALLN("(%d) -> VFS", fildes);
- return vfs::invoke_fs(&fs::fstat, vfs::to_image_fd(fildes), *(struct stat*)stat_buf);
+ return vfs::invoke_fs(&fs::fstat, vfs::to_image_fd(fildes), *(struct stat *)stat_buf);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", fildes);
- return real::__fxstat64(ver,fildes,stat_buf);
+ return real::__fxstat64(ver, fildes, stat_buf);
}
}
__asm__(".symver _iosys_fxstat64,__fxstat64@GLIBC_2.2.5");
@@ 670,39 621,34 @@ extern "C" {
}
__asm__(".symver _iosys_fxstatat64,__fxstatat64@GLIBC_2.4");
- int _iosys_mount (const char *special_file, const char *dir,
- const char *fstype, unsigned long int rwflag,
- const void *data)
+ int _iosys_mount(
+ const char *special_file, const char *dir, const char *fstype, unsigned long int rwflag, const void *data)
{
- if(vfs::redirect_to_image(dir))
- {
+ if (vfs::redirect_to_image(dir)) {
TRACE_SYSCALLN("(%s, %s, %s, %08lx, %p) -> VFS", special_file, dir, fstype, rwflag, data);
- return vfs::invoke_fs(&fs::mount, special_file, dir, fstype, rwflag );
+ return vfs::invoke_fs(&fs::mount, special_file, dir, fstype, rwflag);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s, %s, %s, %08lx,%p) -> linux fs", special_file, dir, fstype, rwflag, data);
return real::mount(special_file, dir, fstype, rwflag, data);
}
}
__asm__(".symver _iosys_mount,mount@GLIBC_2.2.5");
- int _iosys_umount (const char *mount_point)
+ int _iosys_umount(const char *mount_point)
{
- if(vfs::redirect_to_image(mount_point))
- {
+ if (vfs::redirect_to_image(mount_point)) {
TRACE_SYSCALLN("(%s) -> VFS", mount_point);
- return vfs::invoke_fs(&fs::umount, mount_point );
+ return vfs::invoke_fs(&fs::umount, mount_point);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s) -> linux fs", mount_point);
return real::umount(mount_point);
}
}
__asm__(".symver _iosys_umount,umount@GLIBC_2.2.5");
- int _iosys_statvfs (const char *path, struct statvfs *vfstat)
+ int _iosys_statvfs(const char *path, struct statvfs *vfstat)
{
TRACE_SYSCALL();
if (vfs::redirect_to_image(path)) {
M board/linux/libiosyscalls/src/syscalls_posix_dirent.cpp => board/linux/libiosyscalls/src/syscalls_posix_dirent.cpp +70 -79
@@ 12,14 12,17 @@
#include "debug.hpp"
-struct __dirstream {
+struct __dirstream
+{
purefs::fs::filesystem::fsdir dirh;
struct dirent dir_data;
size_t position;
};
-namespace {
- namespace real {
+namespace
+{
+ namespace real
+ {
__REAL_DECL(opendir);
__REAL_DECL(closedir);
__REAL_DECL(readdir);
@@ 42,98 45,90 @@ namespace {
__REAL_DLSYM(seekdir);
__REAL_DLSYM(telldir);
- if (!(real::opendir && real::closedir && real::readdir && real::readdir_r
- && real::rewinddir && real::seekdir && real::telldir))
- {
+ if (!(real::opendir && real::closedir && real::readdir && real::readdir_r && real::rewinddir && real::seekdir &&
+ real::telldir)) {
abort();
}
}
} // namespace
-extern "C" {
+extern "C"
+{
namespace vfs = vfsn::linux::internal;
DIR *_iosys_opendir(const char *dirname)
{
- __dirstream* ret {};
- if(!dirname)
- {
+ __dirstream *ret{};
+ if (!dirname) {
TRACE_SYSCALLN("(%p) invalid argument", dirname);
errno = EINVAL;
return ret;
}
- if( vfs::redirect_to_image(dirname) )
- {
+ if (vfs::redirect_to_image(dirname)) {
TRACE_SYSCALLN("(%s) -> VFS", dirname);
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs)
- {
+ if (!vfs) {
errno = EIO;
}
- else
- {
- ret = new(std::nothrow)__dirstream;
- if(!ret)
- {
+ else {
+ ret = new (std::nothrow) __dirstream;
+ if (!ret) {
errno = ENOMEM;
}
- else
- {
+ else {
ret->position = 0;
- ret->dirh = vfs->diropen(dirname);
- if(!ret->dirh)
- {
+ ret->dirh = vfs->diropen(dirname);
+ if (!ret->dirh) {
delete ret;
errno = EIO;
- ret = nullptr;
+ ret = nullptr;
}
- else if(ret->dirh->error())
- {
+ else if (ret->dirh->error()) {
errno = -ret->dirh->error();
delete ret;
ret = nullptr;
}
}
}
- if(ret) {
+ if (ret) {
vfs::add_DIR_to_image_list(ret);
}
}
- else
- {
+ else {
char tmp[PATH_MAX];
- const auto newpath = vfs::npath_translate(dirname,tmp);
+ const auto newpath = vfs::npath_translate(dirname, tmp);
TRACE_SYSCALLN("(%s) -> (%s) linux fs", dirname, newpath);
ret = real::opendir(newpath);
}
- TRACE_SYSCALLN("(%s)=%p errno=%i",dirname,ret,errno);
+ TRACE_SYSCALLN("(%s)=%p errno=%i", dirname, ret, errno);
return ret;
}
__asm__(".symver _iosys_opendir,opendir@GLIBC_2.2.5");
int _iosys_closedir(DIR *dirp)
{
- int ret {};
+ int ret{};
if (!dirp) {
TRACE_SYSCALLN("(%p) invalid argument", dirp);
errno = EBADF;
return -1;
}
- if(vfs::is_image_DIR(dirp)) {
+ if (vfs::is_image_DIR(dirp)) {
TRACE_SYSCALLN("(%p) -> VFS", dirp);
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
errno = EIO;
return -1;
}
ret = vfs->dirclose(dirp->dirh);
- if(ret < 0) {
+ if (ret < 0) {
errno = -ret;
- ret = -1;
+ ret = -1;
}
vfs::remove_DIR_from_image_list(dirp);
delete dirp;
- } else {
+ }
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", dirp);
ret = real::closedir(dirp);
}
@@ 144,44 139,46 @@ extern "C" {
struct dirent *_iosys_readdir(DIR *dirp)
{
- dirent* ret {};
+ dirent *ret{};
if (!dirp) {
TRACE_SYSCALLN("(%p) invalid argument", dirp);
errno = EBADF;
return ret;
}
- if(vfs::is_image_DIR(dirp)) {
+ if (vfs::is_image_DIR(dirp)) {
TRACE_SYSCALLN("(%p) -> VFS", dirp);
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
errno = EIO;
return ret;
}
std::string fname;
struct stat stdata;
auto res = vfs->dirnext(dirp->dirh, fname, stdata);
- if(res < 0) {
- if(res != -ENODATA) {
+ if (res < 0) {
+ if (res != -ENODATA) {
errno = -res;
}
return ret;
- } else {
+ }
+ else {
if (fname.size() >= sizeof(dirp->dir_data.d_name)) {
errno = EOVERFLOW;
return ret;
}
dirp->position += 1;
- dirp->dir_data.d_ino = stdata.st_ino;
- dirp->dir_data.d_type = S_ISREG(stdata.st_mode)?DT_REG:DT_DIR;
+ dirp->dir_data.d_ino = stdata.st_ino;
+ dirp->dir_data.d_type = S_ISREG(stdata.st_mode) ? DT_REG : DT_DIR;
dirp->dir_data.d_reclen = fname.size();
- std::strncpy(dirp->dir_data.d_name,fname.c_str(), sizeof(dirp->dir_data.d_name)-1);
+ std::strncpy(dirp->dir_data.d_name, fname.c_str(), sizeof(dirp->dir_data.d_name) - 1);
ret = &dirp->dir_data;
}
- } else {
+ }
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", dirp);
ret = real::readdir(dirp);
}
- TRACE_SYSCALLN("(%p)=%p errno=%i", dirp,ret,errno);
+ TRACE_SYSCALLN("(%p)=%p errno=%i", dirp, ret, errno);
return ret;
}
__asm__(".symver _iosys_readdir,readdir@GLIBC_2.2.5");
@@ 193,36 190,38 @@ extern "C" {
errno = EBADF;
return -1;
}
- if(vfs::is_image_DIR(dirp)) {
+ if (vfs::is_image_DIR(dirp)) {
TRACE_SYSCALLN("(%p) -> VFS", dirp);
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
errno = EIO;
return -1;
}
std::string fname;
struct stat stdata;
auto res = vfs->dirnext(dirp->dirh, fname, stdata);
- if(res < 0) {
+ if (res < 0) {
errno = -res;
- res = -1;
+ res = -1;
return res;
- } else {
+ }
+ else {
if (fname.size() >= sizeof(entry->d_name)) {
errno = EOVERFLOW;
return -1;
}
dirp->position += 1;
- entry->d_ino = stdata.st_ino;
- entry->d_type = S_ISREG(stdata.st_mode)?DT_REG:DT_DIR;
+ entry->d_ino = stdata.st_ino;
+ entry->d_type = S_ISREG(stdata.st_mode) ? DT_REG : DT_DIR;
entry->d_reclen = fname.size();
- std::strncpy(entry->d_name,fname.c_str(), sizeof(entry->d_name));
+ std::strncpy(entry->d_name, fname.c_str(), sizeof(entry->d_name));
*result = entry;
return 0;
}
- } else {
+ }
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", dirp);
- return real::readdir_r(dirp,entry,result);
+ return real::readdir_r(dirp, entry, result);
}
}
__asm__(".symver _iosys_readdir_r,readdir_r@GLIBC_2.2.5");
@@ 234,42 233,39 @@ extern "C" {
errno = EBADF;
return;
}
- if(vfs::is_image_DIR(dirp))
- {
+ if (vfs::is_image_DIR(dirp)) {
TRACE_SYSCALLN("(%p) -> VFS", dirp);
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
return;
}
auto res = vfs->dirreset(dirp->dirh);
- if(res < 0) {
+ if (res < 0) {
return;
}
dirp->position = 0;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", dirp);
real::rewinddir(dirp);
}
}
__asm__(".symver _iosys_rewinddir,rewinddir@GLIBC_2.2.5");
- void _iosys_seekdir( DIR *dirp, long int loc)
+ void _iosys_seekdir(DIR *dirp, long int loc)
{
if (!dirp) {
TRACE_SYSCALLN("(%p,%ld) invalid argument", dirp, loc);
errno = EBADF;
return;
}
- if( vfs::is_image_DIR(dirp) )
- {
+ if (vfs::is_image_DIR(dirp)) {
TRACE_SYSCALLN("(%p,%ld) -> VFS", dirp, loc);
if (loc < 0) {
return;
}
auto vfs = purefs::subsystem::vfs_core();
- if(!vfs) {
+ if (!vfs) {
return;
}
if (long(dirp->position) > loc) {
@@ 278,14 274,13 @@ extern "C" {
}
std::string name;
struct stat st;
- while ((long(dirp->position) < loc) && (vfs->dirnext(dirp->dirh,name,st))>=0) {
+ while ((long(dirp->position) < loc) && (vfs->dirnext(dirp->dirh, name, st)) >= 0) {
dirp->position += 1;
}
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p,%ld) -> linux fs", dirp, loc);
- real::seekdir(dirp,loc);
+ real::seekdir(dirp, loc);
}
}
__asm__(".symver _iosys_seekdir,seekdir@GLIBC_2.2.5");
@@ 297,18 292,14 @@ extern "C" {
errno = EBADF;
return -1;
}
- if( vfs::is_image_DIR(dirp) )
- {
+ if (vfs::is_image_DIR(dirp)) {
TRACE_SYSCALLN("(%p) -> VFS", dirp);
return dirp->position;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", dirp);
return real::telldir(dirp);
}
}
__asm__(".symver _iosys_telldir,telldir@GLIBC_2.2.5");
-
}
-
M board/linux/libiosyscalls/src/syscalls_real.hpp => board/linux/libiosyscalls/src/syscalls_real.hpp +2 -2
@@ 4,7 4,7 @@
#pragma once
/* Helpers for intercepting library calls */
-#define __REAL_DECL(fun) decltype(::fun) *fun
+#define __REAL_DECL(fun) decltype(::fun) *fun
#define __REAL_DLSYM(fun) real::fun = reinterpret_cast<decltype(real::fun)>(dlsym(RTLD_NEXT, #fun))
-#include <dlfcn.h> // for dlsym()
+#include <dlfcn.h> // for dlsym()
M board/linux/libiosyscalls/src/syscalls_scan_family.cpp => board/linux/libiosyscalls/src/syscalls_scan_family.cpp +32 -38
@@ 13,42 13,41 @@
namespace
{
- namespace real {
+ namespace real
+ {
__REAL_DECL(ungetc);
__REAL_DECL(vfscanf);
- }
+ } // namespace real
void __attribute__((constructor)) _syscalls_scan_family()
{
__REAL_DLSYM(ungetc);
__REAL_DLSYM(vfscanf);
- if(!(real::ungetc && real::vfscanf)) {
+ if (!(real::ungetc && real::vfscanf)) {
abort();
}
}
-}
+} // namespace
namespace
{
namespace vfs = vfsn::linux::internal;
- using FILEX = vfs::FILEX;
- using fs = purefs::fs::filesystem;
+ using FILEX = vfs::FILEX;
+ using fs = purefs::fs::filesystem;
int ic(FILEX *fp)
{
char ch;
- if(fp->ungetchar>0)
- {
- ch = fp->ungetchar;
+ if (fp->ungetchar > 0) {
+ ch = fp->ungetchar;
fp->ungetchar = -1;
return 0;
}
- else
- {
- auto ret = vfs::invoke_fs(&fs::read,fp->fd,&ch,1);
+ else {
+ auto ret = vfs::invoke_fs(&fs::read, fp->fd, &ch, 1);
fp->error = errno;
- return ret==1?0:ret;
+ return ret == 1 ? 0 : ret;
}
}
@@ 60,7 59,7 @@ namespace
*d++ = c;
}
*d = '\0';
- //ungetc(c, fp);
+ // ungetc(c, fp);
return d == dst;
}
/* t is 1 for char, 2 for short, 4 for int, and 8 for long */
@@ 69,7 68,7 @@ namespace
long n = 0;
int c;
int neg = 0;
- c = ic(fp);
+ c = ic(fp);
if (c == '-') {
neg = 1;
}
@@ 77,13 76,13 @@ namespace
c = ic(fp);
}
if (!isdigit(c) || wid <= 0) {
- ungetc(c, reinterpret_cast<FILE*>(fp));
+ ungetc(c, reinterpret_cast<FILE *>(fp));
return 1;
}
do {
n = n * 10 + c - '0';
} while (isdigit(c = ic(fp)) && --wid > 0);
- ungetc(c, reinterpret_cast<FILE*>(fp));
+ ungetc(c, reinterpret_cast<FILE *>(fp));
if (t == 8) {
*reinterpret_cast<long *>(dst) = neg ? -n : n;
}
@@ 98,46 97,42 @@ namespace
}
return 0;
}
-}
+} // namespace
extern "C"
{
namespace vfs = vfsn::linux::internal;
- using FILEX = vfs::FILEX;
+ using FILEX = vfs::FILEX;
- int ungetc (int __c, FILE *__stream)
+ int ungetc(int __c, FILE *__stream)
{
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
fx->ungetchar = __c;
return 0;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
- return real::ungetc(__c,__stream);
+ return real::ungetc(__c, __stream);
}
}
/* WARNING:
* this implementation of ungetc() is work-in-progress
* and should remain local until FILEX buffering is implemented!
*/
-// __asm__(".symver _iosys_ungetc,ungetc@GLIBC_2.2.5");
+ // __asm__(".symver _iosys_ungetc,ungetc@GLIBC_2.2.5");
- int _iosys_vfscanf (FILE *__restrict fp, const char *__restrict fmt,
- __gnuc_va_list ap)
+ int _iosys_vfscanf(FILE *__restrict fp, const char *__restrict fmt, __gnuc_va_list ap)
{
- if(!vfs::is_filex(fp))
- {
+ if (!vfs::is_filex(fp)) {
TRACE_SYSCALLN("(%p) -> linux fs", fp);
- return real::vfscanf(fp,fmt,ap);
+ return real::vfscanf(fp, fmt, ap);
}
TRACE_SYSCALLN("(%p) -> VFS", fp);
int ret = 0;
int t, c;
int wid = 1 << 20;
- auto fx = reinterpret_cast<FILEX*>(fp);
+ auto fx = reinterpret_cast<FILEX *>(fp);
while (*fmt) {
while (isspace(static_cast<unsigned char>(*fmt))) {
fmt++;
@@ 145,15 140,15 @@ extern "C"
while (isspace(c = ic(fx)))
;
ungetc(c, fp);
- while (*fmt && *fmt != '%' && !isspace((unsigned char) *fmt))
+ while (*fmt && *fmt != '%' && !isspace((unsigned char)*fmt))
if (*fmt++ != ic(fx))
return ret;
if (*fmt != '%')
continue;
fmt++;
- if (isdigit((unsigned char) *fmt)) {
+ if (isdigit((unsigned char)*fmt)) {
wid = 0;
- while (isdigit((unsigned char) *fmt))
+ while (isdigit((unsigned char)*fmt))
wid = wid * 10 + *fmt++ - '0';
}
t = sizeof(int);
@@ 183,8 178,7 @@ extern "C"
}
__asm__(".symver _iosys_vfscanf,vfscanf@GLIBC_2.2.5");
- int _iosys_fscanf (FILE *__restrict fp,
- const char *__restrict fmt, ...)
+ int _iosys_fscanf(FILE *__restrict fp, const char *__restrict fmt, ...)
{
TRACE_SYSCALLN("(%p) -> vfscanf()", fp);
va_list ap;
M board/linux/libiosyscalls/src/syscalls_stdio.cpp => board/linux/libiosyscalls/src/syscalls_stdio.cpp +223 -291
@@ 5,9 5,9 @@
#include <stdio.h>
#include <fcntl.h>
-#include <stdarg.h> // for va_*
-#include <limits.h> // for PATH_MAX
-#include <string.h> // for strlen
+#include <stdarg.h> // for va_*
+#include <limits.h> // for PATH_MAX
+#include <string.h> // for strlen
#include "syscalls_real.hpp"
@@ 15,7 15,8 @@
namespace
{
- namespace real {
+ namespace real
+ {
__REAL_DECL(fprintf);
__REAL_DECL(fwrite);
__REAL_DECL(fread);
@@ 75,13 76,11 @@ namespace
__REAL_DLSYM(remove);
__REAL_DLSYM(rename);
- if (!(real::fprintf && real::fwrite && real::fread && real::fopen && real::fopen64
- && real::fclose && real::fputc && real::fputs && real::putc && real::fgetc
- && real::fgets && real::getc && real::freopen && real::fdopen
- && real::fseek && real::ftell && real::fgetpos && real::fgetpos64
- && real::fsetpos && real::fsetpos64 && real::feof && real::rewind
- && real::fileno && real::ferror && real::fflush && real::remove && real::rename))
- {
+ if (!(real::fprintf && real::fwrite && real::fread && real::fopen && real::fopen64 && real::fclose &&
+ real::fputc && real::fputs && real::putc && real::fgetc && real::fgets && real::getc && real::freopen &&
+ real::fdopen && real::fseek && real::ftell && real::fgetpos && real::fgetpos64 && real::fsetpos &&
+ real::fsetpos64 && real::feof && real::rewind && real::fileno && real::ferror && real::fflush &&
+ real::remove && real::rename)) {
abort();
}
}
@@ 89,56 88,49 @@ namespace
auto fopen_to_open_flags(std::string_view flags)
{
int ret = 0;
- if(!flags.compare("r")) {
+ if (!flags.compare("r")) {
ret = O_RDONLY;
}
- else if(!flags.compare("w")) {
+ else if (!flags.compare("w")) {
ret = O_WRONLY | O_CREAT | O_TRUNC;
}
- else if(!flags.compare("a"))
- {
+ else if (!flags.compare("a")) {
ret = O_WRONLY | O_CREAT | O_APPEND;
}
- else if(!flags.compare("r+"))
- {
+ else if (!flags.compare("r+")) {
ret = O_RDWR;
}
- else if(!flags.compare("w+"))
- {
+ else if (!flags.compare("w+")) {
ret = O_RDWR | O_CREAT | O_TRUNC;
}
- else if(!flags.compare("a+"))
- {
+ else if (!flags.compare("a+")) {
ret = O_RDWR | O_CREAT | O_APPEND;
}
return ret;
}
-}
-
+} // namespace
extern "C"
{
namespace vfs = vfsn::linux::internal;
- using FILEX = vfs::FILEX;
- using fs = purefs::fs::filesystem;
+ using FILEX = vfs::FILEX;
+ using fs = purefs::fs::filesystem;
FILE *_iosys_fopen(const char *pathname, const char *mode)
{
- FILE* ret {};
- if(vfs::redirect_to_image(pathname))
- {
+ FILE *ret{};
+ if (vfs::redirect_to_image(pathname)) {
TRACE_SYSCALLN("(%s,%s) -> VFS", pathname, mode);
- const auto fd = vfs::invoke_fs(&fs::open, pathname, fopen_to_open_flags(mode),0644);
- if(fd >= 0) {
- ret = reinterpret_cast<FILE*>(vfs::allocate_filex(fd));
+ const auto fd = vfs::invoke_fs(&fs::open, pathname, fopen_to_open_flags(mode), 0644);
+ if (fd >= 0) {
+ ret = reinterpret_cast<FILE *>(vfs::allocate_filex(fd));
}
}
- else
- {
+ else {
char tmp[PATH_MAX];
- const auto path = vfs::npath_translate(pathname,tmp);
+ const auto path = vfs::npath_translate(pathname, tmp);
TRACE_SYSCALLN("(%s,%s) -> (%s) linux fs", pathname, mode, path);
- ret = real::fopen(path,mode);
+ ret = real::fopen(path, mode);
}
TRACE_SYSCALLN("(%s,%s)=%p", pathname, mode, ret);
return ret;
@@ 147,18 139,16 @@ extern "C"
FILE *_iosys_fopen64(const char *pathname, const char *mode)
{
- FILE* ret {};
- if(vfs::redirect_to_image(pathname))
- {
+ FILE *ret{};
+ if (vfs::redirect_to_image(pathname)) {
TRACE_SYSCALLN("(%s,%s) -> fopen()", pathname, mode);
return fopen(pathname, mode);
}
- else
- {
+ else {
char tmp[PATH_MAX];
- const auto path = vfs::npath_translate(pathname,tmp);
+ const auto path = vfs::npath_translate(pathname, tmp);
TRACE_SYSCALLN("(%s,%s) -> (%s) linux fs", pathname, mode, path);
- ret = real::fopen64(path,mode);
+ ret = real::fopen64(path, mode);
}
TRACE_SYSCALLN("(%s,%s)=%p", pathname, mode, ret);
return ret;
@@ 167,23 157,19 @@ extern "C"
int _iosys_fclose(FILE *__stream)
{
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
auto ret = vfs::invoke_fs(&fs::close, fx->fd);
- if(!ret)
- {
+ if (!ret) {
vfs::remove_filex(fx);
}
- else
- {
+ else {
fx->error = errno;
}
return ret;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
return real::fclose(__stream);
}
@@ 194,10 180,11 @@ extern "C"
{
if (vfs::is_image_fd(__fd)) {
TRACE_SYSCALLN("(%d) -> VFS", __fd);
- std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
+ std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
errno = ENOTSUP;
return nullptr;
- } else {
+ }
+ else {
TRACE_SYSCALLN("(%d) -> linux fs", __fd);
return real::fdopen(__fd, __modes);
}
@@ 206,50 193,46 @@ extern "C"
int _iosys_feof(FILE *__stream) __THROW
{
- int ret {};
- if(vfs::is_filex(__stream))
- {
+ int ret{};
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
do {
- const auto curr = vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_CUR);
- if(curr<0) {
+ const auto curr = vfs::invoke_fs(&fs::seek, fx->fd, 0, SEEK_CUR);
+ if (curr < 0) {
ret = curr;
break;
}
- const auto ends = vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_END);
- if(ends<0) {
+ const auto ends = vfs::invoke_fs(&fs::seek, fx->fd, 0, SEEK_END);
+ if (ends < 0) {
ret = ends;
break;
}
- const auto restored = vfs::invoke_fs(&fs::seek,fx->fd,curr,SEEK_SET);
- if(restored<0) {
+ const auto restored = vfs::invoke_fs(&fs::seek, fx->fd, curr, SEEK_SET);
+ if (restored < 0) {
ret = restored;
break;
}
ret = curr >= ends;
- } while(0);
+ } while (0);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
ret = real::feof(__stream);
}
- TRACE_SYSCALLN("(%p)=%i",__stream,ret);
+ TRACE_SYSCALLN("(%p)=%i", __stream, ret);
return ret;
}
__asm__(".symver _iosys_feof,feof@GLIBC_2.2.5");
- int _iosys_ferror(FILE * stream) __THROW
+ int _iosys_ferror(FILE *stream) __THROW
{
- if(vfs::is_filex(stream))
- {
+ if (vfs::is_filex(stream)) {
TRACE_SYSCALLN("(%p) -> VFS", stream);
- auto fx = reinterpret_cast<FILEX*>(stream);
+ auto fx = reinterpret_cast<FILEX *>(stream);
return fx->error;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", stream);
return real::ferror(stream);
}
@@ 258,39 241,35 @@ extern "C"
int _iosys_fflush(FILE *__stream)
{
- int ret {};
- if(vfs::is_filex(__stream))
- {
+ int ret{};
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- ret = vfs::invoke_fs(&fs::fsync, fx->fd);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ ret = vfs::invoke_fs(&fs::fsync, fx->fd);
fx->error = errno;
}
- else
- {
+ else {
if (__stream != stdout && __stream != stderr)
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
ret = real::fflush(__stream);
}
if (__stream != stdout && __stream != stderr)
- TRACE_SYSCALLN("(%p)=%i",__stream,ret);
+ TRACE_SYSCALLN("(%p)=%i", __stream, ret);
return ret;
}
__asm__(".symver _iosys_fflush,fflush@GLIBC_2.2.5");
int _iosys_fgetc(FILE *__stream)
{
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
char ch;
- auto ret = vfs::invoke_fs(&fs::read,fx->fd,&ch,1);
+ auto ret = vfs::invoke_fs(&fs::read, fx->fd, &ch, 1);
fx->error = errno;
return ret;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
return real::fgetc(__stream);
}
@@ 299,19 278,17 @@ extern "C"
int _iosys_fgetpos(FILE *__restrict __stream, fpos_t *__restrict __pos)
{
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- auto ret = vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_CUR);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ auto ret = vfs::invoke_fs(&fs::seek, fx->fd, 0, SEEK_CUR);
fx->error = errno;
- if(__pos) {
- __pos->__pos = ret;
+ if (__pos) {
+ __pos->__pos = ret;
}
- return (ret>=0)?(0):(-1);
+ return (ret >= 0) ? (0) : (-1);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
return real::fgetpos(__stream, __pos);
}
@@ 320,19 297,17 @@ extern "C"
int _iosys_fgetpos64(FILE *__restrict __stream, fpos64_t *__restrict __pos)
{
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- auto ret = vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_CUR);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ auto ret = vfs::invoke_fs(&fs::seek, fx->fd, 0, SEEK_CUR);
fx->error = errno;
- if(__pos) {
- __pos->__pos = ret;
+ if (__pos) {
+ __pos->__pos = ret;
}
- return (ret>=0)?(0):(-1);
+ return (ret >= 0) ? (0) : (-1);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
return real::fgetpos64(__stream, __pos);
}
@@ 341,51 316,46 @@ extern "C"
char *_iosys_fgets(char *__restrict __s, int __n, FILE *__restrict __stream)
{
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
char ch;
size_t pos = 0;
do {
- auto ret = vfs::invoke_fs(&fs::read,fx->fd,&ch,1);
- if(ret == 0)
- {
+ auto ret = vfs::invoke_fs(&fs::read, fx->fd, &ch, 1);
+ if (ret == 0) {
fx->error = 0;
return nullptr;
}
- else if(ret<0)
- {
+ else if (ret < 0) {
fx->error = errno;
return nullptr;
- } else {
+ }
+ else {
__s[pos++] = ch;
}
- } while(ch == '\n');
+ } while (ch == '\n');
return __s;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
- return real::fgets(__s,__n,__stream);
+ return real::fgets(__s, __n, __stream);
}
}
__asm__(".symver _iosys_fgets,fgets@GLIBC_2.2.5");
int _iosys_fileno(FILE *__stream) __THROW
{
- int ret {};
- if(vfs::is_filex(__stream))
- {
+ int ret{};
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- ret = vfs::to_native_fd(reinterpret_cast<FILEX*>(__stream)->fd);
+ ret = vfs::to_native_fd(reinterpret_cast<FILEX *>(__stream)->fd);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
ret = real::fileno(__stream);
}
- TRACE_SYSCALLN("(%p)=%i",__stream,ret);
+ TRACE_SYSCALLN("(%p)=%i", __stream, ret);
return ret;
}
__asm__(".symver _iosys_fileno,fileno@GLIBC_2.2.5");
@@ 398,23 368,22 @@ extern "C"
char *pcBuffer;
va_list xArgs;
- if(!vfs::is_filex(__stream))
- {
+ if (!vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
va_list arglist;
- va_start( arglist, __format );
- auto ret = vfprintf( __stream, __format, arglist );
- va_end( arglist );
+ va_start(arglist, __format);
+ auto ret = vfprintf(__stream, __format, arglist);
+ va_end(arglist);
return ret;
}
TRACE_SYSCALLN("(%p) -> VFS", __stream);
pcBuffer = new char[buf_len];
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
if (pcBuffer == NULL) {
/* Store the errno to thread local storage. */
fx->error = ENOMEM;
- iCount = -1;
+ iCount = -1;
}
else {
va_start(xArgs, __format);
@@ 428,7 397,7 @@ extern "C"
iCount = -1;
}
}
- delete [] pcBuffer;
+ delete[] pcBuffer;
}
fx->error = errno;
return iCount;
@@ 437,272 406,244 @@ extern "C"
int _iosys_fputc(int __c, FILE *__stream)
{
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p,%d) -> VFS", __stream, __c);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- char ch = __c;
- int ret = vfs::invoke_fs(&fs::write,fx->fd, &ch, sizeof ch);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ char ch = __c;
+ int ret = vfs::invoke_fs(&fs::write, fx->fd, &ch, sizeof ch);
fx->error = errno;
- return ret==1?0:ret;
+ return ret == 1 ? 0 : ret;
}
- else
- {
+ else {
if (__stream != stdout && __stream != stderr)
TRACE_SYSCALLN("(%p,%d) -> linux fs", __stream, __c);
- return real::fputc( __c, __stream );
+ return real::fputc(__c, __stream);
}
}
__asm__(".symver _iosys_fputc,fputc@GLIBC_2.2.5");
int _iosys_fputs(const char *__restrict __s, FILE *__restrict __stream)
{
- int ret {};
- if(vfs::is_filex(__stream))
- {
+ int ret{};
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p,%p) -> VFS", __s, __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
const auto len = strlen(__s);
- ret = vfs::invoke_fs(&fs::write,fx->fd, __s, len);
- fx->error = errno;
- ret = ret==int(len)?0:-1;
+ ret = vfs::invoke_fs(&fs::write, fx->fd, __s, len);
+ fx->error = errno;
+ ret = ret == int(len) ? 0 : -1;
}
- else
- {
+ else {
if (__stream != stdout && __stream != stderr)
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
- ret = real::fputs( __s, __stream );
+ ret = real::fputs(__s, __stream);
}
if (__stream != stdout && __stream != stderr)
- TRACE_SYSCALLN("(%s, %p)=%i",__s, __stream, ret);
+ TRACE_SYSCALLN("(%s, %p)=%i", __s, __stream, ret);
return ret;
}
__asm__(".symver _iosys_fputs,fputs@GLIBC_2.2.5");
size_t _iosys_fread(void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream)
{
- size_t ret {};
- if(__size!=0 && __n!=0)
- {
- if(vfs::is_filex(__stream))
- {
+ size_t ret{};
+ if (__size != 0 && __n != 0) {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- char* p = reinterpret_cast<char*>(__ptr);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ char *p = reinterpret_cast<char *>(__ptr);
do {
- auto res = vfs::invoke_fs(&fs::read, fx->fd, p, __size);
- const auto eof = res>0 && size_t(res)<__size;
- fx->error = errno;
- if(res<0 || eof) break;
+ auto res = vfs::invoke_fs(&fs::read, fx->fd, p, __size);
+ const auto eof = res > 0 && size_t(res) < __size;
+ fx->error = errno;
+ if (res < 0 || eof)
+ break;
p += __size;
--__n;
++ret;
- } while(__n > 0 );
+ } while (__n > 0);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
- ret = real::fread(__ptr,__size,__n,__stream);
+ ret = real::fread(__ptr, __size, __n, __stream);
}
}
- TRACE_SYSCALLN("(%p, %lu, %lu, %p)=%i",__ptr,__size,__n,__stream, ret);
+ TRACE_SYSCALLN("(%p, %lu, %lu, %p)=%i", __ptr, __size, __n, __stream, ret);
return ret;
}
__asm__(".symver _iosys_fread,fread@GLIBC_2.2.5");
-
- FILE *_iosys_freopen (const char *__restrict __filename,
- const char *__restrict __modes,
- FILE *__restrict __stream)
+ FILE *_iosys_freopen(const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream)
{
- if(vfs::is_filex(__filename))
- {
+ if (vfs::is_filex(__filename)) {
TRACE_SYSCALLN("(%s,%s) -> VFS", __filename, __modes);
- if( fclose(__stream) < 0) {
+ if (fclose(__stream) < 0) {
return nullptr;
}
- return fopen(__filename, __modes );
+ return fopen(__filename, __modes);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%s,%s) -> linux fs", __filename, __modes);
- return real::freopen(__filename,__modes,__stream);
+ return real::freopen(__filename, __modes, __stream);
}
}
__asm__(".symver _iosys_freopen,freopen@GLIBC_2.2.5");
- int _iosys_fseek (FILE *__stream, long int __off, int __whence)
+ int _iosys_fseek(FILE *__stream, long int __off, int __whence)
{
- int ret {};
- if(vfs::is_filex(__stream))
- {
+ int ret{};
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- ret = vfs::invoke_fs(&fs::seek, fx->fd, __off, __whence);
- ret = (ret>0) ? 0 : ret;
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ ret = vfs::invoke_fs(&fs::seek, fx->fd, __off, __whence);
+ ret = (ret > 0) ? 0 : ret;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
- ret = real::fseek(__stream,__off,__whence);
+ ret = real::fseek(__stream, __off, __whence);
}
- TRACE_SYSCALLN("(%p, %li, %i)=%i",__stream,__off,__whence,ret);
+ TRACE_SYSCALLN("(%p, %li, %i)=%i", __stream, __off, __whence, ret);
return ret;
}
__asm__(".symver _iosys_fseek,fseek@GLIBC_2.2.5");
- int _iosys_fsetpos (FILE *__stream, const fpos_t *__pos)
+ int _iosys_fsetpos(FILE *__stream, const fpos_t *__pos)
{
TRACE_SYSCALL();
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
auto ret = vfs::invoke_fs(&fs::seek, fx->fd, __pos->__pos, SEEK_SET);
- return (ret>0) ? 0 : ret;
+ return (ret > 0) ? 0 : ret;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
- return real::fsetpos(__stream,__pos);
+ return real::fsetpos(__stream, __pos);
}
}
__asm__(".symver _iosys_fsetpos,fsetpos@GLIBC_2.2.5");
- int _iosys_fsetpos64 (FILE *__stream, const fpos64_t *__pos)
+ int _iosys_fsetpos64(FILE *__stream, const fpos64_t *__pos)
{
- if(vfs::is_filex(__stream)) {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
auto ret = vfs::invoke_fs(&fs::seek, fx->fd, __pos->__pos, SEEK_SET);
- return (ret>0) ? 0 : ret;
+ return (ret > 0) ? 0 : ret;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
- return real::fsetpos64(__stream,__pos);
+ return real::fsetpos64(__stream, __pos);
}
}
__asm__(".symver _iosys_fsetpos64,fsetpos64@GLIBC_2.2.5");
-
- long int _iosys_ftell (FILE *__stream)
+ long int _iosys_ftell(FILE *__stream)
{
- long int ret {};
- if(vfs::is_filex(__stream))
- {
+ long int ret{};
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- ret = vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_CUR);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ ret = vfs::invoke_fs(&fs::seek, fx->fd, 0, SEEK_CUR);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
ret = real::ftell(__stream);
}
- TRACE_SYSCALLN("(%p)=%i",__stream, ret);
+ TRACE_SYSCALLN("(%p)=%i", __stream, ret);
return ret;
}
__asm__(".symver _iosys_ftell,ftell@GLIBC_2.2.5");
- size_t _iosys_fwrite (const void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __s)
+ size_t _iosys_fwrite(const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __s)
{
- int ret {};
- if(__size != 0 && __n != 0)
- {
- if(vfs::is_filex(__s))
- {
+ int ret{};
+ if (__size != 0 && __n != 0) {
+ if (vfs::is_filex(__s)) {
TRACE_SYSCALLN("(%p) -> VFS", __s);
- auto fx = reinterpret_cast<FILEX*>(__s);
- const char* p = reinterpret_cast<const char*>(__ptr);
- size_t items {};
+ auto fx = reinterpret_cast<FILEX *>(__s);
+ const char *p = reinterpret_cast<const char *>(__ptr);
+ size_t items{};
do {
- auto ret = vfs::invoke_fs(&fs::write, fx->fd, p, __size);
- const auto eof = ret>=0 && size_t(ret)!=__size;
- fx->error = errno;
- if(ret<0 || eof) return ret;
+ auto ret = vfs::invoke_fs(&fs::write, fx->fd, p, __size);
+ const auto eof = ret >= 0 && size_t(ret) != __size;
+ fx->error = errno;
+ if (ret < 0 || eof)
+ return ret;
p += __size;
--__n;
++items;
- } while(__n > 0 );
- ret = (ret<0) ? (-1) : (items);
+ } while (__n > 0);
+ ret = (ret < 0) ? (-1) : (items);
}
- else
- {
+ else {
if (__s != stdout && __s != stderr)
TRACE_SYSCALLN("(%p) -> linux fs", __s);
- ret = real::fwrite( __ptr, __size, __n, __s );
+ ret = real::fwrite(__ptr, __size, __n, __s);
}
}
if (__s != stdout && __s != stderr)
- TRACE_SYSCALLN("(ptr: %p,size: %lu, n: %lu, fil: %p)=%i",__ptr,__size,__n,__s,ret);
+ TRACE_SYSCALLN("(ptr: %p,size: %lu, n: %lu, fil: %p)=%i", __ptr, __size, __n, __s, ret);
return ret;
}
__asm__(".symver _iosys_fwrite,fwrite@GLIBC_2.2.5");
int _iosys_getc(FILE *__stream)
{
- int ret {};
- if(vfs::is_filex(__stream))
- {
+ int ret{};
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
char ch;
- ret = vfs::invoke_fs(&fs::read,fx->fd,&ch,1);
+ ret = vfs::invoke_fs(&fs::read, fx->fd, &ch, 1);
fx->error = errno;
- ret = (ret==1)?(ch):(ret);
+ ret = (ret == 1) ? (ch) : (ret);
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
ret = real::getc(__stream);
}
- TRACE_SYSCALLN("(%p)=%i",__stream, ret);
+ TRACE_SYSCALLN("(%p)=%i", __stream, ret);
return ret;
}
__asm__(".symver _iosys_getc,getc@GLIBC_2.2.5");
int _iosys_putc(int __c, FILE *__stream)
{
- int ret {};
- if(vfs::is_filex(__stream))
- {
+ int ret{};
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- char ch = __c;
- ret = vfs::invoke_fs(&fs::write,fx->fd, &ch, sizeof ch);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ char ch = __c;
+ ret = vfs::invoke_fs(&fs::write, fx->fd, &ch, sizeof ch);
fx->error = errno;
- ret = (ret==1)?(__c):(EOF);
+ ret = (ret == 1) ? (__c) : (EOF);
}
- else
- {
+ else {
if (__stream != stdout && __stream != stderr)
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
- ret = real::putc( __c, __stream );
+ ret = real::putc(__c, __stream);
}
if (__stream != stdout && __stream != stderr)
- TRACE_SYSCALLN("(%i %p)=%i",__c,__stream, ret);
+ TRACE_SYSCALLN("(%i %p)=%i", __c, __stream, ret);
return ret;
}
__asm__(".symver _iosys_putc,putc@GLIBC_2.2.5");
- int _iosys_remove (const char *__filename) __THROW
+ int _iosys_remove(const char *__filename) __THROW
{
- int ret {};
- if(vfs::redirect_to_image(__filename))
- {
+ int ret{};
+ if (vfs::redirect_to_image(__filename)) {
TRACE_SYSCALLN("(%s) -> VFS", __filename);
ret = vfs::invoke_fs(&fs::unlink, __filename);
}
- else
- {
+ else {
char tmp[PATH_MAX];
- const auto npath = vfs::npath_translate(__filename,tmp);
+ const auto npath = vfs::npath_translate(__filename, tmp);
TRACE_SYSCALLN("(%s) -> (%s) linux fs", __filename, npath);
ret = real::remove(npath);
}
- TRACE_SYSCALLN("(%s)=%i",__filename, ret);
+ TRACE_SYSCALLN("(%s)=%i", __filename, ret);
return ret;
}
__asm__(".symver _iosys_remove,remove@GLIBC_2.2.5");
@@ 710,75 651,66 @@ extern "C"
int _iosys_rename(const char *oldpath, const char *newpath)
{
TRACE_SYSCALL();
- if(vfs::redirect_to_image(oldpath))
- {
+ if (vfs::redirect_to_image(oldpath)) {
TRACE_SYSCALLN("(%s,%s) -> VFS", oldpath, newpath);
return vfs::invoke_fs(&fs::rename, oldpath, newpath);
}
- else
- {
+ else {
char tmp[PATH_MAX], tmp2[PATH_MAX];
- const auto oldp = vfs::npath_translate(oldpath,tmp);
- const auto newp = vfs::npath_translate(newpath,tmp2);
+ const auto oldp = vfs::npath_translate(oldpath, tmp);
+ const auto newp = vfs::npath_translate(newpath, tmp2);
TRACE_SYSCALLN("(%s,%s) -> (%s,%s) linux fs", oldpath, newpath, oldp, newp);
- return real::rename(oldp,newp);
+ return real::rename(oldp, newp);
}
}
__asm__(".symver _iosys_rename,rename@GLIBC_2.2.5");
- void _iosys_rewind (FILE *__stream)
+ void _iosys_rewind(FILE *__stream)
{
- if(vfs::is_filex(__stream))
- {
+ if (vfs::is_filex(__stream)) {
TRACE_SYSCALLN("(%p) -> VFS", __stream);
- auto fx = reinterpret_cast<FILEX*>(__stream);
- vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_SET);
+ auto fx = reinterpret_cast<FILEX *>(__stream);
+ vfs::invoke_fs(&fs::seek, fx->fd, 0, SEEK_SET);
fx->error = errno;
}
- else
- {
+ else {
TRACE_SYSCALLN("(%p) -> linux fs", __stream);
real::rewind(__stream);
}
}
__asm__(".symver _iosys_rewind,rewind@GLIBC_2.2.5");
-
- void _iosys_setbuf (FILE *__restrict , char *__restrict ) __THROW
+ void _iosys_setbuf(FILE *__restrict, char *__restrict) __THROW
{
TRACE_SYSCALL();
- std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
+ std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
errno = ENOTSUP;
}
__asm__(".symver _iosys_setbuf,setbuf@GLIBC_2.2.5");
- int _iosys_setvbuf (FILE *__restrict __stream, char *__restrict __buf,
- int __modes, size_t __n) __THROW
+ int _iosys_setvbuf(FILE *__restrict __stream, char *__restrict __buf, int __modes, size_t __n) __THROW
{
TRACE_SYSCALL();
- std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
+ std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
errno = ENOTSUP;
return 0;
}
__asm__(".symver _iosys_setvbuf,setvbuf@GLIBC_2.2.5");
-
- void _iosys_setbuffer (FILE *__restrict __stream, char *__restrict __buf,
- size_t __size) __THROW
+ void _iosys_setbuffer(FILE *__restrict __stream, char *__restrict __buf, size_t __size) __THROW
{
TRACE_SYSCALL();
- std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
+ std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
errno = ENOTSUP;
}
__asm__(".symver _iosys_setbuffer,setbuffer@GLIBC_2.2.5");
/* Make STREAM line-buffered. */
- void _iosys_setlinebuf (FILE *__stream) __THROW
+ void _iosys_setlinebuf(FILE *__stream) __THROW
{
TRACE_SYSCALL();
errno = ENOTSUP;
- std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
+ std::cerr << "Unimplemented syscall " << __PRETTY_FUNCTION__ << std::endl;
}
__asm__(".symver _iosys_setlinebuf,setlinebuf@GLIBC_2.2.5");
-
}
M board/linux/libiosyscalls/test/unittest_iosys.cpp => board/linux/libiosyscalls/test/unittest_iosys.cpp +6 -4
@@ 16,16 16,18 @@ TEST_CASE("VFS linux support")
static constexpr auto filenm = "assets/lang/English.json";
- SECTION("std::filesystem") {
+ SECTION("std::filesystem")
+ {
REQUIRE(std::filesystem::file_size(filenm) > 0);
}
- SECTION("iterators") {
+ SECTION("iterators")
+ {
std::ifstream myfile(filenm);
- REQUIRE (myfile.is_open());
+ REQUIRE(myfile.is_open());
auto __first = std::istreambuf_iterator<char>(myfile);
- auto __last = std::istreambuf_iterator<char>();
+ auto __last = std::istreambuf_iterator<char>();
std::vector<char> testvec(__first, __last);
testvec.push_back('\0');
M board/linux/macros.h => board/linux/macros.h +34 -35
@@ 15,54 15,54 @@
#include <stdint.h>
#define _STRINGIFY(s) #s
-#define STRINGIFY(s) _STRINGIFY(s)
+#define STRINGIFY(s) _STRINGIFY(s)
#define UNUSED(x) ((void)(x))
-#define ALIGN_(n) __attribute__((aligned(n)))
+#define ALIGN_(n) __attribute__((aligned(n)))
-#define CACHEABLE_SECTION_SDRAM(var) var
+#define CACHEABLE_SECTION_SDRAM(var) var
-#define CACHEABLE_SECTION_SDRAM_ALIGN(var,alignbytes) var
+#define CACHEABLE_SECTION_SDRAM_ALIGN(var, alignbytes) var
-#define NONCACHEABLE_SECTION_SDRAM(var) var
+#define NONCACHEABLE_SECTION_SDRAM(var) var
-#define NONCACHEABLE_SECTION_SDRAM_ALIGN(var,alignbytes) var
+#define NONCACHEABLE_SECTION_SDRAM_ALIGN(var, alignbytes) var
-#define NONCACHEABLE_SECTION_INIT(var) var
+#define NONCACHEABLE_SECTION_INIT(var) var
-#define NONCACHEABLE_SECTION_ALIGN_INIT(var, alignbytes) var
+#define NONCACHEABLE_SECTION_ALIGN_INIT(var, alignbytes) var
#define NONCACHEABLE_SECTION(var) var
-#define NONCACHEABLE_SECTION_ALIGN(var, alignbytes) var
+#define NONCACHEABLE_SECTION_ALIGN(var, alignbytes) var
-static inline uint32_t IS_MEM_ADDR_CACHED(void* addr)
+static inline uint32_t IS_MEM_ADDR_CACHED(void *addr)
{
- extern uint32_t __sdram_non_cached_start[];
- extern uint32_t __sdram_non_cached_end[];
- extern uint32_t __ocram_cached_start[];
- extern uint32_t __ocram_cached_end[];
- extern uint32_t __dtcm_ram_start[];
- extern uint32_t __dtcm_ram_end[];
- extern uint32_t __sdram_cached_start[];
- extern uint32_t __sdram_cached_end[];
-
-
- if(((uint32_t*)addr >= (uint32_t*)__sdram_non_cached_start) && ((uint32_t*)addr < (uint32_t*)__sdram_non_cached_end)){
- return 0;
- }
- if(((uint32_t*)addr >= (uint32_t*)__ocram_cached_start) && ((uint32_t*)addr < (uint32_t*)__ocram_cached_end)){
- return 1;
- }
- if(((uint32_t*)addr >= (uint32_t*)__dtcm_ram_start) && ((uint32_t*)addr < (uint32_t*)__dtcm_ram_end)){
- return 0;
- }
- if(((uint32_t*)addr >= (uint32_t*)__sdram_cached_start) && ((uint32_t*)addr < (uint32_t*)__sdram_cached_end)){
- return 1;
- }
-
- assert(0);
+ extern uint32_t __sdram_non_cached_start[];
+ extern uint32_t __sdram_non_cached_end[];
+ extern uint32_t __ocram_cached_start[];
+ extern uint32_t __ocram_cached_end[];
+ extern uint32_t __dtcm_ram_start[];
+ extern uint32_t __dtcm_ram_end[];
+ extern uint32_t __sdram_cached_start[];
+ extern uint32_t __sdram_cached_end[];
+
+ if (((uint32_t *)addr >= (uint32_t *)__sdram_non_cached_start) &&
+ ((uint32_t *)addr < (uint32_t *)__sdram_non_cached_end)) {
+ return 0;
+ }
+ if (((uint32_t *)addr >= (uint32_t *)__ocram_cached_start) && ((uint32_t *)addr < (uint32_t *)__ocram_cached_end)) {
+ return 1;
+ }
+ if (((uint32_t *)addr >= (uint32_t *)__dtcm_ram_start) && ((uint32_t *)addr < (uint32_t *)__dtcm_ram_end)) {
+ return 0;
+ }
+ if (((uint32_t *)addr >= (uint32_t *)__sdram_cached_start) && ((uint32_t *)addr < (uint32_t *)__sdram_cached_end)) {
+ return 1;
+ }
+
+ assert(0);
}
//! Test if in interrupt mode
@@ 71,5 71,4 @@ static inline bool isIRQ()
return false;
}
-
#endif /* MACROS_H_ */
M board/rt1051/newlib/include/sys/mount.h => board/rt1051/newlib/include/sys/mount.h +16 -23
@@ 2,40 2,33 @@
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
#pragma once
-
-
/* These are the fs-independent mount-flags: up to 16 flags are
supported */
enum
{
- MS_RDONLY = 1, /* Mount read-only. */
- MS_NOEXEC = 8, /* Disallow program execution. */
- MS_SYNCHRONOUS = 16, /* Writes are synced at once. */
- MS_REMOUNT = 32, /* Alter flags of a mounted FS. */
- MS_MANDLOCK = 64, /* Allow mandatory locks on an FS. */
- MS_DIRSYNC = 128, /* Directory modifications are synchronous. */
- MS_NOATIME = 1024, /* Do not update access times. */
- MS_NODIRATIME = 2048, /* Do not update directory access times. */
- MS_BIND = 4096, /* Bind directory at different place. */
+ MS_RDONLY = 1, /* Mount read-only. */
+ MS_NOEXEC = 8, /* Disallow program execution. */
+ MS_SYNCHRONOUS = 16, /* Writes are synced at once. */
+ MS_REMOUNT = 32, /* Alter flags of a mounted FS. */
+ MS_MANDLOCK = 64, /* Allow mandatory locks on an FS. */
+ MS_DIRSYNC = 128, /* Directory modifications are synchronous. */
+ MS_NOATIME = 1024, /* Do not update access times. */
+ MS_NODIRATIME = 2048, /* Do not update directory access times. */
+ MS_BIND = 4096, /* Bind directory at different place. */
};
-
-
-
#ifdef __cplusplus
-extern "C" {
+extern "C"
+{
#endif
-/* Mount a filesystem. */
-int mount (const char *special_file, const char *dir,
- const char *fstype, unsigned long int rwflag,
- const void *data);
-
-/* Unmount a filesystem. */
-int umount (const char *special_file);
+ /* Mount a filesystem. */
+ int mount(
+ const char *special_file, const char *dir, const char *fstype, unsigned long int rwflag, const void *data);
+ /* Unmount a filesystem. */
+ int umount(const char *special_file);
#ifdef __cplusplus
}
#endif
-
M board/rt1051/newlib/io_syscalls.cpp => board/rt1051/newlib/io_syscalls.cpp +25 -26
@@ 16,27 16,27 @@ extern "C"
/* File related functions */
int _fstat_r(struct _reent *r, int fd, struct stat *st)
{
- return syscalls::fstat(r->_errno,fd,st);
+ return syscalls::fstat(r->_errno, fd, st);
}
int _open_r(struct _reent *r, const char *file, int flags, int mode)
{
- return syscalls::open(r->_errno,file,flags,mode);
+ return syscalls::open(r->_errno, file, flags, mode);
}
long _close_r(struct _reent *r, int fd)
{
- return syscalls::close(r->_errno,fd);
+ return syscalls::close(r->_errno, fd);
}
long _write_r(struct _reent *r, int fd, const void *buf, size_t cnt)
{
- return syscalls::write(r->_errno,fd,buf,cnt);
+ return syscalls::write(r->_errno, fd, buf, cnt);
}
long _read_r(struct _reent *r, int fd, void *buf, size_t cnt)
{
- return syscalls::read(r->_errno,fd,buf,cnt);
+ return syscalls::read(r->_errno, fd, buf, cnt);
}
off_t _lseek_r(struct _reent *r, int fd, off_t pos, int dir)
{
- return syscalls::lseek(r->_errno,fd,pos,dir);
+ return syscalls::lseek(r->_errno, fd, pos, dir);
}
int _link_r(struct _reent *r, const char *existing, const char *newLink)
@@ 49,40 49,41 @@ extern "C"
}
int _fcntl_r(struct _reent *r, int fd, int cmd, int arg)
{
- return syscalls::fcntl(r->_errno,fd,cmd,arg);
+ return syscalls::fcntl(r->_errno, fd, cmd, arg);
}
int _stat_r(struct _reent *r, const char *file, struct stat *pstat)
{
- return syscalls::stat(r->_errno,file,pstat);
+ return syscalls::stat(r->_errno, file, pstat);
}
/** POSIX directory related funcs */
int chdir(const char *path)
{
- return syscalls::chdir(_REENT->_errno,path);
+ return syscalls::chdir(_REENT->_errno, path);
}
char *getcwd(char *buf, size_t size)
{
- return syscalls::getcwd(_REENT->_errno,buf,size);
+ return syscalls::getcwd(_REENT->_errno, buf, size);
}
int _rename_r(struct _reent *r, const char *oldName, const char *newName)
{
- return syscalls::rename(r->_errno,oldName,newName);
+ return syscalls::rename(r->_errno, oldName, newName);
}
int mkdir(const char *path, uint32_t mode)
{
- return syscalls::mkdir(_REENT->_errno,path,mode);
+ return syscalls::mkdir(_REENT->_errno, path, mode);
}
// Dir entry functionality
int closedir(DIR *dirp)
{
- return syscalls::closedir(_REENT->_errno,dirp);
+ return syscalls::closedir(_REENT->_errno, dirp);
}
DIR *opendir(const char *dirname)
{
return syscalls::opendir(_REENT->_errno, dirname);
}
- struct dirent *readdir(DIR *dirp) {
+ struct dirent *readdir(DIR *dirp)
+ {
return syscalls::readdir(_REENT->_errno, dirp);
}
int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
@@ 95,38 96,36 @@ extern "C"
}
void seekdir(DIR *dirp, long int loc)
{
- syscalls::seekdir(_REENT->_errno, dirp,loc);
+ syscalls::seekdir(_REENT->_errno, dirp, loc);
}
long int telldir(DIR *dirp)
{
return syscalls::telldir(_REENT->_errno, dirp);
}
- int chmod(const char* path, mode_t mode) {
- return syscalls::chmod(_REENT->_errno,path,mode);
+ int chmod(const char *path, mode_t mode)
+ {
+ return syscalls::chmod(_REENT->_errno, path, mode);
}
int fchmod(int fd, mode_t mode)
{
return syscalls::fchmod(_REENT->_errno, fd, mode);
}
- int fsync( int fd ) {
+ int fsync(int fd)
+ {
return syscalls::fsync(_REENT->_errno, fd);
}
int statvfs(const char *path, struct statvfs *buf)
{
- return syscalls::statvfs( _REENT->_errno, path,buf);
+ return syscalls::statvfs(_REENT->_errno, path, buf);
}
/* Mount a filesystem. */
- int mount (const char *special_file, const char *dir,
- const char *fstype, unsigned long int rwflag,
- const void *data)
+ int mount(const char *special_file, const char *dir, const char *fstype, unsigned long int rwflag, const void *data)
{
- return syscalls::mount(_REENT->_errno, special_file, dir,
- fstype, rwflag, data );
+ return syscalls::mount(_REENT->_errno, special_file, dir, fstype, rwflag, data);
}
/* Unmount a filesystem. */
- int umount (const char *special_file)
+ int umount(const char *special_file)
{
return syscalls::umount(_REENT->_errno, special_file);
}
}
-
M config/format-config.sh => config/format-config.sh +4 -2
@@ 1,5 1,5 @@
#!/bin/bash -e
-# Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+# Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
# For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
# config file for pre-commit.hook clang-format
@@ 15,7 15,9 @@ VERBOSE=1
# if you don't wish to format i.e one file - just pass whole path to this file from git root directory
declare ignore_paths=(
'./module-os/'
- './board/'
+ './board/rt1051/xip/'
+ './board/rt1051/newlib/dir-common.h'
+ './board/rt1051/newlib/include/'
'./module-bsp/bsp/'
'./module-bsp/board/rt1051/common/fsl_drivers/'
'./module-bsp/board/rt1051/common/board.cpp'