Skip to content
Snippets Groups Projects
Commit 033a48a8 authored by Ruben Otto's avatar Ruben Otto :crab:
Browse files

chore: unify naming schemes & remove redundant code

parent fe31481d
No related branches found
No related tags found
No related merge requests found
Showing
with 173 additions and 266 deletions
add_subdirectory(cpu_temp) add_subdirectory(cpu_temp)
add_subdirectory(test)
...@@ -5,7 +5,7 @@ ...@@ -5,7 +5,7 @@
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include <string.h> #include <string.h>
#include "../../../common/include/protocol.h" #include "../../../common/include/message.h"
#include "../../../common/include/userspace_comm.h" #include "../../../common/include/userspace_comm.h"
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
...@@ -14,8 +14,8 @@ int main(int argc, char* argv[]) { ...@@ -14,8 +14,8 @@ int main(int argc, char* argv[]) {
return EXIT_FAILURE; return EXIT_FAILURE;
} }
send_t send; userspace_send_handle_t userspace_send_handle;
if (send_init(&send) == -1) { if (create_userspace_send_handle(&userspace_send_handle) == -1) {
perror("Failed to open message queue"); perror("Failed to open message queue");
return EXIT_FAILURE; return EXIT_FAILURE;
} }
...@@ -39,20 +39,20 @@ int main(int argc, char* argv[]) { ...@@ -39,20 +39,20 @@ int main(int argc, char* argv[]) {
cpu_temp = (double)atoi(buffer) / 1000; cpu_temp = (double)atoi(buffer) / 1000;
daemon_measurement_t packet = { message_t message = {
.measurement_id=atoi(argv[1]), .measurement_id=atoi(argv[1]),
.datatype=FLOAT64, .datatype=FLOAT64,
.length=sizeof(cpu_temp) .length=sizeof(cpu_temp)
}; };
memcpy(&packet.data, &cpu_temp, sizeof(cpu_temp)); memcpy(&message.data, &cpu_temp, sizeof(cpu_temp));
send_send(&send, packet); send_userspace_message(&userspace_send_handle, message);
usleep(sleep_ms * 1000); usleep(sleep_ms * 1000);
} }
send_destroy(&send); destroy_userspace_send_handle(&userspace_send_handle);
close(file_fd); close(file_fd);
return EXIT_SUCCESS; return EXIT_SUCCESS;
......
add_executable(test
src/test.c
)
target_link_libraries(test
PRIVATE common
)
target_include_directories(test
PRIVATE include
)
#include <stdio.h>
#include "../../../common/include/communication.h"
#define PATH "/dev/amogus"
int main(int argc, char* argv[]) {
communication_handle_t handle;
if(create_communication_handle(PATH, &handle) != 0) {
printf("Couldn't create communication handle, did you sudo\n");
return 0;
}
printf("Created communication handle\n");
message_t message;
uint32_t data = 69;
if(create_message(&message, 0, sizeof(uint32_t),UINT32, &data) != 0) {
printf("Couldn't create message\n");
return 0;
}
printf("Created message\n");
if(push_message(&handle, &message) != 0) {
printf("Couldn't push message\n");
return 0;
}
printf("Destroyed message\n");
destroy_communication_handle(&handle);
printf("Destroyed communication handle\n");
}
add_library(common add_library(common
src/protocol.c src/message.c
src/userspace_comm.c src/userspace_comm.c
src/communication.c
) )
target_include_directories(common target_include_directories(common
PUBLIC include PUBLIC include
......
#pragma once
#include <stddef.h>
#include <stdint.h>
#include "message.h"
typedef struct communication_handle {
int fd;
} communication_handle_t;
int create_communication_handle(char* path, communication_handle_t* handle);
void destroy_communication_handle(communication_handle_t* handle);
int create_message(message_t* message, int32_t id, message_data_type_t type, size_t length, void* data);
int push_message(communication_handle_t* handle, message_t* message);
void destroy_message(message_t* message);
...@@ -15,7 +15,7 @@ ...@@ -15,7 +15,7 @@
#include <stddef.h> #include <stddef.h>
#endif #endif
#define MESSAGE_DATA_SIZE 4096 #define MAX_MESSAGE_DATA_SIZE 4096
typedef enum message_data_type : uint32_t { typedef enum message_data_type : uint32_t {
INT8, INT8,
...@@ -30,11 +30,33 @@ typedef enum message_data_type : uint32_t { ...@@ -30,11 +30,33 @@ typedef enum message_data_type : uint32_t {
FLOAT64 FLOAT64
} message_data_type_t; } message_data_type_t;
/**
* typedef message_t - Structure to hold a message with a measurement.
* @measurement_id: The id of the measurement. Every sender should have a unique id.
* @daemon_measurement_datatype: Datatype of the data. All values in `data` must be of this type.
* @length: How many types of `datatype` are in `data`. Must not exceed (`length` * daemon_measurement_datatype_size(`datatype`)) > MAX_DAEMON_PACKET_DATA_SIZE.
* @data: The measurement data.
*/
typedef struct message { typedef struct message {
int32_t id; uint8_t measurement_id;
message_data_type_t type; message_data_type_t datatype;
uint32_t length; uint16_t length;
uint8_t data[MESSAGE_DATA_SIZE]; uint8_t data[MAX_MESSAGE_DATA_SIZE];
} message_t; } message_t;
/**
* message_data_type_size() - Get the size of a `message_data_type_t`.
* @arg1: The datatype to get the size of.
*
* Returns the size.
*/
size_t message_data_type_size(message_data_type_t type); size_t message_data_type_size(message_data_type_t type);
/**
* message_check() - Check if a `message_t` is correct.
* @arg1: Message to check.
*
* Checks if the datatype size * length not exceeds MAX_DAEMON_PACKET_DATA_SIZE.
*
* Returns 0 on success, -1 on error.
*/
int message_check(message_t* message);
#pragma once
#include <stdint.h>
#include <sys/ipc.h>
#define MAX_DAEMON_PACKET_DATA_SIZE 4096
#define MSG_QUEUE_KEY "/var/run/sibyl"
#define MSG_QUEUE_PROJ_ID 69
/**
* typedef daemon_measurement_datatype_t - Enum of possible datatypes for `daemon_measurement_t`.
*/
typedef enum {
CHAR,
INT64,
UINT64,
FLOAT64
} __attribute__ ((__packed__)) daemon_measurement_datatype_t;
/**
* typedef daemon_measurement_t - Structure to hold a userspace measurement.
* @measurement_id: The id of the measurement. Every sender should have a unique id.
* @daemon_measurement_datatype: Datatype of the data. All values in `data` must be of this type.
* @length: How many types of `datatype` are in `data`. Must not exceed (`length` * daemon_measurement_datatype_size(`datatype`)) > MAX_DAEMON_PACKET_DATA_SIZE.
* @data: The measurement data.
*/
typedef struct {
uint8_t measurement_id;
daemon_measurement_datatype_t datatype;
uint16_t length;
uint8_t data[MAX_DAEMON_PACKET_DATA_SIZE];
} daemon_measurement_t;
/**
* daemon_measurement_datatype_size() - Get the size of a `daemon_measurement_datatype_t`.
* @arg1: The datatype to get the size of.
*
* Returns the size.
*/
int daemon_measurement_datatype_size(daemon_measurement_datatype_t datatype);
/**
* daemon_measurement_check() - Check if a `daemon_measurement_t` is correct.
* @arg1: Measurement to check.
*
* Checks if the datatype size * length not exceeds MAX_DAEMON_PACKET_DATA_SIZE.
*
* Returns 0 on success, -1 on error.
*/
int daemon_measurement_check(daemon_measurement_t* daemon_measurement);
/**
* msg_queue_key() - Return the message queue key for the userspace communication.
*
* Returns the key of the message queue or -1 on error.
*/
key_t msg_queue_key();
#pragma once #pragma once
#include "protocol.h"
#include "message.h"
#include <sys/ipc.h>
#define MESSAGE_MEASUREMENT_ID 1 #define MESSAGE_MEASUREMENT_ID 1
#define MSG_QUEUE_KEY "/var/run/sibyl"
#define MSG_QUEUE_PROJ_ID 69
/** /**
* typedef send_t - Holds the a handle to the message queue. * typedef userspace_send_handle_t - Holds the a handle to the message queue.
* @msg_queue_id: Id of the message queue. * @msg_queue_id: Id of the message queue.
*/ */
typedef struct { typedef struct {
int msg_queue_id; int msg_queue_id;
} send_t; } userspace_send_handle_t;
/** /**
* typedef message_t - Wrapper around `daemon_measurement_t` to make it sendable over a message queue. * typedef message_queue_message_t - Wrapper around `daemon_measurement_t` to make it sendable over a message queue.
* @message_type: The messages' type. * @message_type: The messages' type.
* @measurement: The measurement. * @measurement: The measurement.
*/ */
typedef struct { typedef struct {
// required by the message queue api in order to work // required by the message queue api in order to work
long message_type; long message_type;
daemon_measurement_t measurement; message_t message;
} message_t; } message_queue_message_t;
/**
* msg_queue_key() - Return the message queue key for the userspace communication.
*
* Returns the key of the message queue or -1 on error.
*/
key_t msg_queue_key();
/** /**
* send_init() - Initializes the send module. * create_userspace_send_handle_t() - Initializes the send module.
* @arg1: The send module. * @arg1: The send module.
* *
* Tries to get a handle to a message queue. * Tries to get a handle to a message queue.
...@@ -31,13 +42,13 @@ typedef struct { ...@@ -31,13 +42,13 @@ typedef struct {
* *
* Returns 0 on success, -1 on error. * Returns 0 on success, -1 on error.
*/ */
int send_init(send_t* send); int create_userspace_send_handle(userspace_send_handle_t* handle);
/** /**
* send_send() - Sends a message over the message queue. * send_send() - Sends a message over the message queue.
* *
* Returns 0 on success, -1 on error. * Returns 0 on success, -1 on error.
*/ */
int send_send(send_t* send, daemon_measurement_t measurement); int send_userspace_message(userspace_send_handle_t* handle, message_t message);
/** /**
* send_destroy() - Destroys the message queue handle. * send_destroy() - Destroys the message queue handle.
* *
...@@ -45,4 +56,4 @@ int send_send(send_t* send, daemon_measurement_t measurement); ...@@ -45,4 +56,4 @@ int send_send(send_t* send, daemon_measurement_t measurement);
* *
* Always returns 0. * Always returns 0.
*/ */
int send_destroy(send_t* send); int destroy_userspace_send_handle(userspace_send_handle_t* handle);
#include "../include/communication.h"
#include <stddef.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
int create_communication_handle(char* path, communication_handle_t* handle) {
handle->fd = open(path, O_WRONLY);
if (handle->fd < 0) {
return -1;
}
return 0;
}
void destroy_communication_handle(communication_handle_t* handle) {
close(handle->fd);
}
int create_message(message_t* message, int32_t id, message_data_type_t type, size_t length, void* data) {
message->id = id;
message->type = type;
message->length = length;
if(length > MESSAGE_DATA_SIZE) {
return -1;
}
memcpy(&message->data, data, length);
return 0;
}
int push_message(communication_handle_t* handle, message_t* message) {
if(write(handle->fd, message, sizeof(message_t)) == -1) {
return -1;
}
return 0;
}
...@@ -26,3 +26,13 @@ size_t message_data_type_size(message_data_type_t type) { ...@@ -26,3 +26,13 @@ size_t message_data_type_size(message_data_type_t type) {
return 0; return 0;
} }
} }
int message_check(message_t* message) {
int data_type_size = message_data_type_size(message->datatype);
if (data_type_size * message->length > MAX_MESSAGE_DATA_SIZE) {
return -1;
}
return 0;
}
#include "../include/protocol.h"
int daemon_measurement_datatype_size(daemon_measurement_datatype_t datatype) {
switch (datatype) {
case CHAR:
return 1;
case INT64:
case UINT64:
case FLOAT64:
return 8;
}
}
int daemon_measurement_check(daemon_measurement_t* daemon_measurement) {
int datatype_size = daemon_measurement_datatype_size(daemon_measurement->datatype);
if (datatype_size * daemon_measurement->length > MAX_DAEMON_PACKET_DATA_SIZE) {
return -1;
}
return 0;
}
key_t msg_queue_key() {
return ftok(MSG_QUEUE_KEY, MSG_QUEUE_PROJ_ID);
}
#include "../include/protocol.h"
#include "../include/userspace_comm.h" #include "../include/userspace_comm.h"
#include <sys/ipc.h> #include <sys/ipc.h>
#include <sys/msg.h> #include <sys/msg.h>
int send_init(send_t* send) { key_t msg_queue_key() {
return ftok(MSG_QUEUE_KEY, MSG_QUEUE_PROJ_ID);
}
int create_userspace_send_handle(userspace_send_handle_t* handle) {
int key; int key;
int msg_queue_id; int msg_queue_id;
...@@ -14,21 +17,21 @@ int send_init(send_t* send) { ...@@ -14,21 +17,21 @@ int send_init(send_t* send) {
return -1; return -1;
} }
send->msg_queue_id = msg_queue_id; handle->msg_queue_id = msg_queue_id;
return 0; return 0;
} }
int send_send(send_t *send, daemon_measurement_t measurement) { int send_userspace_message(userspace_send_handle_t* handle, message_t message) {
message_t message = { message_queue_message_t message_queue_message = {
.message_type = MESSAGE_MEASUREMENT_ID, .message_type = MESSAGE_MEASUREMENT_ID,
.measurement = measurement, .message = message,
}; };
msgsnd(send->msg_queue_id, &message, sizeof(daemon_measurement_t), 0); msgsnd(handle->msg_queue_id, &message_queue_message, sizeof(message_t), 0);
return 0; return 0;
} }
int send_destroy(send_t *send) { int destroy_userspace_send_handle(userspace_send_handle_t* handle) {
return 0; return 0;
} }
add_executable(daemon add_executable(daemon
src/main.c src/main.c
src/receive.c src/receive.c
src/send.c
) )
target_link_libraries(daemon target_link_libraries(daemon
......
#pragma once #pragma once
#include "../../common/include/protocol.h" #include "../../common/include/message.h"
#include <sys/ipc.h> #include <sys/ipc.h>
/** /**
* typedef receive_t - The receive module. * typedef userspace_receive_handle_t - The receive module.
* @msg_id: Id of the message queue that is used internally to communicate. * @msg_id: Id of the message queue that is used internally to communicate.
*/ */
typedef struct { typedef struct {
int msg_queue_id; int msg_queue_id;
} receive_t; } userspace_receive_handle_t;
/** /**
* receive_init() - Initializes the receive module. * create_userspace_receive_handle() - Initializes the receive module.
* @arg1: The receive module. * @arg1: The receive module.
* *
* Creates a file at `MSG_QUEUE_KEY` and a message queue with `MSG_QUEUE_KEY` as key and `MSG_QUEUE_PROJ_ID` as project id. * Creates a file at `MSG_QUEUE_KEY` and a message queue with `MSG_QUEUE_KEY` as key and `MSG_QUEUE_PROJ_ID` as project id.
...@@ -19,17 +19,17 @@ typedef struct { ...@@ -19,17 +19,17 @@ typedef struct {
* *
* Returns 0 on success, -1 on error. * Returns 0 on success, -1 on error.
*/ */
int receive_init(receive_t* receive); int create_userspace_receive_handle(userspace_receive_handle_t* handle);
/** /**
* receive_read() - Reads a measurement from the message queue. * recv_userspace_receive_handle() - Reads a measurement from the message queue.
* @arg1: The receive module. * @arg1: The receive module.
* @arg2: The struct to store the read measurement in. * @arg2: The struct to store the read measurement in.
* *
* Returns 0 on success, -1 on error. * Returns 0 on success, -1 on error.
*/ */
int receive_read(receive_t* receive, daemon_measurement_t* daemon_measurement); int recv_userspace_message(userspace_receive_handle_t* handle, message_t* message);
/** /**
* receive_deinit() - Deinitializes the receive module. * destroy_userspace_receive_handle() - Deinitializes the receive module.
* @arg1: The receive module. * @arg1: The receive module.
* *
* The always returns 0, but is not guaranteed to be successful, so any occuring error is silent. * The always returns 0, but is not guaranteed to be successful, so any occuring error is silent.
...@@ -37,4 +37,4 @@ int receive_read(receive_t* receive, daemon_measurement_t* daemon_measurement); ...@@ -37,4 +37,4 @@ int receive_read(receive_t* receive, daemon_measurement_t* daemon_measurement);
* *
* Always returns 0. * Always returns 0.
*/ */
int receive_destroy(receive_t* receive); int destroy_userspace_receive_handle(userspace_receive_handle_t* handle);
#pragma once
#include "../../common/include/message.h"
#define KERNEL_DEVICE_PATH "/dev/amogus"
typedef struct {
int fd;
} kernel_send_handle_t;
int create_kernel_send_handle(kernel_send_handle_t* handle);
int send_kernel_message(kernel_send_handle_t* handle, message_t* message);
int destroy_kernel_send_handle(kernel_send_handle_t* handle);
#include "../../common/include/message.h"
#include "../include/receive.h" #include "../include/receive.h"
#include <stddef.h> #include <stddef.h>
#include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <fcntl.h> #include <fcntl.h>
...@@ -8,23 +10,38 @@ ...@@ -8,23 +10,38 @@
#include <unistd.h> #include <unistd.h>
#include <signal.h> #include <signal.h>
receive_t receive; userspace_receive_handle_t userspace_receive_handle;
void signal_handler(int sig) { void signal_handler(int sig) {
receive_destroy(&receive); destroy_userspace_receive_handle(&userspace_receive_handle);
exit(1); exit(1);
} }
void print_measurement_data(daemon_measurement_t* measurement) { void print_message_data(message_t* message) {
int datatype_size = daemon_measurement_datatype_size(measurement->datatype); int data_type_size = message_data_type_size(message->datatype);
for (int i = 0; i < datatype_size / measurement->length; i++) { for (int i = 0; i < data_type_size / message->length; i++) {
uint8_t buf[datatype_size]; uint8_t buf[data_type_size];
for (int j = 0; j < datatype_size; j++) { for (int j = 0; j < data_type_size; j++) {
buf[j] = measurement->data[(i * datatype_size) + j]; buf[j] = message->data[(i * data_type_size) + j];
} }
switch (measurement->datatype) { switch (message->datatype) {
case CHAR: case INT8:
printf("%c", *(char*)buf); printf("%d", *(int8_t*)buf);
break;
case UINT8:
printf("%d", *(uint8_t*)buf);
break;
case INT16:
printf("%d", *(int16_t*)buf);
break;
case UINT16:
printf("%d", *(uint16_t*)buf);
break;
case INT32:
printf("%d", *(int32_t*)buf);
break;
case UINT32:
printf("%d", *(uint32_t*)buf);
break; break;
case INT64: case INT64:
printf("%ld", *(int64_t*)buf); printf("%ld", *(int64_t*)buf);
...@@ -32,19 +49,22 @@ void print_measurement_data(daemon_measurement_t* measurement) { ...@@ -32,19 +49,22 @@ void print_measurement_data(daemon_measurement_t* measurement) {
case UINT64: case UINT64:
printf("%ld", *(uint64_t*)buf); printf("%ld", *(uint64_t*)buf);
break; break;
case FLOAT32:
printf("%f", *(float*)buf);
break;
case FLOAT64: case FLOAT64:
printf("%f", *(double*)buf); printf("%f", *(double*)buf);
break; break;
} }
if (measurement->datatype != CHAR && i != measurement->length - 1) { if (i != message->length - 1) {
printf(" "); printf(" ");
} }
} }
} }
int main() { int main() {
if (receive_init(&receive) != 0) { if (create_userspace_receive_handle(&userspace_receive_handle) != 0) {
perror("Failed to create receive module"); perror("Failed to create receive module");
return EXIT_FAILURE; return EXIT_FAILURE;
} }
...@@ -57,18 +77,18 @@ int main() { ...@@ -57,18 +77,18 @@ int main() {
sigaction(SIGINT, &signal_action, NULL); sigaction(SIGINT, &signal_action, NULL);
while (1) { while (1) {
daemon_measurement_t daemon_measurement; message_t message;
if (receive_read(&receive, &daemon_measurement) != 0) { if (recv_userspace_message(&userspace_receive_handle, &message) != 0) {
continue; continue;
} }
printf("Received data from %d with length %d: ", daemon_measurement.measurement_id, daemon_measurement.length); printf("Received data from %d with length %d: ", message.measurement_id, message.length);
print_measurement_data(&daemon_measurement); print_message_data(&message);
printf("\n"); printf("\n");
} }
receive_destroy(&receive); destroy_userspace_receive_handle(&userspace_receive_handle);
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
#include "../../common/include/protocol.h" #include "../../common/include/message.h"
#include "../../common/include/userspace_comm.h" #include "../../common/include/userspace_comm.h"
#include "../include/receive.h" #include "../include/receive.h"
#include <stddef.h> #include <stddef.h>
...@@ -25,7 +25,7 @@ int remove_run_file() { ...@@ -25,7 +25,7 @@ int remove_run_file() {
return remove(MSG_QUEUE_KEY); return remove(MSG_QUEUE_KEY);
} }
int receive_init(receive_t* receive) { int create_userspace_receive_handle(userspace_receive_handle_t* handle) {
if (create_run_file() == -1) { if (create_run_file() == -1) {
return -1; return -1;
} }
...@@ -35,32 +35,29 @@ int receive_init(receive_t* receive) { ...@@ -35,32 +35,29 @@ int receive_init(receive_t* receive) {
return -1; return -1;
} }
int msg_queue_id = msgget(key, IPC_CREAT | IPC_EXCL | IPC_NOWAIT); if ((handle->msg_queue_id = msgget(key, IPC_CREAT | IPC_EXCL | IPC_NOWAIT)) == -1) {
if (msg_queue_id == -1) {
return -1; return -1;
} }
receive->msg_queue_id = msg_queue_id;
return 0; return 0;
} }
int receive_read(receive_t* receive, daemon_measurement_t* daemon_measurement) { int recv_userspace_message(userspace_receive_handle_t* handle, message_t* message) {
message_t message; message_queue_message_t message_queue_message;
ssize_t read = msgrcv(receive->msg_queue_id, &message, sizeof(daemon_measurement_t), MESSAGE_MEASUREMENT_ID, 0); ssize_t read = msgrcv(handle->msg_queue_id, &message_queue_message, sizeof(message_t), MESSAGE_MEASUREMENT_ID, 0);
if (read == -1) { if (read == -1) {
return -1; return -1;
} }
*daemon_measurement = message.measurement; *message = message_queue_message.message;
return 0; return 0;
} }
int receive_destroy(receive_t* receive) { int destroy_userspace_receive_handle(userspace_receive_handle_t* handle) {
remove_run_file(); remove_run_file();
msgctl(receive->msg_queue_id, IPC_RMID, NULL); msgctl(handle->msg_queue_id, IPC_RMID, NULL);
return 0; return 0;
} }
#include "../include/send.h"
#include <fcntl.h>
#include <unistd.h>
int create_kernel_send_handle(kernel_send_handle_t* handle) {
handle->fd = open(KERNEL_DEVICE_PATH, O_WRONLY);
if (handle->fd < 0) {
return -1;
}
return 0;
}
int destroy_kernel_send_handle(kernel_send_handle_t* handle) {
return close(handle->fd);
}
int send_kernel_message(kernel_send_handle_t* handle, message_t* message) {
return write(handle->fd, message, sizeof(message_t));
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment