PosixPassthroguh and PosixFileSystem updated

Author: rgmacedo

.clang-format

@@ -0,0 +1,34 @@
+BasedOnStyle: WebKit
+AlignConsecutiveAssignments: false
+AlignConsecutiveMacros: true
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+AlwaysBreakTemplateDeclarations: Yes
+AllowShortBlocksOnASingleLine: Empty
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: None
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: Never
+  AfterEnum: false
+  AfterFunction: true
+  AfterStruct: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+BreakConstructorInitializers: AfterColon
+ColumnLimit: 100
+FixNamespaceComments: true
+IncludeBlocks: Regroup
+IndentCaseBlocks: false
+IndentCaseLabels: true
+PointerAlignment: Left
+SpaceAfterTemplateKeyword: false
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeParens: Always
+SpacesInContainerLiterals: false

include/ldpaio/interface/posix_file_system.hpp

@@ -11,5 +11,15 @@
 
 ssize_t read (int fd, void* buf, size_t size);
 
+ssize_t write (int fd, const void* buf, size_t size);
 
-#endif //LDPAIO_POSIX_FILE_SYSTEM_H
+ssize_t pread (int fd, void* buf, size_t size, off_t offset);
+
+ssize_t pwrite (int fd, const void* buf, size_t size, off_t offset);
+
+int open (const char* pathname, int flags);
+
+int open (const char* pathname, int flags, mode_t mode);
+
+
+#endif // LDPAIO_POSIX_FILE_SYSTEM_H

include/ldpaio/interface/posix_passthrough.hpp

@@ -1,44 +1,54 @@
 /**
-*   Written by Ricardo Macedo.
-*   Copyright (c) 2021 INESC TEC.
-**/
+ *   Written by Ricardo Macedo.
+ *   Copyright (c) 2021 INESC TEC.
+ **/
 
 #ifndef LDPAIO_POSIX_PASSTHROUGH_HPP
 #define LDPAIO_POSIX_PASSTHROUGH_HPP
 
 #define __USE_GNU
 #define _GNU_SOURCE
 
-#include <sys/types.h>
-#include <sys/stat.h>
+#include <dlfcn.h>
 #include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h>
-#include <dlfcn.h>
 
 namespace ldpaio {
 
-    typedef ssize_t (*real_read_t)(int, void*, size_t);
+typedef ssize_t (*real_read_t) (int, void*, size_t);
+typedef ssize_t (*real_write_t) (int, const void*, size_t);
+typedef ssize_t (*real_pread_t) (int, void*, size_t, off_t);
+typedef ssize_t (*real_pwrite_t) (int, const void*, size_t, off_t);
+typedef ssize_t (*real_open_t) (const char*, int);
+typedef ssize_t (*real_open_2_t) (const char*, int, mode_t);
+
+
+class PosixPassthrough {
 
-    ssize_t passthrough_read (int fd, void* buf, ssize_t counter);
+public:
 
-    ssize_t passthrough_write (int fd, const void* buf, ssize_t counter);
+    static ssize_t passthrough_read (int fd, void *buf, ssize_t counter);
 
-    ssize_t passthrough_pread (int fd, void* buf, ssize_t counter, off_t offset);
+    static ssize_t passthrough_write (int fd, const void *buf, ssize_t counter);
 
-    ssize_t passthrough_pwrite (int fd, const void* buf, ssize_t counter, off_t offset);
+    static ssize_t passthrough_pread (int fd, void *buf, ssize_t counter, off_t offset);
 
-    // open calls
-    int passthrough_open (const char* pathname, int flags);
+    static ssize_t passthrough_pwrite (int fd, const void *buf, ssize_t counter, off_t offset);
 
-    int passthrough_open (const char* pathname, int flags, mode_t mode);
+// open calls
+    static int passthrough_open (const char* pathname, int flags);
 
-    int passthrough_creat (const char* pathname, mode_t mode);
+    static int passthrough_open (const char* pathname, int flags, mode_t mode);
 
-    int passthrough_openat (int dirfd, const char* pathname, int flags);
+    static int passthrough_creat (const char* pathname, mode_t mode);
 
-    int passthrough_openat (int dirfd, const char* pathname, int flags, mode_t mode);
+    static int passthrough_openat (int dirfd, const char* pathname, int flags);
 
-}
+    static int passthrough_openat (int dirfd, const char* pathname, int flags, mode_t mode);
 
+};
+} // namespace ldpaio
 
-#endif //LDPAIO_POSIX_PASSTHROUGH_HPP
+#endif // LDPAIO_POSIX_PASSTHROUGH_HPP

run-clang-format.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# ---------------------------------------------------------------------------- #
+
+set -o errexit -o pipefail -o nounset
+
+cd "$( realpath "$0" | xargs dirname )" &&
+find . -name '*.[ch]' -o -name '*.[ch]pp' | xargs clang-format -i
+
+# ---------------------------------------------------------------------------- #

src/interface/posix_file_system.cpp

@@ -1,17 +1,48 @@
 /**
-*   Written by Ricardo Macedo.
-*   Copyright (c) 2021 INESC TEC.
-**/
+ *   Written by Ricardo Macedo.
+ *   Copyright (c) 2021 INESC TEC.
+ **/
 
-
-#include <ldpaio/interface/posix_file_system.hpp>
-#include <ldpaio/interface/posix_passthrough.hpp>
 #include <cstring>
 #include <iostream>
+#include <ldpaio/interface/posix_file_system.hpp>
+#include <ldpaio/interface/posix_passthrough.hpp>
 
-
+// read call. ...
 ssize_t read (int fd, void* buf, size_t size)
 {
     std::cout << "One more read ...\n";
-    return ldpaio::passthrough_read (fd, buf, size);
-}
+    return ldpaio::PosixPassthrough::passthrough_read (fd, buf, size);
+}
+
+// write call. ...
+ssize_t write (int fd, const void* buf, size_t size)
+{
+    std::cout << "One more write ...\n";
+    return ldpaio::PosixPassthrough::passthrough_write (fd, buf, size);
+}
+
+// pread call. ...
+ssize_t pread (int fd, void* buf, size_t size, off_t offset)
+{
+    std::cout << "One more pread ...\n";
+    return ldpaio::PosixPassthrough::passthrough_pread (fd, buf, size, offset);
+}
+
+// pwrite call. ...
+ssize_t pwrite (int fd, const void* buf, size_t size, off_t offset)
+{
+    std::cout << "One more pwrite ...\n";
+    return ldpaio::PosixPassthrough::passthrough_pwrite (fd, buf, size, offset);
+}
+
+int open (const char* pathname, int flags) {
+    std::cout << "One more open ... \n";
+    return ldpaio::PosixPassthrough::passthrough_open (pathname, flags);
+}
+
+int open (const char* pathname, int flags, mode_t mode) {
+    std::cout << "One more open (w/ mode) ... \n";
+    return ldpaio::PosixPassthrough::passthrough_open (pathname, flags, mode);
+}
+

src/interface/posix_passthrough.cpp

@@ -1,15 +1,38 @@
 /**
-*   Written by Ricardo Macedo.
-*   Copyright (c) 2021 INESC TEC.
-**/
+ *   Written by Ricardo Macedo.
+ *   Copyright (c) 2021 INESC TEC.
+ **/
 
 #include <ldpaio/interface/posix_passthrough.hpp>
 
 namespace ldpaio {
 
-    ssize_t passthrough_read (int fd, void* buf, ssize_t counter) {
-        return ((real_read_t) dlsym (RTLD_NEXT, "read"))(fd, buf, counter);
-    }
+ssize_t PosixPassthrough::passthrough_read (int fd, void* buf, ssize_t counter)
+{
+    return ((real_read_t)dlsym (RTLD_NEXT, "read")) (fd, buf, counter);
+}
 
+ssize_t PosixPassthrough::passthrough_write (int fd, const void* buf, ssize_t counter)
+{
+    return ((real_write_t)dlsym (RTLD_NEXT, "write")) (fd, buf, counter);
+}
 
-}
+ssize_t PosixPassthrough::passthrough_pread (int fd, void* buf, ssize_t counter, off_t offset)
+{
+    return ((real_pread_t)dlsym (RTLD_NEXT, "pread")) (fd, buf, counter, offset);
+}
+
+ssize_t PosixPassthrough::passthrough_pwrite (int fd, const void* buf, ssize_t counter, off_t offset)
+{
+    return ((real_pwrite_t)dlsym (RTLD_NEXT, "pwrite")) (fd, buf, counter, offset);
+}
+
+int PosixPassthrough::passthrough_open (const char* pathname, int flags) {
+    return ((real_open_t)dlsym (RTLD_NEXT, "open")) (pathname, flags);
+}
+
+int PosixPassthrough::passthrough_open (const char* pathname, int flags, mode_t mode) {
+    return ((real_open_2_t)dlsym (RTLD_NEXT, "open")) (pathname, flags, mode);
+}
+
+} // namespace ldpaio

tests/ldpaio_test.cpp

@@ -4,23 +4,27 @@
  **/
 
 #include <cstdio>
-#include <unistd.h>
 #include <cstdlib>
+#include <unistd.h>
+#include <fcntl.h>
 
 #define BUFFER_SIZE 1024
 
-int main (int argc, char* argv[]) {
+int main (int argc, char* argv[])
+{
 
     ssize_t read_bytes = 0;
     ssize_t written_bytes = 0;
-    char* buffer = static_cast<char*>(malloc(sizeof(char) * BUFFER_SIZE));
+    char* buffer = static_cast<char*> (std::malloc (sizeof (char) * BUFFER_SIZE));
+
+    int fd_write = ::open ("tmp.txt", O_CREAT | O_TRUNC | O_RDWR, 0600);
 
     while ((read_bytes = ::read (STDIN_FILENO, buffer, BUFFER_SIZE)) > 0) {
-        written_bytes += write (STDOUT_FILENO, buffer, read_bytes);
+        written_bytes += write (fd_write, buffer, read_bytes);
     }
 
+    close (fd_write);
     delete (buffer);
 
     return 0;
-
 }