78 files changed, 145 insertions, 145 deletions
diff --git a/.gitignore b/.gitignore
index 0a122f0..ab4c720 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,5 +2,5 @@
 *.o
 docs/html/
 docs/latex/
-ioreplay/ioreplay
+ioriot/ioriot
 systemtap/downloads/
diff --git a/Makefile b/Makefile
index 427e7bb..d5ab493 100644
--- a/Makefile
+++ b/Makefile
@@ -1,19 +1,19 @@
-DESTDIR=/opt/ioreplay
+DESTDIR=/opt/ioriot
 all:
 	$(MAKE) -C systemtap
-	$(MAKE) -C ioreplay
+	$(MAKE) -C ioriot
 install:
 	$(MAKE) -C systemtap install
-	$(MAKE) -C ioreplay install
+	$(MAKE) -C ioriot install
 uninstall:
 	test ! -z $(DESTDIR) && test -d $(DESTDIR) && rm -Rfv $(DESTDIR) || exit 0
 deinstall: uninstall
 clean:
-	$(MAKE) -C ioreplay clean
+	$(MAKE) -C ioriot clean
 	$(MAKE) -C systemtap clean
 astyle:
-	$(MAKE) -C ioreplay astyle
+	$(MAKE) -C ioriot astyle
 loc:
-	wc -l ./systemtap/src/*.stp ./ioreplay/src/*.{h,c} ./ioreplay/src/*/*.{h,c} | tail -n 1
+	wc -l ./systemtap/src/*.stp ./ioriot/src/*.{h,c} ./ioriot/src/*/*.{h,c} | tail -n 1
 doxygen:
 	doxygen ./docs/doxygen.conf
diff --git a/README.md b/README.md
index db18da5..be6aa8f 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# I/O Replay
+# I/O Riot
 
 ## Overview
 
-I/O Replay is an I/O benchmarking tool for Linux based operating systems which captures I/O operations on a (possibly production) server in order to replay the exact same I/O operations on a load test machine.
+I/O Riot is an I/O benchmarking tool for Linux based operating systems which captures I/O operations on a (possibly production) server in order to replay the exact same I/O operations on a load test machine.
 
-I/O Replay is operated in 5 steps:
+I/O Riot is operated in 5 steps:
 
 1. Capture: Record all I/O operations over a given period of time to a capture log.
 2. Initialize: Copy the log to a load test machine and initialize the load test environment.
@@ -23,11 +23,11 @@ The file system fragmentation (depending on the file system type and utilisation
 
 ## Benefits
 
-In contrast to traditional I/O benchmarking tools, I/O Replay reproduces real production I/O, and does not rely on a pre-defined set of I/O operations.
+In contrast to traditional I/O benchmarking tools, I/O Riot reproduces real production I/O, and does not rely on a pre-defined set of I/O operations.
 
-Also, I/O Replay only requires a server machine for capturing and another server machine for replaying. A traditional load test environment would usually be a distributed system which can consist of many components and machines. Such a distributed system can become quite complex which makes it difficult to isolate possible I/O bottlenecks. For example in order to trigger I/O events a client application would usually have to call a remote server application. The remote server application itself would query a database and the database would trigger the actual I/O operations in Linux. Furthermore, it is not easy to switch forth and back between hardware and OS settings. For example without a backup and restore procedure a database would most likely be corrupt after reformatting the data partitions with a different file system type.
+Also, I/O Riot only requires a server machine for capturing and another server machine for replaying. A traditional load test environment would usually be a distributed system which can consist of many components and machines. Such a distributed system can become quite complex which makes it difficult to isolate possible I/O bottlenecks. For example in order to trigger I/O events a client application would usually have to call a remote server application. The remote server application itself would query a database and the database would trigger the actual I/O operations in Linux. Furthermore, it is not easy to switch forth and back between hardware and OS settings. For example without a backup and restore procedure a database would most likely be corrupt after reformatting the data partitions with a different file system type.
 
-The benefits of I/O replay are:
+The benefits of I/O Riot are:
 
 * It is easy to determine whether a new hardware type is suitable for an already existing application.
 * It is easy to change OS and hardware for performance tests and optimizations.
@@ -41,7 +41,7 @@ The benefits of I/O replay are:
 
 # Send in patches
 
-Patches of any kind (bug fixes, new features...) are welcome! I/O Replay is new software and not everything might be perfect yet. Also, I/O Replay is used for a very specific use case at Mimecast. It may need tuning or extension for your use case. It will grow and mature over time.
+Patches of any kind (bug fixes, new features...) are welcome! I/O Riot is new software and not everything might be perfect yet. Also, I/O Riot is used for a very specific use case at Mimecast. It may need tuning or extension for your use case. It will grow and mature over time.
 
 This is also potentially a great tool just for analysing (not replaying) the I/O, therefore it would be a great opportunity to add more features related to that (e.g. more stats, filters, etc.).
 
@@ -49,11 +49,11 @@ Future work will also include file hole support and I/O support for memory mappe
 
 # Getting started
 
-I/O Replay consists of a set of SystemTap kernel modules (capturing I/O) and the tool ``ioreplay`` (replaying I/O). Usually you want to capture I/O from a production machine and want to replay it on a separate load testing machine.
+I/O Riot consists of a set of SystemTap kernel modules (capturing I/O) and the tool ``ioriot`` (replaying I/O). Usually you want to capture I/O from a production machine and want to replay it on a separate load testing machine.
  
 ## System requirements
 
-I/O replay has been tested on
+I/O Riot has been tested on
 
 * CentOS 7.4 64Bit (latest version, all packages up to date, booted into the installed Kernel)
 * SystemTap (from the default CentOS repository)
@@ -61,29 +61,29 @@ I/O replay has been tested on
 
 Before proceeding please ensure that the latest CentOS 7 kernel is installed and running on all machines involved. It should also be ensured that the capture machine and the load test machine have the same mount points mounted. This is to ensure that I/O is being replayed on the corresponding data drives on the load test machine.
 
-## Compiling and installing ioreplay 
+## Compiling and installing ioriot 
 
-I/O Replay has to be installed on all machines involved.  To install I/O Replay perform the following steps:
+I/O Riot has to be installed on all machines involved.  To install I/O Riot perform the following steps:
 
 ```sh
 sudo yum install gcc systemtap yum-utils kernel-devel-$(uname -r)
 sudo debuginfo-install kernel-$(uname -r)
 make && sudo make install
-export PATH=$PATH:/opt/ioreplay/bin
+export PATH=$PATH:/opt/ioriot/bin
 ```
 
-This will install the ``ioreplay`` utility to ``/opt/ioreplay/bin/`` and the SystemTap kernel modules to ``/opt/ioreplay/systemtap/``. Run ``ioreplay -h`` to print out a brief help.
+This will install the ``ioriot`` utility to ``/opt/ioriot/bin/`` and the SystemTap kernel modules to ``/opt/ioriot/systemtap/``. Run ``ioriot -h`` to print out a brief help.
 
-However, best practise is not to install any compilers on a production machine. You can either compile I/O Replay from scratch on all machines involved like shown above or only compile it on a build machine and distribute the ``/opt/ioreplay`` directory to the remaining machines. In the latter case you will also need to install the ``systemtap-runtime`` package as an additional dependency.
+However, best practise is not to install any compilers on a production machine. You can either compile I/O Riot from scratch on all machines involved like shown above or only compile it on a build machine and distribute the ``/opt/ioriot`` directory to the remaining machines. In the latter case you will also need to install the ``systemtap-runtime`` package as an additional dependency.
 
-In case you decided to deinstall I/O Replay you can do so by running
+In case you decided to deinstall I/O Riot you can do so by running
 
 ```sh
-sudo ioreplay -P # purges all test files created by ioreplay
+sudo ioriot -P # purges all test files created by ioriot
 sudo make uninstall
 ```
 
-# Operating I/O Replay
+# Operating I/O Riot
 
 ## 1. Capture
 
@@ -93,7 +93,7 @@ The following steps are required to capture all I/O operation of the entire (Lin
  * 2) Run:
 
 ```sh
-sudo ioreplay -c ~/io.capture
+sudo ioriot -c ~/io.capture
 ```
 
  * 3) Start all applications again.
@@ -102,13 +102,13 @@ sudo ioreplay -c ~/io.capture
 To capture only I/O caused by Java process run:
 
 ```sh
-sudo ioreplay -c ~/io.capture -m javaioreplay.ko
+sudo ioriot -c ~/io.capture -m javaioriot.ko
 ```
 
 To capture the I/O of a specific process run the following respectively:
 
 ```sh
-sudo ioreplay -c ~/io.capture -m targetedioreplay.ko -p PID
+sudo ioriot -c ~/io.capture -m targetedioriot.ko -p PID
 ```
 
 The resulting capture log looks like this and can be multiple GB in size:
@@ -168,7 +168,7 @@ sudo mount -t tmpfs -o size=32g tmpfs /mnt/ramdisk
 Make sure that there is enough system memory available for such a RAMdisk and all the processes running on the machine. Eventually, RAM will be taken away from the Linux caches which potentially could decrease system I/O performance. Run the following command to capture to the RAMdisk respectively:
 
 ```sh
-sudo ioreplay -c /mnt/ramdisk/io.capture
+sudo ioriot -c /mnt/ramdisk/io.capture
 ```
 
 ## 2. Initialize
@@ -181,59 +181,59 @@ After producing ``io.capture`` it must be pre-processed. The resulting replay lo
 * Use of internal opcodes rather than strings (e.g. ``30`` instead of ``open``) for faster parsing.
 * All operations on unknown file handles are _removed_.
 * All incomplete or corrupt lines from the capture file are ignored. There may be corrupt lines in the capture file because SystemTap may skips a very few probe points if it decides that capturing I/O is causing too much overhead.
-* Rewrite of all file paths. ``ioreplay`` adds ``/.ioreplay/NAME`` to all file paths for each file system mount point.
+* Rewrite of all file paths. ``ioriot`` adds ``/.ioriot/NAME`` to all file paths for each file system mount point.
 
 To generate the the replay log ``io.replay`` from the capture log ``io.capture`` run:
 
 ```sh
-sudo ioreplay -c io.capture -r io.replay -n NAME -u USER
+sudo ioriot -c io.capture -r io.replay -n NAME -u USER
 ```
 
-In which NAME is a freely chosen name and USER must be a valid system user. It is the system user under which the replay test will run. This command also creates all required top level directories such as ``/.ioreplay/NAME/``, ``/mnt/.ioreplay/NAME/`` in all mounted file systems. These are the directories where the replay test will read/write files from/to. These directories will belong to user USER.
+In which NAME is a freely chosen name and USER must be a valid system user. It is the system user under which the replay test will run. This command also creates all required top level directories such as ``/.ioriot/NAME/``, ``/mnt/.ioriot/NAME/`` in all mounted file systems. These are the directories where the replay test will read/write files from/to. These directories will belong to user USER.
 
-``ioreplay`` will filter out many operations, especially all operations on pseudo file systems (e.g. sysfs, procfs), as it does not make a lot of sense to replay I/O on these file systems. Also, I/O operations on unknown file handles will be filtered out as well. This can happen when we start capturing the I/O *after* an application already opened a file. As a result we won't see how the application opened that file. The best practise is to stop all applications on the machine first, start capturing the I/O, and start all applications again. This may be improved in future releases of I/O Replay.
+``ioriot`` will filter out many operations, especially all operations on pseudo file systems (e.g. sysfs, procfs), as it does not make a lot of sense to replay I/O on these file systems. Also, I/O operations on unknown file handles will be filtered out as well. This can happen when we start capturing the I/O *after* an application already opened a file. As a result we won't see how the application opened that file. The best practise is to stop all applications on the machine first, start capturing the I/O, and start all applications again. This may be improved in future releases of I/O Riot.
 
 The resulting replay log will look like this: At the first line there is a meta header. It contains information about the test configuration. The meta header is followed by all the I/O operations. At the end of the file is the INIT section. It lists all files (also their sizes) and directories required to be present before replaying the I/O.
 
 
 ```sh
-#|num_timelines=509591|num_mapped_pids=19189|num_mapped_fds=4292067|num_lines=55040114|replay_version=1|user=ioreplayuser|name=test0|init_offset=2578735248|
-23|1|1|0|0|30|11|/usr/local/mimecast/.ioreplay/test0/someapp/somesubdir/vd11-9:1|438|0|open@31|
+#|num_timelines=509591|num_mapped_pids=19189|num_mapped_fds=4292067|num_lines=55040114|replay_version=1|user=ioriotuser|name=test0|init_offset=2578735248|
+23|1|1|0|0|30|11|/usr/local/mimecast/.ioriot/test0/someapp/somesubdir/vd11-9:1|438|0|open@31|
 23|1|1|0|0|0|11|0|fstat@32|
 23|1|1|0|0|10|11|12|read@33|
 23|1|1|0|0|0|11|0|fstat@34|
 23|1|1|0|0|72|11|0|1|12|lseek@35|
 23|1|1|0|0|10|11|0|read@36|
 23|1|1|0|0|50|11|0|close@37|
-23|2|1|0|0|30|12|/usr/local/mimecast/.ioreplay/test0/someapp/somesubdir/vd11-8:1|438|0|open@38|
+23|2|1|0|0|30|12|/usr/local/mimecast/.ioriot/test0/someapp/somesubdir/vd11-8:1|438|0|open@38|
 23|2|1|0|0|0|12|0|fstat@39|
 23|2|1|0|0|10|12|12|read@40|
 23|2|1|0|0|0|12|0|fstat@41|
 23|2|1|0|0|72|12|0|1|12|lseek@42|
 23|2|1|0|0|10|12|0|read@43|
 23|2|1|0|0|50|12|0|close@44|
-23|3|1|0|0|30|13|/usr/local/mimecast/.ioreplay/test0/someapp/somesubdir/vd11-9:0|438|0|open@45|
+23|3|1|0|0|30|13|/usr/local/mimecast/.ioriot/test0/someapp/somesubdir/vd11-9:0|438|0|open@45|
 23|3|1|0|0|0|13|0|fstat@46|
 23|3|1|0|0|10|13|12|read@47|
 23|3|1|0|0|0|13|0|fstat@48|
 23|3|1|0|0|72|13|0|1|12|lseek@49|
 23|3|1|0|0|10|13|0|read@50|
 23|3|1|0|0|50|13|0|close@51|
-23|4|1|0|0|30|14|/usr/local/mimecast/.ioreplay/test0/someapp/somesubdir/vd11-7:1|438|0|open@52|
+23|4|1|0|0|30|14|/usr/local/mimecast/.ioriot/test0/someapp/somesubdir/vd11-7:1|438|0|open@52|
 23|4|1|0|0|0|14|0|fstat@53|
 23|4|1|0|0|10|14|12|read@54|
 23|4|1|0|0|0|14|0|fstat@55|
 23|4|1|0|0|72|14|0|1|12|lseek@56|
 23|4|1|0|0|10|14|0|read@57|
 23|4|1|0|0|50|14|0|close@58|
-23|5|1|0|0|30|15|/usr/local/mimecast/.ioreplay/test0/someapp/somesubdir/vd11-8:0|438|0|open@59|
+23|5|1|0|0|30|15|/usr/local/mimecast/.ioriot/test0/someapp/somesubdir/vd11-8:0|438|0|open@59|
 23|5|1|0|0|0|15|0|fstat@60|
 23|5|1|0|0|10|15|12|read@61|
 23|5|1|0|0|0|15|0|fstat@62|
 23|5|1|0|0|72|15|0|1|12|lseek@63|
 23|5|1|0|0|10|15|0|read@64|
 23|5|1|0|0|50|15|0|close@65|
-23|6|1|0|0|30|16|/usr/local/mimecast/.ioreplay/test0/someapp/somesubdir/vd11-6:1|438|0|open@66|
+23|6|1|0|0|30|16|/usr/local/mimecast/.ioriot/test0/someapp/somesubdir/vd11-6:1|438|0|open@66|
 23|6|1|0|0|0|16|0|fstat@67|
 23|6|1|0|0|10|16|12|read@68|
 23|6|1|0|0|0|16|0|fstat@69|
@@ -241,18 +241,18 @@ The resulting replay log will look like this: At the first line there is a meta
 .
 .
 #INIT
-0|1|688|/mnt/15/.ioreplay/test0/bmnt/2/20171101/b/8/b_dv01_11_vd11-11_a|@55290437
-0|1|2592|/mnt/15/.ioreplay/test0/bmnt/2/20171101/b/3/b_dv01_11_vd11-11_b|@33907067
-0|1|768|/mnt/14/.ioreplay/test0/bmnt/2/20171101/b/d/b_dv01_11_vd11-11_c|@64247527
-0|1|1440|/mnt/15/.ioreplay/test0/bmnt/2/20171101/b/0/b_dv01_11_vd11-11_d|@2014896
-0|1|960|/mnt/15/.ioreplay/test0/bmnt/2/20171101/b/9/b_dv01_11_vd11-11_e|@17724079
-0|1|928|/mnt/15/.ioreplay/test0/bmnt/2/20171101/b/1/b_dv01_11_vd11-11_f|@4534389
-0|1|1712|/mnt/14/.ioreplay/test0/bmnt/2/20171101/b/5/b_dv01_11_vd11-11_g|@2738458
-0|1|784|/mnt/14/.ioreplay/test0/bmnt/2/20171101/b/b/b_dv01_11_vd11-11_h|@21136612
-0|1|624|/mnt/14/.ioreplay/test0/bmnt/2/20171101/b/6/b_dv01_11_vd11-11_i|@24683427
-0|1|672|/mnt/14/.ioreplay/test0/bmnt/2/20171101/b/9/b_dv01_11_vd11-11_j|@12584061
-0|1|336|/mnt/15/.ioreplay/test0/bmnt/2/20171101/b/5/b_dv01_11_vd11-11_k|@7737434
-0|1|12|/mnt/06/.ioreplay/test0/bmnt/tmp/b|@42498106
+0|1|688|/mnt/15/.ioriot/test0/bmnt/2/20171101/b/8/b_dv01_11_vd11-11_a|@55290437
+0|1|2592|/mnt/15/.ioriot/test0/bmnt/2/20171101/b/3/b_dv01_11_vd11-11_b|@33907067
+0|1|768|/mnt/14/.ioriot/test0/bmnt/2/20171101/b/d/b_dv01_11_vd11-11_c|@64247527
+0|1|1440|/mnt/15/.ioriot/test0/bmnt/2/20171101/b/0/b_dv01_11_vd11-11_d|@2014896
+0|1|960|/mnt/15/.ioriot/test0/bmnt/2/20171101/b/9/b_dv01_11_vd11-11_e|@17724079
+0|1|928|/mnt/15/.ioriot/test0/bmnt/2/20171101/b/1/b_dv01_11_vd11-11_f|@4534389
+0|1|1712|/mnt/14/.ioriot/test0/bmnt/2/20171101/b/5/b_dv01_11_vd11-11_g|@2738458
+0|1|784|/mnt/14/.ioriot/test0/bmnt/2/20171101/b/b/b_dv01_11_vd11-11_h|@21136612
+0|1|624|/mnt/14/.ioriot/test0/bmnt/2/20171101/b/6/b_dv01_11_vd11-11_i|@24683427
+0|1|672|/mnt/14/.ioriot/test0/bmnt/2/20171101/b/9/b_dv01_11_vd11-11_j|@12584061
+0|1|336|/mnt/15/.ioriot/test0/bmnt/2/20171101/b/5/b_dv01_11_vd11-11_k|@7737434
+0|1|12|/mnt/06/.ioriot/test0/bmnt/tmp/b|@42498106
 .
 .
 .
@@ -264,17 +264,17 @@ The resulting replay log will look like this: At the first line there is a meta
 It is very likely that the replay test wants to access already existing files. Therefore it has to be ensured that all of these exist already before starting the test. To create all files and directories required by the test run the following command:
 
 ```sh
-sudo ioreplay -i io.replay
+sudo ioriot -i io.replay
 ```
 
-For that ``ioreplay`` makes use of the INIT section in ``io.replay``.
+For that ``ioriot`` makes use of the INIT section in ``io.replay``.
 
 ## 3. Replay
 
 To replay the log run:
 
 ```sh
-sudo ioreplay -r io.replay
+sudo ioriot -r io.replay
 ```
 
 It is beneficial to read ``io.replay`` from RAMdisk so that we are not interfering so much with the system I/O. 
@@ -284,12 +284,12 @@ It is beneficial to read ``io.replay`` from RAMdisk so that we are not interferi
 It is posisble to initialise the test and run the test with one single command, just replace option `-r` with `-R`:
 
 ```sh
-sudo ioreplay -R io.replay
+sudo ioriot -R io.replay
 ```
 
 *Speed factor*
 
-By default `ioreplay` tries to replay all I/O operations as fast as it can. To replay the I/O at a different speed it is possible to configure the speed factor by using the `-s` command line option.
+By default `ioriot` tries to replay all I/O operations as fast as it can. To replay the I/O at a different speed it is possible to configure the speed factor by using the `-s` command line option.
 
 The following pseudo code demonstrates how the speed factor affects the replay speed. Here `current_time` represents the current time while replaying the I/O, `time_in_log` represents the time as logged in `io.replay` and `time_ahead` indicates whether the replay is too quick or not. 
 
@@ -306,7 +306,7 @@ A speed factor of `0` is interpreted as "replay as fast as possible". A speed fa
 In order to replay the I/O in original speed the factor of `1` can be used as follows:
 
 ```sh
-sudo ioreplay -R io.replay -s 1
+sudo ioriot -R io.replay -s 1
 ```
 
 ## 4. Analyse
@@ -322,14 +322,14 @@ It is important to understand the I/O statistics observed. It is possible to rep
 To purge all temporally data files of all tests run
 
 ```sh
-sudo ioreplay -P
+sudo ioriot -P
 ```
 
-Note: It's not required to cleanup any test data manually when you intend to re-run a test or run a new test. During initialization (``-i`` or ``-R`` switch) ``ioreplay`` will automatically move all old data to ``.ioreplay/.trash/`` sub-folders. The data will be ignored there. However, once you intend to completely delete all test files and directories (e.g. you run out of disk space or want to deinstall ``ioreplay`` you should purge them with ``-P`` as shown above.
+Note: It's not required to cleanup any test data manually when you intend to re-run a test or run a new test. During initialization (``-i`` or ``-R`` switch) ``ioriot`` will automatically move all old data to ``.ioriot/.trash/`` sub-folders. The data will be ignored there. However, once you intend to completely delete all test files and directories (e.g. you run out of disk space or want to deinstall ``ioriot`` you should purge them with ``-P`` as shown above.
 
 ## Supported file systems
 
-Currently I/O Replay supports replaying I/O on ``ext2``, ``ext3``, ``ext4`` and ``xfs``. However, it should be straightforward add additional file systems. 
+Currently I/O Riot supports replaying I/O on ``ext2``, ``ext3``, ``ext4`` and ``xfs``. However, it should be straightforward add additional file systems. 
 
 ## Supported syscalls
 
@@ -391,4 +391,4 @@ exit_group - To detect process termination (closing all open file handles)
 
 ## Source code documentation
 
-The documentation of the source code can be generated via the Doxygen Framework. To install doxygen run ``sudo yum install doxygen`` and to generate the documentation run ``make doxygen`` in the top level source directory.  Once done, the resulting documentation can be found in the ``docs/html`` subfolder of the project. It is worthwhile to start from ``ioreplay/src/main.c`` and read your way through. Functions are generally documented in the header files. Exceptions are static functions which don't have any separate declarations.
+The documentation of the source code can be generated via the Doxygen Framework. To install doxygen run ``sudo yum install doxygen`` and to generate the documentation run ``make doxygen`` in the top level source directory.  Once done, the resulting documentation can be found in the ``docs/html`` subfolder of the project. It is worthwhile to start from ``ioriot/src/main.c`` and read your way through. Functions are generally documented in the header files. Exceptions are static functions which don't have any separate declarations.
diff --git a/docs/doxygen.conf b/docs/doxygen.conf
index 340f731..8f014b6 100644
--- a/docs/doxygen.conf
+++ b/docs/doxygen.conf
@@ -32,7 +32,7 @@ DOXYFILE_ENCODING      = UTF-8
 # title of most generated pages and in a few other places.
 # The default value is: My Project.
 
-PROJECT_NAME           = "I/O Replay"
+PROJECT_NAME           = "I/O Riot"
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number. This
 # could be handy for archiving the generated documentation or if some version
@@ -791,7 +791,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = README.md ./ioreplay/src
+INPUT                  = README.md ./ioriot/src
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
diff --git a/ioreplay/Makefile b/ioriot/Makefile
index 67f4421..d933d72 100644
--- a/ioreplay/Makefile
+++ b/ioriot/Makefile
@@ -1,9 +1,9 @@
 #DEBUG=-g3 -ggdb3 -pg
-NAME=ioreplay
+NAME=ioriot
 LIBS=-pthread
 CFLAGS=-Wall -std=gnu99 -pedantic
 STATIC=#-static
-DESTDIR=/opt/ioreplay/bin
+DESTDIR=/opt/ioriot/bin
 SRCS=$(wildcard src/*.c src/*/*.c)
 HDRS=$(SRCS:.c=.h)
 OBJS=$(SRCS:.c=.o)
@@ -18,7 +18,7 @@ compile: $(OBJS)
 %.o: %.c %.h
 	$(CC) $(STATIC) $(DEBUG) $(LIBS) -c $(CFLAGS) $< -o $@
 clean:
-	rm -v ioreplay ./src/*.o ./src/*/*.o 2>/dev/null || exit 0
+	rm -v ioriot ./src/*.o ./src/*/*.o 2>/dev/null || exit 0
 install:
 	test ! -d $(DESTDIR) && mkdir -p $(DESTDIR) || exit 0
 	cp -v $(NAME) $(DESTDIR)
diff --git a/ioreplay/src/capture/capture.c b/ioriot/src/capture/capture.c
index 0ac336b..aaad6cb 100644
--- a/ioreplay/src/capture/capture.c
+++ b/ioriot/src/capture/capture.c
@@ -35,7 +35,7 @@ status_e capture_run(options_s *opts)
 
     Put("Release of currently running Kernel: %s", uts.release);
     char modules_dir[128];
-    sprintf(modules_dir, "/opt/ioreplay/systemtap/%s", uts.release);
+    sprintf(modules_dir, "/opt/ioriot/systemtap/%s", uts.release);
     Put("Changing directory to module path: %s/", modules_dir);
 
     if (0 != chdir(modules_dir)) {
@@ -77,7 +77,7 @@ status_e capture_run(options_s *opts)
     Out("NOTICE: It is good practise first to stop all processes, then to ");
     Out("start capturing, and then to start all processes again. The reason ");
     Out("is that processes may have already open file handles. In that case ");
-    Out("I/O Replay would be unable to replay these! This may be improved "); 
+    Out("I/O Riot would be unable to replay these! This may be improved "); 
     Put("in a future release!");
     Put("To abort capturing now send Ctrl+C, otherwise wait 1h");
     Put("Capturing I/O via: '%s'", staprun_command);
diff --git a/ioreplay/src/capture/capture.h b/ioriot/src/capture/capture.h
index 7718d3e..7718d3e 100644
--- a/ioreplay/src/capture/capture.h
+++ b/ioriot/src/capture/capture.h
diff --git a/ioreplay/src/cleanup/cleanup.c b/ioriot/src/cleanup/cleanup.c
index 570f8a7..570f8a7 100644
--- a/ioreplay/src/cleanup/cleanup.c
+++ b/ioriot/src/cleanup/cleanup.c
diff --git a/ioreplay/src/cleanup/cleanup.h b/ioriot/src/cleanup/cleanup.h
index 127badf..127badf 100644
--- a/ioreplay/src/cleanup/cleanup.h
+++ b/ioriot/src/cleanup/cleanup.h
diff --git a/ioreplay/src/datas/amap.c b/ioriot/src/datas/amap.c
index 806a3f8..806a3f8 100644
--- a/ioreplay/src/datas/amap.c
+++ b/ioriot/src/datas/amap.c
diff --git a/ioreplay/src/datas/amap.h b/ioriot/src/datas/amap.h
index 882a7c5..882a7c5 100644
--- a/ioreplay/src/datas/amap.h
+++ b/ioriot/src/datas/amap.h
diff --git a/ioreplay/src/datas/btree.c b/ioriot/src/datas/btree.c
index da5da48..da5da48 100644
--- a/ioreplay/src/datas/btree.c
+++ b/ioriot/src/datas/btree.c
diff --git a/ioreplay/src/datas/btree.h b/ioriot/src/datas/btree.h
index 55da560..55da560 100644
--- a/ioreplay/src/datas/btree.h
+++ b/ioriot/src/datas/btree.h
diff --git a/ioreplay/src/datas/hmap.c b/ioriot/src/datas/hmap.c
index 96c373e..96c373e 100644
--- a/ioreplay/src/datas/hmap.c
+++ b/ioriot/src/datas/hmap.c
diff --git a/ioreplay/src/datas/hmap.h b/ioriot/src/datas/hmap.h
index 9d1978b..9d1978b 100644
--- a/ioreplay/src/datas/hmap.h
+++ b/ioriot/src/datas/hmap.h
diff --git a/ioreplay/src/datas/list.c b/ioriot/src/datas/list.c
index 9cc78db..9cc78db 100644
--- a/ioreplay/src/datas/list.c
+++ b/ioriot/src/datas/list.c
diff --git a/ioreplay/src/datas/list.h b/ioriot/src/datas/list.h
index 385333c..385333c 100644
--- a/ioreplay/src/datas/list.h
+++ b/ioriot/src/datas/list.h
diff --git a/ioreplay/src/datas/rbuffer.c b/ioriot/src/datas/rbuffer.c
index c019e6c..c019e6c 100644
--- a/ioreplay/src/datas/rbuffer.c
+++ b/ioriot/src/datas/rbuffer.c
diff --git a/ioreplay/src/datas/rbuffer.h b/ioriot/src/datas/rbuffer.h
index fa634de..fa634de 100644
--- a/ioreplay/src/datas/rbuffer.h
+++ b/ioriot/src/datas/rbuffer.h
diff --git a/ioreplay/src/datas/stack.c b/ioriot/src/datas/stack.c
index 94e83e3..94e83e3 100644
--- a/ioreplay/src/datas/stack.c
+++ b/ioriot/src/datas/stack.c
diff --git a/ioreplay/src/datas/stack.h b/ioriot/src/datas/stack.h
index 87e0974..87e0974 100644
--- a/ioreplay/src/datas/stack.h
+++ b/ioriot/src/datas/stack.h
diff --git a/ioreplay/src/defaults.h b/ioriot/src/defaults.h
index de7910e..6ba1f3b 100644
--- a/ioreplay/src/defaults.h
+++ b/ioriot/src/defaults.h
@@ -27,10 +27,10 @@
 #define MAX_LINE_LEN 1024*8
 /** Controls how many tasks can be queued and buffered per worker thread */
 #define TASK_BUFFER_PER_THREAD 512
-/** Version of I/O Replay */
-#define IOREPLAY_VERSION "0.3-develop"
+/** Version of I/O Riot */
+#define IORIOT_VERSION "0.3-develop"
 /** Copyright information */
-#define IOREPLAY_COPYRIGHT "Mimecast 2017, 2018 (c)"
+#define IORIOT_COPYRIGHT "Mimecast 2017, 2018 (c)"
 /** Max open files resource user limit */
 #define SET_RLIMIT_NOFILE 369216
 /** Max processes resource user limit */
diff --git a/ioreplay/src/generate/generate.c b/ioriot/src/generate/generate.c
index 05445ae..ee7178c 100644
--- a/ioreplay/src/generate/generate.c
+++ b/ioriot/src/generate/generate.c
@@ -165,7 +165,7 @@ status_e generate_run(options_s *opts)
     meta_write_start(meta);
 
     // The meta header is being written to the first line of the .replay
-    // file and used by ioreplay to do various things (e.g. initializing
+    // file and used by ioriot to do various things (e.g. initializing
     // the test correctly, creating the internal data structures with the
     // correct sizes etc.
 
diff --git a/ioreplay/src/generate/generate.h b/ioriot/src/generate/generate.h
index cf096d2..6c0d97f 100644
--- a/ioreplay/src/generate/generate.h
+++ b/ioriot/src/generate/generate.h
@@ -79,7 +79,7 @@ status_e generate_run(options_s *opts);
  *
  * This function writes a list of all pre-required
  * paths to the .replay file. That then can be used
- * by ioreplay to initialise the test enironment.
+ * by ioriot to initialise the test enironment.
  *
  * @param data A pointer to the vsize timestamp object
  */
diff --git a/ioreplay/src/generate/gioop.c b/ioriot/src/generate/gioop.c
index 01701bc..01701bc 100644
--- a/ioreplay/src/generate/gioop.c
+++ b/ioriot/src/generate/gioop.c
diff --git a/ioreplay/src/generate/gioop.h b/ioriot/src/generate/gioop.h
index ad49713..ad49713 100644
--- a/ioreplay/src/generate/gioop.h
+++ b/ioriot/src/generate/gioop.h
diff --git a/ioreplay/src/generate/gparser.c b/ioriot/src/generate/gparser.c
index 514128f..2f3b250 100644
--- a/ioreplay/src/generate/gparser.c
+++ b/ioriot/src/generate/gparser.c
@@ -104,7 +104,7 @@ void gparser_extract(gparser_s *p, gtask_s *t)
             Cleanup(ERROR);
         }
 
-        // We are inserting ".ioreplay/NAME" to the paths. This enables us to
+        // We are inserting ".ioriot/NAME" to the paths. This enables us to
         // run multiple tests simoultaneously.
 
         if (t->path) {
diff --git a/ioreplay/src/generate/gparser.h b/ioriot/src/generate/gparser.h
index f3e204a..f3e204a 100644
--- a/ioreplay/src/generate/gparser.h
+++ b/ioriot/src/generate/gparser.h
diff --git a/ioreplay/src/generate/gprocess.c b/ioriot/src/generate/gprocess.c
index 6a0b37a..6a0b37a 100644
--- a/ioreplay/src/generate/gprocess.c
+++ b/ioriot/src/generate/gprocess.c
diff --git a/ioreplay/src/generate/gprocess.h b/ioriot/src/generate/gprocess.h
index 47e5037..7fcbd77 100644
--- a/ioreplay/src/generate/gprocess.h
+++ b/ioriot/src/generate/gprocess.h
@@ -62,7 +62,7 @@ void gprocess_destroy(gprocess_s *gp);
 /**
  * @brief Creates a new virtual FD from a given real FD number
  *
- * In ioreplay we map the real file descriptor (the fd number protocolled in
+ * In ioriot we map the real file descriptor (the fd number protocolled in
  * the.capture file) to a virtual file descriptor (the fd numner written to the
  * .replay file). The purpose is to increase concurrency of the I/O during
  * replay. Normally, a process would reuse the same file descriptor number
diff --git a/ioreplay/src/generate/gtask.c b/ioriot/src/generate/gtask.c
index 55a1124..55a1124 100644
--- a/ioreplay/src/generate/gtask.c
+++ b/ioriot/src/generate/gtask.c
diff --git a/ioreplay/src/generate/gtask.h b/ioriot/src/generate/gtask.h
index 2f364d3..0f8e5ac 100644
--- a/ioreplay/src/generate/gtask.h
+++ b/ioriot/src/generate/gtask.h
@@ -46,7 +46,7 @@ typedef struct gtask_s_ {
     int fd; /**< File descriptor number */
     int flags; /**< File open flags */
     int mode; /**< File open mode */
-    int ret; /**< ioreplay process status, SUCCESS if everything is alright */
+    int ret; /**< ioriot process status, SUCCESS if everything is alright */
     int status; /**< Operation/syscall return status */
     long address2; /**< Another address (used by mmap related syscalls) */
     long address; /**< An address (used by mmap related syscalls) */
diff --git a/ioreplay/src/generate/gwriter.c b/ioriot/src/generate/gwriter.c
index e0d448e..e0d448e 100644
--- a/ioreplay/src/generate/gwriter.c
+++ b/ioriot/src/generate/gwriter.c
diff --git a/ioreplay/src/generate/gwriter.h b/ioriot/src/generate/gwriter.h
index 4295580..4295580 100644
--- a/ioreplay/src/generate/gwriter.h
+++ b/ioriot/src/generate/gwriter.h
diff --git a/ioreplay/src/generate/vsize.c b/ioriot/src/generate/vsize.c
index f2d56ba..f2d56ba 100644
--- a/ioreplay/src/generate/vsize.c
+++ b/ioriot/src/generate/vsize.c
diff --git a/ioreplay/src/generate/vsize.h b/ioriot/src/generate/vsize.h
index bb1008e..8556ec0 100644
--- a/ioreplay/src/generate/vsize.h
+++ b/ioriot/src/generate/vsize.h
@@ -77,7 +77,7 @@ void init_parent_dir(vsize_s *v, const char *path);
  * Compares the virtual file size of the file in the vsize
  * object to the the offset in the virtual file descriptor.
  * In case the offset is higher we have a size deficit and
- * we need to mark it. That way ioreplay can ensure that
+ * we need to mark it. That way ioriot can ensure that
  * during init mode it will create a file with the correct
  * size prior of running the test!
  *
diff --git a/ioreplay/src/init/init.c b/ioriot/src/init/init.c
index e375379..e375379 100644
--- a/ioreplay/src/init/init.c
+++ b/ioriot/src/init/init.c
diff --git a/ioreplay/src/init/init.h b/ioriot/src/init/init.h
index 3d9f9e9..3d9f9e9 100644
--- a/ioreplay/src/init/init.h
+++ b/ioriot/src/init/init.h
diff --git a/ioreplay/src/init/itask.c b/ioriot/src/init/itask.c
index f04ce33..f04ce33 100644
--- a/ioreplay/src/init/itask.c
+++ b/ioriot/src/init/itask.c
diff --git a/ioreplay/src/init/itask.h b/ioriot/src/init/itask.h
index b10d515..b10d515 100644
--- a/ioreplay/src/init/itask.h
+++ b/ioriot/src/init/itask.h
diff --git a/ioreplay/src/init/ithread.c b/ioriot/src/init/ithread.c
index a580e70..a580e70 100644
--- a/ioreplay/src/init/ithread.c
+++ b/ioriot/src/init/ithread.c
diff --git a/ioreplay/src/init/ithread.h b/ioriot/src/init/ithread.h
index 0884519..0884519 100644
--- a/ioreplay/src/init/ithread.h
+++ b/ioriot/src/init/ithread.h
diff --git a/ioreplay/src/macros.h b/ioriot/src/macros.h
index 45e5a10..45e5a10 100644
--- a/ioreplay/src/macros.h
+++ b/ioriot/src/macros.h
diff --git a/ioreplay/src/main.c b/ioriot/src/main.c
index 4a65de3..461711b 100644
--- a/ioreplay/src/main.c
+++ b/ioriot/src/main.c
@@ -16,7 +16,7 @@
  * @file main.c
  * @author Paul Buetow
  *
- * @brief The entry point of the I/O Replay program.
+ * @brief The entry point of the I/O Riot program.
  */
 
 #include <signal.h>
@@ -55,7 +55,7 @@ static void _arch_check_atomic(void)
  */
 static void _print_version(void)
 {
-    Put("This is I/O Replay %s - %s", IOREPLAY_VERSION, IOREPLAY_COPYRIGHT);
+    Put("This is I/O Riot %s - %s", IORIOT_VERSION, IORIOT_COPYRIGHT);
 }
 
 /**
@@ -66,15 +66,15 @@ static void _print_synopsis(void)
     _print_version();
 
     Put("Synopsis:");
-    Put("\tioreplay -c io.capture [-x PID] [-m MODULE]");
-    Put("\tioreplay -c io.capture -r io.replay [-n str] [-u str] [-w str]");
-    Put("\tioreplay -i io.replay");
-    Put("\tioreplay -r io.replay [-p #] [-t #] [-D] [-s #]");
-    Put("\tioreplay -R io.replay [-p #] [-t #] [-D] [-s #]");
-    Put("\tioreplay -d");
-    Put("\tioreplay -P");
-    Put("\tioreplay -T [-n NAME]");
-    Put("\tioreplay -V");
+    Put("\tioriot -c io.capture [-x PID] [-m MODULE]");
+    Put("\tioriot -c io.capture -r io.replay [-n str] [-u str] [-w str]");
+    Put("\tioriot -i io.replay");
+    Put("\tioriot -r io.replay [-p #] [-t #] [-D] [-s #]");
+    Put("\tioriot -R io.replay [-p #] [-t #] [-D] [-s #]");
+    Put("\tioriot -d");
+    Put("\tioriot -P");
+    Put("\tioriot -T [-n NAME]");
+    Put("\tioriot -V");
 }
 
 /**
@@ -85,7 +85,7 @@ static void _print_help(void)
     _print_synopsis();
 
     Put("Help:");
-    Put("\t-d            Drop all Linux/FS caches and exit ioreplay");
+    Put("\t-d            Drop all Linux/FS caches and exit ioriot");
     Put("\t-D            Don't drop all caches (in conjunction with -r/-R):");
     Put("\t-s SPEED      The speed factor (default: 0 [as fast as possible])");
     Put("\t-h            Print this help");
@@ -102,18 +102,18 @@ static void _print_help(void)
     Put("\t-P            Purge all trash directories of all tests)");
     Put("\t-V            Print I/O replay program version");
     Put("\t-w WD_BASE    The working directory's base path");
-    Put("\t              (default: /usr/local/ioreplay)");
+    Put("\t              (default: /usr/local/ioriot)");
     Put("\t-x PID        To specify a process ID (in conjunction with -c)");
     Put("\t-m MODULE     To specify a module (in conjunction with -c)");
     Put("\nExample (run these commands one after another):");
-    Put("\t 1.) sudo ioreplay -c io.capture");
-    Put("\t 2.) sudo ioreplay -r io.replay -c io.capture -u paul -n test1");
-    Put("\t 3.) sudo ioreplay -i io.replay");
-    Put("\t 4.) sudo ioreplay -r io.replay -S");
+    Put("\t 1.) sudo ioriot -c io.capture");
+    Put("\t 2.) sudo ioriot -r io.replay -c io.capture -u paul -n test1");
+    Put("\t 3.) sudo ioriot -i io.replay");
+    Put("\t 4.) sudo ioriot -r io.replay -S");
 }
 
 /**
- * @brief I/O Replay's entry point
+ * @brief I/O Riot's entry point
  *
  * Not much more to document here though!
  * @return The exit code
diff --git a/ioreplay/src/meta/meta.c b/ioriot/src/meta/meta.c
index d56c17e..d56c17e 100644
--- a/ioreplay/src/meta/meta.c
+++ b/ioriot/src/meta/meta.c
diff --git a/ioreplay/src/meta/meta.h b/ioriot/src/meta/meta.h
index 10002cc..1c160b1 100644
--- a/ioreplay/src/meta/meta.h
+++ b/ioriot/src/meta/meta.h
@@ -21,7 +21,7 @@
  * @brief The meta information definition
  *
  * This is used to write or read meta information to/from the header
- * of the .replay file. This information then is used by ioreplay
+ * of the .replay file. This information then is used by ioriot
  * in other steps. E.g. reading the amount of used file descriptors
  * from the meta header in order to allocate data structures of the
  * correct sizes before running the test!
diff --git a/ioreplay/src/mounts.c b/ioriot/src/mounts.c
index afa8376..d754557 100644
--- a/ioreplay/src/mounts.c
+++ b/ioriot/src/mounts.c
@@ -16,7 +16,7 @@
 
 #include "utils/futils.h"
 
-#define _PATH_INSERT "/.ioreplay/"
+#define _PATH_INSERT "/.ioriot/"
 #define _PATH_INSERT_LEN 11 // strlen of _PATH_INSERT
 
 void mounts_read(mounts_s *m)
@@ -240,14 +240,14 @@ void mounts_init(mounts_s *m)
         char *mp = m->mps[i];
         char *path = NULL;
 
-        // Create .ioreplay/ directory on MP
+        // Create .ioriot/ directory on MP
         asprintf(&path, "%s/%s", mp, _PATH_INSERT);
         ensure_dir_exists(path);
         chown_path(m->opts->user, path);
         free(path);
         path = NULL;
 
-        // Create .ioreplay/NAME directory on MP
+        // Create .ioriot/NAME directory on MP
         asprintf(&path, "%s/%s/%s", mp, _PATH_INSERT, opts->name);
         ensure_dir_exists(path);
         chown_path(m->opts->user, path);
@@ -339,7 +339,7 @@ bool mounts_transform_path(mounts_s *m, const char *name,
     }
 
     // So the path is on a valid mount point! Now we need to insert
-    // .ioreplay/NAME to each mount point, e.g. /usr/local/.ioreplay/NAME/...
+    // .ioriot/NAME to each mount point, e.g. /usr/local/.ioriot/NAME/...
 
     // Iterate backwards through all mount points.
     for (int i = m->count-1; i >= 0; --i) {
@@ -348,7 +348,7 @@ bool mounts_transform_path(mounts_s *m, const char *name,
 
         if (strncmp(path, mountpoint, mp_len) == 0) {
             // Found a path to replace
-            // Now insert .ioreplay/NAME/ into the file path.
+            // Now insert .ioriot/NAME/ into the file path.
             *path_r = Calloc(strlen(path) + strlen(name)+1
                              + _PATH_INSERT_LEN+1, char);
 
diff --git a/ioreplay/src/mounts.h b/ioriot/src/mounts.h
index a644ddb..1c4a3d4 100644
--- a/ioreplay/src/mounts.h
+++ b/ioriot/src/mounts.h
@@ -65,8 +65,8 @@ void mounts_destroy(mounts_s *m);
 /**
  * @brief moves all files within replay mounts to trash
  *
- * It moves all files of the .ioreplay/NAME directories to
- * .ioreplay/NAME.trashEPOCH directories for all available mount points.
+ * It moves all files of the .ioriot/NAME directories to
+ * .ioriot/NAME.trashEPOCH directories for all available mount points.
  * It does the same for the working dorectory of the current test.
  *
  * @param m The responsible mounts object
@@ -76,7 +76,7 @@ void mounts_trash(mounts_s *m);
 /**
  * @brief Deletes all files within replay mounts
  *
- * It deletes all files from the .ioreplay/ directories for all availabe
+ * It deletes all files from the .ioriot/ directories for all availabe
  * mount points. It also deletes the working directory of all tests. The
  * function forks one sub-process per mount point, so it is cleaning all drives
  * in parallel.
@@ -91,9 +91,9 @@ void mounts_trash(mounts_s *m);
 void mounts_purge(mounts_s *m);
 
 /**
- * @brief Ensures all mounts have a .ioreplay/NAME directory
+ * @brief Ensures all mounts have a .ioriot/NAME directory
  *
- * These directories are used by ioreplay to run the I/O replay tests in.
+ * These directories are used by ioriot to run the I/O replay tests in.
  * The function also ensures to have the correct user permissions for these
  * directories.
  *
@@ -111,7 +111,7 @@ void mounts_read(mounts_s *m);
 /**
  * @brief Determines whether a path should be ignored
  *
- * ioreplay replays I/O only on known mount points of known
+ * ioriot replays I/O only on known mount points of known
  * file system types. This function helps to determine whether
  * a path is on a valid mount point or not.
  *
@@ -122,9 +122,9 @@ void mounts_read(mounts_s *m);
 bool mounts_ignore_path(mounts_s *m, const char *path);
 
 /**
- * @brief Inserts ./ioreplay/NAME into a path
+ * @brief Inserts ./ioriot/NAME into a path
  *
- * This function inserts ./ioreplay/NAME into a given file path.
+ * This function inserts ./ioriot/NAME into a given file path.
  * The function also checks whether the path is on a supported replay
  * path or not. E.g. we want to ignore file systems such as devfs, sysfs,
  * procfs.. etc.
diff --git a/ioreplay/src/opcodes.h b/ioriot/src/opcodes.h
index 3d5c114..3d5c114 100644
--- a/ioreplay/src/opcodes.h
+++ b/ioriot/src/opcodes.h
diff --git a/ioreplay/src/options.c b/ioriot/src/options.c
index c1dcdb9..01a5375 100644
--- a/ioreplay/src/options.c
+++ b/ioriot/src/options.c
@@ -21,7 +21,7 @@ options_s *options_new()
     o->capture_file = NULL;
     o->replay_file = NULL;
     o->stats_file = NULL;
-    o->wd_base = "/usr/local/ioreplay";
+    o->wd_base = "/usr/local/ioriot";
     o->num_workers = 4;
     o->num_threads_per_worker = 128;
     o->user = "mcuser";
@@ -33,7 +33,7 @@ options_s *options_new()
     o->purge = false;
     o->trash = false;
     o->pid = -1;
-    o->module = "ioreplay.ko";
+    o->module = "ioriot.ko";
 
     return o;
 }
diff --git a/ioreplay/src/options.h b/ioriot/src/options.h
index 66cb0f7..eca92ff 100644
--- a/ioreplay/src/options.h
+++ b/ioriot/src/options.h
@@ -27,15 +27,15 @@ typedef struct options_s_ {
     char *stats_file; /**< The name of the .stats file */
     bool write_stats_file; /**< Write a stats file at the end of the test */
     char *user; /**< The user name to run the test as */
-    char *name; /**< The name of the test (found in .ioreplay/name sub-dirs) */
+    char *name; /**< The name of the test (found in .ioriot/name sub-dirs) */
     char *wd_base; /**< The working directory base */
     int num_workers; /**< The amount of worker processes */
     int num_threads_per_worker; /**< Max threads per worker processes */
-    bool init; /**< If set ioreplay will initialise the environment */
-    bool replay; /**< If set ioreplay will run/replay the test */
-    bool purge; /**< If set ioreplay will purge the environment */
-    bool trash; /**< If set ioreplay will trash the environment */
-    bool drop_caches; /**< True if  ioreplay should drop all Linux caches */
+    bool init; /**< If set ioriot will initialise the environment */
+    bool replay; /**< If set ioriot will run/replay the test */
+    bool purge; /**< If set ioriot will purge the environment */
+    bool trash; /**< If set ioriot will trash the environment */
+    bool drop_caches; /**< True if  ioriot should drop all Linux caches */
     double speed_factor; /**< Specifies how fast the test is replayed */
     int pid; /**< Specifies a process id to capture */
     char *module; /**< Specifies the kernel module for capturing */
diff --git a/ioreplay/src/replay/replay.c b/ioriot/src/replay/replay.c
index e4606d1..e4606d1 100644
--- a/ioreplay/src/replay/replay.c
+++ b/ioriot/src/replay/replay.c
diff --git a/ioreplay/src/replay/replay.h b/ioriot/src/replay/replay.h
index dcc3d84..dcc3d84 100644
--- a/ioreplay/src/replay/replay.h
+++ b/ioriot/src/replay/replay.h
diff --git a/ioreplay/src/replay/rioop.c b/ioriot/src/replay/rioop.c
index 2e16c94..2e16c94 100644
--- a/ioreplay/src/replay/rioop.c
+++ b/ioriot/src/replay/rioop.c
diff --git a/ioreplay/src/replay/rioop.h b/ioriot/src/replay/rioop.h
index 4db4284..4db4284 100644
--- a/ioreplay/src/replay/rioop.h
+++ b/ioriot/src/replay/rioop.h
diff --git a/ioreplay/src/replay/rprocess.c b/ioriot/src/replay/rprocess.c
index 4efd835..4efd835 100644
--- a/ioreplay/src/replay/rprocess.c
+++ b/ioriot/src/replay/rprocess.c
diff --git a/ioreplay/src/replay/rprocess.h b/ioriot/src/replay/rprocess.h
index 739dd89..adba0f3 100644
--- a/ioreplay/src/replay/rprocess.h
+++ b/ioriot/src/replay/rprocess.h
@@ -30,7 +30,7 @@ typedef struct rprocess_s_ {
     int rworker_num; /**< The worker number of the responsible worker */
     int pid; /**< The virtual process ID */
     unsigned long lineno; /**< Holding the current .replay line number */
-    bool initm; /**< Indicates whether ioreplay is in init mode or not */
+    bool initm; /**< Indicates whether ioriot is in init mode or not */
     amap_s *fds_map; /**< Holding all file descriptors */
 } rprocess_s;
 
diff --git a/ioreplay/src/replay/rstats.c b/ioriot/src/replay/rstats.c
index c3e6e38..c3e6e38 100644
--- a/ioreplay/src/replay/rstats.c
+++ b/ioriot/src/replay/rstats.c
diff --git a/ioreplay/src/replay/rstats.h b/ioriot/src/replay/rstats.h
index 1ce3f27..1ce3f27 100644
--- a/ioreplay/src/replay/rstats.h
+++ b/ioriot/src/replay/rstats.h
diff --git a/ioreplay/src/replay/rtask.c b/ioriot/src/replay/rtask.c
index b1afb92..b1afb92 100644
--- a/ioreplay/src/replay/rtask.c
+++ b/ioriot/src/replay/rtask.c
diff --git a/ioreplay/src/replay/rtask.h b/ioriot/src/replay/rtask.h
index 35c5714..35c5714 100644
--- a/ioreplay/src/replay/rtask.h
+++ b/ioriot/src/replay/rtask.h
diff --git a/ioreplay/src/replay/rthread.c b/ioriot/src/replay/rthread.c
index 55364ec..ae0a597 100644
--- a/ioreplay/src/replay/rthread.c
+++ b/ioriot/src/replay/rthread.c
@@ -31,10 +31,10 @@ static void _rthread_init_log(rthread_s *t)
 {
     rworker_s *w = t->worker;
     char *rthread_log = Calloc(1024, char);
-    snprintf(rthread_log, 1023, "/tmp/ioreplay/worker%d.thread%ld.debuglog",
+    snprintf(rthread_log, 1023, "/tmp/ioriot/worker%d.thread%ld.debuglog",
              w->rworker_num, (long)pthread_self());
 
-    ensure_dir_exists("/tmp/ioreplay");
+    ensure_dir_exists("/tmp/ioriot");
     t->rthread_fd = Fopen(rthread_log, "a");
 
     free(rthread_log);
diff --git a/ioreplay/src/replay/rthread.h b/ioriot/src/replay/rthread.h
index 9971e49..9971e49 100644
--- a/ioreplay/src/replay/rthread.h
+++ b/ioriot/src/replay/rthread.h
diff --git a/ioreplay/src/replay/rworker.c b/ioriot/src/replay/rworker.c
index 0e3fbe9..89bb49f 100644
--- a/ioreplay/src/replay/rworker.c
+++ b/ioriot/src/replay/rworker.c
@@ -41,7 +41,7 @@ rworker_s* rworker_new(const int rworker_num, amap_s *fds_map,
 
 #ifdef THREAD_DEBUG
     char *rworker_log = Calloc(1024, char);
-    snprintf(rworker_log, 1023, "/tmp/ioreplay/_worker%d.debuglog",
+    snprintf(rworker_log, 1023, "/tmp/ioriot/_worker%d.debuglog",
              rworker_num);
 
     w->rworker_fd = Fopen(rworker_log, "a");
diff --git a/ioreplay/src/replay/rworker.h b/ioriot/src/replay/rworker.h
index 26a1300..26a1300 100644
--- a/ioreplay/src/replay/rworker.h
+++ b/ioriot/src/replay/rworker.h
diff --git a/ioreplay/src/utests.c b/ioriot/src/utests.c
index 7cc4959..7cc4959 100644
--- a/ioreplay/src/utests.c
+++ b/ioriot/src/utests.c
diff --git a/ioreplay/src/utests.h b/ioriot/src/utests.h
index 4ad6973..4ad6973 100644
--- a/ioreplay/src/utests.h
+++ b/ioriot/src/utests.h
diff --git a/ioreplay/src/utils/futils.c b/ioriot/src/utils/futils.c
index 5b35618..5b35618 100644
--- a/ioreplay/src/utils/futils.c
+++ b/ioriot/src/utils/futils.c
diff --git a/ioreplay/src/utils/futils.h b/ioriot/src/utils/futils.h
index 9afde1a..9afde1a 100644
--- a/ioreplay/src/utils/futils.h
+++ b/ioriot/src/utils/futils.h
diff --git a/ioreplay/src/utils/utils.c b/ioriot/src/utils/utils.c
index 4b41273..4b41273 100644
--- a/ioreplay/src/utils/utils.c
+++ b/ioriot/src/utils/utils.c
diff --git a/ioreplay/src/utils/utils.h b/ioriot/src/utils/utils.h
index 3e86865..3e86865 100644
--- a/ioreplay/src/utils/utils.h
+++ b/ioriot/src/utils/utils.h
diff --git a/ioreplay/src/vfd.c b/ioriot/src/vfd.c
index 6e86f61..6e86f61 100644
--- a/ioreplay/src/vfd.c
+++ b/ioriot/src/vfd.c
diff --git a/ioreplay/src/vfd.h b/ioriot/src/vfd.h
index fd0c4fb..ff9c79c 100644
--- a/ioreplay/src/vfd.h
+++ b/ioriot/src/vfd.h
@@ -21,7 +21,7 @@
 /**
  * @brief The virtual file descriptor definition
  *
- * A virtual file descriptor represents a file descriptor from ioreplay's
+ * A virtual file descriptor represents a file descriptor from ioriot's
  * point of view and is being used in various ways to simulate the real I/O
  * protocolled to the .capture/.replay files.
  *
diff --git a/ioreplay/tags b/ioriot/tags
index cbad51a..65fdc50 100644
--- a/ioreplay/tags
+++ b/ioriot/tags
@@ -57,8 +57,8 @@ HMAP_H	./src/datas/hmap.h	2;"	d
 Has	./src/macros.h	17;"	d
 Hasnt	./src/macros.h	18;"	d
 INIT_H	./src/init/init.h	2;"	d
-IOREPLAY_COPYRIGHT	./src/defaults.h	19;"	d
-IOREPLAY_VERSION	./src/defaults.h	17;"	d
+IORIOT_COPYRIGHT	./src/defaults.h	19;"	d
+IORIOT_VERSION	./src/defaults.h	17;"	d
 ITASK_H	./src/init/itask.h	2;"	d
 ITHREAD_H	./src/init/ithread.h	2;"	d
 LCHOWN	./src/opcodes.h	/^    LCHOWN,$/;"	e	enum:__anon1
@@ -225,7 +225,7 @@ debug	./src/vfd.h	/^    int debug; \/**< Used for debugging purposes only *\/$/;
 dirfd	./src/vfd.h	/^    DIR *dirfd; \/**< The real dirfd *\/$/;"	m	struct:vfd_s_
 dirname_r	./src/utils/futils.c	/^char* dirname_r(char *path)$/;"	f
 dirs_created	./src/init/itask.h	/^    long dirs_created;$/;"	m	struct:itask_s_
-drop_caches	./src/options.h	/^    bool drop_caches; \/**< True if  ioreplay should drop all Linux caches *\/$/;"	m	struct:options_s_
+drop_caches	./src/options.h	/^    bool drop_caches; \/**< True if  ioriot should drop all Linux caches *\/$/;"	m	struct:options_s_
 drop_caches	./src/utils/futils.c	/^void drop_caches(void)$/;"	f
 drop_root	./src/utils/utils.c	/^void drop_root(const char *user)$/;"	f
 ensure_dir_empty	./src/utils/futils.c	/^void ensure_dir_empty(const char *path)$/;"	f
@@ -353,7 +353,7 @@ id	./src/generate/vsize.h	/^    unsigned long id; \/**< The vsize id *\/$/;"	m	s
 ignore_count	./src/mounts.h	/^    int ignore_count; \/**< The amount of ignored mount points *\/$/;"	m	struct:mounts_s_
 ignore_mps	./src/mounts.h	/^    char *ignore_mps[MAX_MOUNTPOINTS]; \/**< The ignored mp paths *\/$/;"	m	struct:mounts_s_
 init	./src/init/ithread.h	/^    init_s *init; \/**< The responsible init object *\/$/;"	m	struct:ithread_s_
-init	./src/options.h	/^    bool init; \/**< If set ioreplay will initialise the environment *\/$/;"	m	struct:options_s_
+init	./src/options.h	/^    bool init; \/**< If set ioriot will initialise the environment *\/$/;"	m	struct:options_s_
 init_destroy	./src/init/init.c	/^void init_destroy(init_s *i)$/;"	f
 init_extract_header	./src/init/init.c	/^void init_extract_header(init_s *i, off_t *init_offset)$/;"	f
 init_new	./src/init/init.c	/^init_s *init_new(options_s *opts)$/;"	f
@@ -361,7 +361,7 @@ init_parent_dir	./src/generate/vsize.c	/^void init_parent_dir(vsize_s *v, const
 init_run	./src/init/init.c	/^status_e init_run(options_s *opts)$/;"	f
 init_s	./src/init/init.h	/^} init_s;$/;"	t	typeref:struct:init_s_
 init_s_	./src/init/init.h	/^typedef struct init_s_ {$/;"	s
-initm	./src/replay/rprocess.h	/^    bool initm; \/**< Indicates whether ioreplay is in init mode or not *\/$/;"	m	struct:rprocess_s_
+initm	./src/replay/rprocess.h	/^    bool initm; \/**< Indicates whether ioriot is in init mode or not *\/$/;"	m	struct:rprocess_s_
 inserted	./src/generate/vsize.h	/^    bool inserted; \/**< For debugging purposes only *\/$/;"	m	struct:vsize_s_
 is_dir	./src/generate/vsize.h	/^    bool is_dir; \/**< True if this file\/dir is a directory *\/$/;"	m	struct:vsize_s_
 is_dir	./src/init/itask.h	/^    bool is_dir;$/;"	m	struct:itask_s_
@@ -453,7 +453,7 @@ mounts_trash	./src/mounts.c	/^void mounts_trash(mounts_s *m)$/;"	f
 mps	./src/generate/generate.h	/^    mounts_s *mps; \/**< The mounts object *\/$/;"	m	struct:generate_s_
 mps	./src/mounts.h	/^    char *mps[MAX_MOUNTPOINTS]; \/**< The mp paths *\/$/;"	m	struct:mounts_s_
 name	./src/generate/generate.h	/^    char *name; \/**< The name of the test specified by the user *\/$/;"	m	struct:generate_s_
-name	./src/options.h	/^    char *name; \/**< The name of the test (found in .ioreplay\/name sub-dirs) *\/$/;"	m	struct:options_s_
+name	./src/options.h	/^    char *name; \/**< The name of the test (found in .ioriot\/name sub-dirs) *\/$/;"	m	struct:options_s_
 next	./src/datas/list.h	/^    struct list_elem_s_ *next; \/**< The next element *\/$/;"	m	struct:list_elem_s_	typeref:struct:list_elem_s_::list_elem_s_
 next	./src/datas/stack.h	/^    struct stack_elem_s_ *next; \/**< The next element *\/$/;"	m	struct:stack_elem_s_	typeref:struct:stack_elem_s_::stack_elem_s_
 notnull	./src/utils/utils.c	/^void* notnull(void *p, char *file, int line, int count)$/;"	f
@@ -497,7 +497,7 @@ pthread	./src/generate/gparser.h	/^    pthread_t pthread; \/**< The posix thread
 pthread	./src/generate/gwriter.h	/^    pthread_t pthread; \/**< The posix thread *\/$/;"	m	struct:gwriter_s_
 pthread	./src/init/ithread.h	/^    pthread_t pthread; \/**< We run the init tasks in concurrent pthreads *\/$/;"	m	struct:ithread_s_
 pthread	./src/replay/rthread.h	/^    pthread_t pthread; \/**< We run the tasks in concurrent pthreads *\/$/;"	m	struct:rthread_s_
-purge	./src/options.h	/^    bool purge; \/**< If set ioreplay will purge the environment *\/$/;"	m	struct:options_s_
+purge	./src/options.h	/^    bool purge; \/**< If set ioriot will purge the environment *\/$/;"	m	struct:options_s_
 queue	./src/generate/gparser.h	/^    rbuffer_s *queue; \/**< A queue of task objects *\/$/;"	m	struct:gparser_s_
 queue	./src/generate/gwriter.h	/^    rbuffer_s *queue; \/**< A queue of task objects *\/$/;"	m	struct:gwriter_s_
 queue	./src/init/ithread.h	/^    rbuffer_s *queue; \/**< The thread's task queue *\/$/;"	m	struct:ithread_s_
@@ -513,7 +513,7 @@ rbuffer_test	./src/datas/rbuffer.c	/^void rbuffer_test(void)$/;"	f
 read_buf	./src/meta/meta.h	/^    char* read_buf; \/**< Pointer to a read buffer *\/$/;"	m	struct:meta_s_
 read_pos	./src/datas/rbuffer.h	/^    sig_atomic_t read_pos;$/;"	m	struct:rbuffer_s_
 renamed	./src/generate/vsize.h	/^    bool renamed; \/**< True if file\/dir has been renamed *\/$/;"	m	struct:vsize_s_
-replay	./src/options.h	/^    bool replay; \/**< If set ioreplay will run\/replay the test *\/$/;"	m	struct:options_s_
+replay	./src/options.h	/^    bool replay; \/**< If set ioriot will run\/replay the test *\/$/;"	m	struct:options_s_
 replay_extract_header	./src/replay/replay.c	/^void replay_extract_header(options_s *opts, FILE *replay_fd, long *num_vsizes,$/;"	f
 replay_fd	./src/generate/generate.h	/^    FILE *replay_fd; \/**< The fd of the .replay file *\/$/;"	m	struct:generate_s_
 replay_fd	./src/init/init.h	/^    FILE *replay_fd;$/;"	m	struct:init_s_
@@ -521,7 +521,7 @@ replay_fd	./src/meta/meta.h	/^    FILE* replay_fd; \/**< The FS of the .replay f
 replay_file	./src/options.h	/^    char *replay_file; \/**< The name of the .replay file *\/$/;"	m	struct:options_s_
 replay_run	./src/replay/replay.c	/^status_e replay_run(options_s *opts)$/;"	f
 required	./src/generate/vsize.h	/^    bool required; \/**< True if init mode will create this file\/dir *\/$/;"	m	struct:vsize_s_
-ret	./src/generate/gtask.h	/^    int ret; \/**< ioreplay process status, SUCCESS if everything is alright *\/$/;"	m	struct:gtask_s_
+ret	./src/generate/gtask.h	/^    int ret; \/**< ioriot process status, SUCCESS if everything is alright *\/$/;"	m	struct:gtask_s_
 reuse_queue	./src/generate/generate.h	/^    rbuffer_s *reuse_queue; \/**< A task buffer, for reusing these *\/$/;"	m	struct:generate_s_
 reuse_queue	./src/init/init.h	/^    rbuffer_s *reuse_queue;$/;"	m	struct:init_s_
 reuse_queue_mutex	./src/init/init.h	/^    pthread_mutex_t reuse_queue_mutex;$/;"	m	struct:init_s_
@@ -617,7 +617,7 @@ tid	./src/generate/gtask.h	/^    long tid; \/**< The thread ID *\/$/;"	m	struct:
 tid	./src/replay/rthread.h	/^    long tid; \/**< The virtual thread id *\/$/;"	m	struct:rthread_s_
 toks	./src/replay/rtask.h	/^    char *toks[MAX_TOKENS+1]; \/**< The tokens parsed from the .replay line *\/$/;"	m	struct:rtask_s_
 top	./src/datas/stack.h	/^    stack_elem_s *top; \/**< The top element of the stack, NULL if empty *\/$/;"	m	struct:stack_s_
-trash	./src/options.h	/^    bool trash; \/**< If set ioreplay will trash the environment *\/$/;"	m	struct:options_s_
+trash	./src/options.h	/^    bool trash; \/**< If set ioriot will trash the environment *\/$/;"	m	struct:options_s_
 unsure	./src/generate/vsize.h	/^    bool unsure; \/**< True if the file type is not fully clear *\/$/;"	m	struct:vsize_s_
 updates	./src/generate/vsize.h	/^    long updates; \/**< Amount of times this vsize has been updated *\/$/;"	m	struct:vsize_s_
 user	./src/options.h	/^    char *user; \/**< The user name to run the test as *\/$/;"	m	struct:options_s_
diff --git a/systemtap/Makefile b/systemtap/Makefile
index f027719..49f1977 100644
--- a/systemtap/Makefile
+++ b/systemtap/Makefile
@@ -1,15 +1,15 @@
 KERNEL ?= $(shell uname -r)
 PROCESSOR ?= $(shell uname -p)
-DESTDIR ?= /opt/ioreplay/systemtap/$(KERNEL)
+DESTDIR ?= /opt/ioriot/systemtap/$(KERNEL)
 UPDATEURI = http://debuginfo.centos.org/7/$(PROCESSOR)
 DOWNLOADIR ?= ./downloads
 all: prepare compile
 prepare:
-	sed 's/execname() != "stapio"/pid() == target()/' ./src/ioreplay.stp > ./src/targetedioreplay.stp
-	sed 's/execname() != "stapio"/execname() == "java"/' ./src/ioreplay.stp > ./src/javaioreplay.stp
+	sed 's/execname() != "stapio"/pid() == target()/' ./src/ioriot.stp > ./src/targetedioriot.stp
+	sed 's/execname() != "stapio"/execname() == "java"/' ./src/ioriot.stp > ./src/javaioriot.stp
 compile:
 	@echo Crosscompiling for Kernel version $(KERNEL)
-	for stp in ioreplay javaioreplay targetedioreplay; do \
+	for stp in ioriot javaioriot targetedioriot; do \
 		stap -v ./src/$$stp.stp -p 4 -r $(KERNEL) -m $$stp \
 		-D MAXSTRINGLEN=255 -D MAXACTION=10000 -D MAXSKIPPED=10000\
 		-g --suppress-time-limits --suppress-handler-errors; \
@@ -18,14 +18,14 @@ testsystemtap:
 	stap -v -e 'probe vfs.read {printf("read performed\n"); exit()}'
 clean:
 	@echo Cleaning modules
-	test -f ioreplay.ko && rm -v ioreplay.ko || exit 0
-	test -f javaioreplay.ko && rm -v javaioreplay.ko || exit 0
-	test -f targetedioreplay.ko && rm -v targetedioreplay.ko || exit 0
+	test -f ioriot.ko && rm -v ioriot.ko || exit 0
+	test -f javaioriot.ko && rm -v javaioriot.ko || exit 0
+	test -f targetedioriot.ko && rm -v targetedioriot.ko || exit 0
 install:
 	test -d $(DESTDIR) || mkdir -p $(DESTDIR)
-	test -f ioreplay.ko && cp -v ioreplay.ko $(DESTDIR)/ || exit 0
-	test -f javaioreplay.ko && cp -v javaioreplay.ko $(DESTDIR)/ || exit 0
-	test -f targetedioreplay.ko && cp -v targetedioreplay.ko $(DESTDIR)/ || exit 0
+	test -f ioriot.ko && cp -v ioriot.ko $(DESTDIR)/ || exit 0
+	test -f javaioriot.ko && cp -v javaioriot.ko $(DESTDIR)/ || exit 0
+	test -f targetedioriot.ko && cp -v targetedioriot.ko $(DESTDIR)/ || exit 0
 uninstall:
 	test ! -z "$(DESTDIR)" && test -d $(DESTDIR)/ && find $(DESTDIR) -name \*.ko -delete || exit 0
 deinstall: uninstall
diff --git a/systemtap/src/ioreplay.stp b/systemtap/src/ioriot.stp
index c4b4f0b..9ea6a68 100644
--- a/systemtap/src/ioreplay.stp
+++ b/systemtap/src/ioriot.stp
@@ -15,7 +15,7 @@
 # limitations under the License.
 
 # This script is used to capture I/O on a Linux based system in order to replay
-# the same I/O via the ioreplay command line utility.
+# the same I/O via the ioriot command line utility.
 #
 # The tool will generate one line per captured I/O syscall to a .capture log
 # file.
diff --git a/systemtap/src/javaioreplay.stp b/systemtap/src/javaioriot.stp
index 4fca0ef..3943971 100644
--- a/systemtap/src/javaioreplay.stp
+++ b/systemtap/src/javaioriot.stp
@@ -15,7 +15,7 @@
 # limitations under the License.
 
 # This script is used to capture I/O on a Linux based system in order to replay
-# the same I/O via the ioreplay command line utility.
+# the same I/O via the ioriot command line utility.
 #
 # The tool will generate one line per captured I/O syscall to a .capture log
 # file.
diff --git a/systemtap/src/targetedioreplay.stp b/systemtap/src/targetedioriot.stp
index 139a89b..f72dc66 100644
--- a/systemtap/src/targetedioreplay.stp
+++ b/systemtap/src/targetedioriot.stp
@@ -15,7 +15,7 @@
 # limitations under the License.
 
 # This script is used to capture I/O on a Linux based system in order to replay
-# the same I/O via the ioreplay command line utility.
+# the same I/O via the ioriot command line utility.
 #
 # The tool will generate one line per captured I/O syscall to a .capture log
 # file.