From 7d06115f3e75e726d48691609f73589308a1c12e Mon Sep 17 00:00:00 2001 From: "Wiktor S. Ovalle Correa" Date: Tue, 19 Jan 2021 13:17:59 +0100 Subject: [PATCH] [EGD-5318] Fix coding style in board/ Code style check was disabled for board/ subfolder. This commit fixes coding and enables style check for this folder. --- .vscode/settings.json | 6 +- board/linux/libiosyscalls/include/debug.hpp | 19 +- .../libiosyscalls/include/iosyscalls.hpp | 37 +- board/linux/libiosyscalls/src/iosyscalls.cpp | 111 ++-- .../libiosyscalls/src/syscalls_posix.cpp | 362 ++++++------ .../src/syscalls_posix_dirent.cpp | 149 +++-- .../linux/libiosyscalls/src/syscalls_real.hpp | 4 +- .../src/syscalls_scan_family.cpp | 70 ++- .../libiosyscalls/src/syscalls_stdio.cpp | 514 ++++++++---------- .../libiosyscalls/test/unittest_iosys.cpp | 10 +- board/linux/macros.h | 69 ++- board/rt1051/newlib/include/sys/mount.h | 39 +- board/rt1051/newlib/io_syscalls.cpp | 51 +- config/format-config.sh | 6 +- 14 files changed, 654 insertions(+), 793 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 78a754658a9dcbcf0befaa88af0256baa2fce4fe..4affeee4145e37975388ce8fdb0a72318ad5cc6e 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -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 diff --git a/board/linux/libiosyscalls/include/debug.hpp b/board/linux/libiosyscalls/include/debug.hpp index b8a241b904690560aa15875a0f64f22a70fc0a03..3a990ec925cbc6bd54f2294dbb5dc98cf53a3016 100644 --- a/board/linux/libiosyscalls/include/debug.hpp +++ b/board/linux/libiosyscalls/include/debug.hpp @@ -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 diff --git a/board/linux/libiosyscalls/include/iosyscalls.hpp b/board/linux/libiosyscalls/include/iosyscalls.hpp index 8dee370538d3c64b2e670d1994da7370faa577bd..3b34f0bb0605b67be08a55182ebabb78808fe1bd 100644 --- a/board/linux/libiosyscalls/include/iosyscalls.hpp +++ b/board/linux/libiosyscalls/include/iosyscalls.hpp @@ -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 - auto invoke_fs( T Base::*lfs_fun, Args&& ... args) + auto invoke_fs(T Base::*lfs_fun, Args &&... args) -> decltype((static_cast(nullptr)->*lfs_fun)(std::forward(args)...)) { auto vfs = purefs::subsystem::vfs_core(); - if(!vfs) { + if (!vfs) { errno = EIO; return -1; } auto ret = (vfs.get()->*lfs_fun)(std::forward(args)...); - if(ret < 0) { + if (ret < 0) { errno = -ret; - ret = -1; + ret = -1; } return ret; } -} - +} // namespace vfsn::linux::internal diff --git a/board/linux/libiosyscalls/src/iosyscalls.cpp b/board/linux/libiosyscalls/src/iosyscalls.cpp index a16995ff330cf473327ed8830f5f3e3d0c90c874..0906ac5a8797fc1f53dacaac1adebd8686e844b0 100644 --- a/board/linux/libiosyscalls/src/iosyscalls.cpp +++ b/board/linux/libiosyscalls/src/iosyscalls.cpp @@ -12,70 +12,67 @@ #include #include -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 g_fdlist; - phmap::flat_hash_set g_dirlist; -} + phmap::flat_hash_set g_fdlist; + phmap::flat_hash_set 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(fd)); - auto isfilex = ( fres != g_fdlist.end() ); + auto fres = g_fdlist.find(reinterpret_cast(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(dlsym(RTLD_NEXT, "vfprintf")); - auto rprint = reinterpret_cast(dlsym(RTLD_NEXT, "fprintf")); - rprint(stderr,">>>>>>> IOFUNC: [%s] ", fn); + auto rprint = reinterpret_cast(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 diff --git a/board/linux/libiosyscalls/src/syscalls_posix.cpp b/board/linux/libiosyscalls/src/syscalls_posix.cpp index e673d8ac71b223e7d715d13ea3623aa38ccbbbe5..0a78fa27110ffd57f59ccdbb337ce65d2145ecb5 100644 --- a/board/linux/libiosyscalls/src/syscalls_posix.cpp +++ b/board/linux/libiosyscalls/src/syscalls_posix.cpp @@ -12,8 +12,8 @@ #include #include #include -#include // for va_* -#include // for PATH_MAX +#include // for va_* +#include // 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)) { diff --git a/board/linux/libiosyscalls/src/syscalls_posix_dirent.cpp b/board/linux/libiosyscalls/src/syscalls_posix_dirent.cpp index c146afa796bb672f1648c67902b95ff3dbe1a0a3..51abf8d294f2708d7d93c9ed4a2255a919045493 100644 --- a/board/linux/libiosyscalls/src/syscalls_posix_dirent.cpp +++ b/board/linux/libiosyscalls/src/syscalls_posix_dirent.cpp @@ -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"); - } - diff --git a/board/linux/libiosyscalls/src/syscalls_real.hpp b/board/linux/libiosyscalls/src/syscalls_real.hpp index 890707045fb73537db3deb0e7b13480e66d22afa..79c80f5dad56342b994b1141c223ecb84197edf3 100644 --- a/board/linux/libiosyscalls/src/syscalls_real.hpp +++ b/board/linux/libiosyscalls/src/syscalls_real.hpp @@ -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(dlsym(RTLD_NEXT, #fun)) -#include // for dlsym() +#include // for dlsym() diff --git a/board/linux/libiosyscalls/src/syscalls_scan_family.cpp b/board/linux/libiosyscalls/src/syscalls_scan_family.cpp index be15f7b50a2afacb031e20a715b991b5bd4ace74..315ad46ecf8597c24de876fd345798e5c3a96768 100644 --- a/board/linux/libiosyscalls/src/syscalls_scan_family.cpp +++ b/board/linux/libiosyscalls/src/syscalls_scan_family.cpp @@ -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(fp)); + ungetc(c, reinterpret_cast(fp)); return 1; } do { n = n * 10 + c - '0'; } while (isdigit(c = ic(fp)) && --wid > 0); - ungetc(c, reinterpret_cast(fp)); + ungetc(c, reinterpret_cast(fp)); if (t == 8) { *reinterpret_cast(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(__stream); + auto fx = reinterpret_cast(__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(fp); + auto fx = reinterpret_cast(fp); while (*fmt) { while (isspace(static_cast(*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; diff --git a/board/linux/libiosyscalls/src/syscalls_stdio.cpp b/board/linux/libiosyscalls/src/syscalls_stdio.cpp index e7cc8283672c41ee0b3b974c8f2dfe2bfc118c0b..f1f61a0ebd2833fff7fb1a275d2b1787436b5a15 100644 --- a/board/linux/libiosyscalls/src/syscalls_stdio.cpp +++ b/board/linux/libiosyscalls/src/syscalls_stdio.cpp @@ -5,9 +5,9 @@ #include #include -#include // for va_* -#include // for PATH_MAX -#include // for strlen +#include // for va_* +#include // for PATH_MAX +#include // 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(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(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(__stream); + auto fx = reinterpret_cast(__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(__stream); + auto fx = reinterpret_cast(__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(stream); + auto fx = reinterpret_cast(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(__stream); - ret = vfs::invoke_fs(&fs::fsync, fx->fd); + auto fx = reinterpret_cast(__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(__stream); + auto fx = reinterpret_cast(__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(__stream); - auto ret = vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_CUR); + auto fx = reinterpret_cast(__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(__stream); - auto ret = vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_CUR); + auto fx = reinterpret_cast(__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(__stream); + auto fx = reinterpret_cast(__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(__stream)->fd); + ret = vfs::to_native_fd(reinterpret_cast(__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(__stream); + auto fx = reinterpret_cast(__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(__stream); - char ch = __c; - int ret = vfs::invoke_fs(&fs::write,fx->fd, &ch, sizeof ch); + auto fx = reinterpret_cast(__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(__stream); + auto fx = reinterpret_cast(__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(__stream); - char* p = reinterpret_cast(__ptr); + auto fx = reinterpret_cast(__stream); + char *p = reinterpret_cast(__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(__stream); - ret = vfs::invoke_fs(&fs::seek, fx->fd, __off, __whence); - ret = (ret>0) ? 0 : ret; + auto fx = reinterpret_cast(__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(__stream); + auto fx = reinterpret_cast(__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(__stream); + auto fx = reinterpret_cast(__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(__stream); - ret = vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_CUR); + auto fx = reinterpret_cast(__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(__s); - const char* p = reinterpret_cast(__ptr); - size_t items {}; + auto fx = reinterpret_cast(__s); + const char *p = reinterpret_cast(__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(__stream); + auto fx = reinterpret_cast(__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(__stream); - char ch = __c; - ret = vfs::invoke_fs(&fs::write,fx->fd, &ch, sizeof ch); + auto fx = reinterpret_cast(__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(__stream); - vfs::invoke_fs(&fs::seek,fx->fd,0,SEEK_SET); + auto fx = reinterpret_cast(__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"); - } diff --git a/board/linux/libiosyscalls/test/unittest_iosys.cpp b/board/linux/libiosyscalls/test/unittest_iosys.cpp index 38c7f39200194ac9fcd674bb0e4becc590db321a..5bd966a658c7e2c36eaedada223b1b210ed41396 100644 --- a/board/linux/libiosyscalls/test/unittest_iosys.cpp +++ b/board/linux/libiosyscalls/test/unittest_iosys.cpp @@ -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(myfile); - auto __last = std::istreambuf_iterator(); + auto __last = std::istreambuf_iterator(); std::vector testvec(__first, __last); testvec.push_back('\0'); diff --git a/board/linux/macros.h b/board/linux/macros.h index a115f2489cf50c2910a1c8542f7f08665d83a5dd..d156647cc5b10f7bf4545a432f3becad113f8d6d 100644 --- a/board/linux/macros.h +++ b/board/linux/macros.h @@ -15,54 +15,54 @@ #include #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_ */ diff --git a/board/rt1051/newlib/include/sys/mount.h b/board/rt1051/newlib/include/sys/mount.h index ee370796b95563531f5dadfd3b2dcd63c1179a2f..23724c737ec4b6d320873d070f13ee4762fd5928 100644 --- a/board/rt1051/newlib/include/sys/mount.h +++ b/board/rt1051/newlib/include/sys/mount.h @@ -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 - diff --git a/board/rt1051/newlib/io_syscalls.cpp b/board/rt1051/newlib/io_syscalls.cpp index 6a5c46d87084d182c4a45557712c0ce9aa6fd076..95607ad3449dacc0d23574590c0d7e0213f4c730 100644 --- a/board/rt1051/newlib/io_syscalls.cpp +++ b/board/rt1051/newlib/io_syscalls.cpp @@ -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); } } - diff --git a/config/format-config.sh b/config/format-config.sh index bfdb8e1d8f8c4bb0c7320836b1be58387567832c..b9dce4459cb57697e0634e7194cbaabcd7e34d8b 100644 --- a/config/format-config.sh +++ b/config/format-config.sh @@ -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'