diff --git a/clients/CMakeLists.txt b/clients/CMakeLists.txt index ad38b36c7bf153d9c06201f06d5f3220d3c5e10a..8e025abdcd7745350d2c269912cc3598f57971df 100644 --- a/clients/CMakeLists.txt +++ b/clients/CMakeLists.txt @@ -1,2 +1 @@ add_subdirectory(cpu_temp) -add_subdirectory(test) diff --git a/clients/cpu_temp/src/cpu_temp.c b/clients/cpu_temp/src/cpu_temp.c index 5f126f10e00e3e0c33b39960f21f82a246964d5e..91d7bfe4f95a5320197eb101780fe5829d2f6c04 100644 --- a/clients/cpu_temp/src/cpu_temp.c +++ b/clients/cpu_temp/src/cpu_temp.c @@ -5,7 +5,7 @@ #include <fcntl.h> #include <unistd.h> #include <string.h> -#include "../../../common/include/protocol.h" +#include "../../../common/include/message.h" #include "../../../common/include/userspace_comm.h" int main(int argc, char* argv[]) { @@ -14,8 +14,8 @@ int main(int argc, char* argv[]) { return EXIT_FAILURE; } - send_t send; - if (send_init(&send) == -1) { + userspace_send_handle_t userspace_send_handle; + if (create_userspace_send_handle(&userspace_send_handle) == -1) { perror("Failed to open message queue"); return EXIT_FAILURE; } @@ -39,20 +39,20 @@ int main(int argc, char* argv[]) { cpu_temp = (double)atoi(buffer) / 1000; - daemon_measurement_t packet = { + message_t message = { .measurement_id=atoi(argv[1]), .datatype=FLOAT64, .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); } - send_destroy(&send); + destroy_userspace_send_handle(&userspace_send_handle); close(file_fd); return EXIT_SUCCESS; diff --git a/clients/test/CMakeLists.txt b/clients/test/CMakeLists.txt deleted file mode 100644 index 71d30b5a14edd088cfcd51464766d0a1a1c8f1a9..0000000000000000000000000000000000000000 --- a/clients/test/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -add_executable(test - src/test.c -) -target_link_libraries(test - PRIVATE common -) -target_include_directories(test - PRIVATE include -) diff --git a/clients/test/src/test.c b/clients/test/src/test.c deleted file mode 100644 index 935b6d18dd6162050b5e4947856131670c2a610b..0000000000000000000000000000000000000000 --- a/clients/test/src/test.c +++ /dev/null @@ -1,37 +0,0 @@ -#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"); -} diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 94f58803b5619a086c95548aa9a5243b1d3532b6..2c04648af68afd954557dfb139ed221711c28d17 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -1,7 +1,6 @@ add_library(common - src/protocol.c + src/message.c src/userspace_comm.c - src/communication.c ) target_include_directories(common PUBLIC include diff --git a/common/include/communication.h b/common/include/communication.h deleted file mode 100644 index b3d5420b23c8ac572d422140c4bff88ef49c99e6..0000000000000000000000000000000000000000 --- a/common/include/communication.h +++ /dev/null @@ -1,19 +0,0 @@ -#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); diff --git a/common/include/message.h b/common/include/message.h index 66a8fed9431d6e2cb89a4f22bb241315573c2221..171d46367be1290d8ebe8dbfd5c01f2568f572aa 100644 --- a/common/include/message.h +++ b/common/include/message.h @@ -15,7 +15,7 @@ #include <stddef.h> #endif -#define MESSAGE_DATA_SIZE 4096 +#define MAX_MESSAGE_DATA_SIZE 4096 typedef enum message_data_type : uint32_t { INT8, @@ -30,11 +30,33 @@ typedef enum message_data_type : uint32_t { FLOAT64 } 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 { - int32_t id; - message_data_type_t type; - uint32_t length; - uint8_t data[MESSAGE_DATA_SIZE]; + uint8_t measurement_id; + message_data_type_t datatype; + uint16_t length; + uint8_t data[MAX_MESSAGE_DATA_SIZE]; } 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); +/** + * 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); diff --git a/common/include/protocol.h b/common/include/protocol.h deleted file mode 100644 index b20646a46a413607ac7a26f28e00eb9c4153623d..0000000000000000000000000000000000000000 --- a/common/include/protocol.h +++ /dev/null @@ -1,56 +0,0 @@ -#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(); diff --git a/common/include/userspace_comm.h b/common/include/userspace_comm.h index 6540dd12def65990721585b4927f3c82acade609..51a819917d83b31e7ce1b26ef2ea1f9ac5c3776a 100644 --- a/common/include/userspace_comm.h +++ b/common/include/userspace_comm.h @@ -1,29 +1,40 @@ #pragma once -#include "protocol.h" + +#include "message.h" +#include <sys/ipc.h> #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. */ typedef struct { 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. * @measurement: The measurement. */ typedef struct { // required by the message queue api in order to work long message_type; - daemon_measurement_t measurement; -} message_t; + message_t message; +} 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. * * Tries to get a handle to a message queue. @@ -31,13 +42,13 @@ typedef struct { * * 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. * * 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. * @@ -45,4 +56,4 @@ int send_send(send_t* send, daemon_measurement_t measurement); * * Always returns 0. */ -int send_destroy(send_t* send); +int destroy_userspace_send_handle(userspace_send_handle_t* handle); diff --git a/common/src/communication.c b/common/src/communication.c deleted file mode 100644 index d435db0abeacfae78d1346bce247cd0628f7385a..0000000000000000000000000000000000000000 --- a/common/src/communication.c +++ /dev/null @@ -1,40 +0,0 @@ -#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; -} diff --git a/common/src/message.c b/common/src/message.c index e59740ca100bf5aa558c6188b17424e79d2f0869..dd72492686881c68c8389ce3bebc7c48d765c3c8 100644 --- a/common/src/message.c +++ b/common/src/message.c @@ -25,4 +25,14 @@ size_t message_data_type_size(message_data_type_t type) { default: 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; +} diff --git a/common/src/protocol.c b/common/src/protocol.c deleted file mode 100644 index 0ce57442e8b0a2491342823bcc60f55366788831..0000000000000000000000000000000000000000 --- a/common/src/protocol.c +++ /dev/null @@ -1,26 +0,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); -} diff --git a/common/src/userspace_comm.c b/common/src/userspace_comm.c index 14e2786bbae13bf2497464356bc4a4b8106b0d4e..8a00efd7b0cbb25f540a4ff02eab4ed1725f825e 100644 --- a/common/src/userspace_comm.c +++ b/common/src/userspace_comm.c @@ -1,9 +1,12 @@ -#include "../include/protocol.h" #include "../include/userspace_comm.h" #include <sys/ipc.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 msg_queue_id; @@ -14,21 +17,21 @@ int send_init(send_t* send) { return -1; } - send->msg_queue_id = msg_queue_id; + handle->msg_queue_id = msg_queue_id; return 0; } -int send_send(send_t *send, daemon_measurement_t measurement) { - message_t message = { +int send_userspace_message(userspace_send_handle_t* handle, message_t message) { + message_queue_message_t message_queue_message = { .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; } -int send_destroy(send_t *send) { +int destroy_userspace_send_handle(userspace_send_handle_t* handle) { return 0; } diff --git a/daemon/CMakeLists.txt b/daemon/CMakeLists.txt index 52d7c4c5f14f28afd5508c5803da9f7cbf54d160..ed44e75e6276876e7d894580e174e4bdada1602e 100644 --- a/daemon/CMakeLists.txt +++ b/daemon/CMakeLists.txt @@ -1,6 +1,7 @@ add_executable(daemon src/main.c src/receive.c + src/send.c ) target_link_libraries(daemon diff --git a/daemon/include/receive.h b/daemon/include/receive.h index d6a116c283ce4b1e07a4842e4d9167f111c02ef3..b2508e00d5ca978084c21522f8904abf5a3dc5e8 100644 --- a/daemon/include/receive.h +++ b/daemon/include/receive.h @@ -1,17 +1,17 @@ #pragma once -#include "../../common/include/protocol.h" +#include "../../common/include/message.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. */ typedef struct { 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. * * 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 { * * 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. * @arg2: The struct to store the read measurement in. * * 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. * * 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); * * Always returns 0. */ -int receive_destroy(receive_t* receive); +int destroy_userspace_receive_handle(userspace_receive_handle_t* handle); diff --git a/daemon/include/send.h b/daemon/include/send.h new file mode 100644 index 0000000000000000000000000000000000000000..e70aabc7fce80aff5da8dfa30837fd91b6248663 --- /dev/null +++ b/daemon/include/send.h @@ -0,0 +1,13 @@ +#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); diff --git a/daemon/src/main.c b/daemon/src/main.c index 9b74fd7738e1355f69f6472a400bee5a2785a982..3f0106ad3617f8ee34f4dee6b238d1eb05ce4e4c 100644 --- a/daemon/src/main.c +++ b/daemon/src/main.c @@ -1,5 +1,7 @@ +#include "../../common/include/message.h" #include "../include/receive.h" #include <stddef.h> +#include <stdint.h> #include <stdlib.h> #include <stdio.h> #include <fcntl.h> @@ -8,23 +10,38 @@ #include <unistd.h> #include <signal.h> -receive_t receive; +userspace_receive_handle_t userspace_receive_handle; void signal_handler(int sig) { - receive_destroy(&receive); + destroy_userspace_receive_handle(&userspace_receive_handle); exit(1); } -void print_measurement_data(daemon_measurement_t* measurement) { - int datatype_size = daemon_measurement_datatype_size(measurement->datatype); - for (int i = 0; i < datatype_size / measurement->length; i++) { - uint8_t buf[datatype_size]; - for (int j = 0; j < datatype_size; j++) { - buf[j] = measurement->data[(i * datatype_size) + j]; +void print_message_data(message_t* message) { + int data_type_size = message_data_type_size(message->datatype); + for (int i = 0; i < data_type_size / message->length; i++) { + uint8_t buf[data_type_size]; + for (int j = 0; j < data_type_size; j++) { + buf[j] = message->data[(i * data_type_size) + j]; } - switch (measurement->datatype) { - case CHAR: - printf("%c", *(char*)buf); + switch (message->datatype) { + case INT8: + 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; case INT64: printf("%ld", *(int64_t*)buf); @@ -32,19 +49,22 @@ void print_measurement_data(daemon_measurement_t* measurement) { case UINT64: printf("%ld", *(uint64_t*)buf); break; + case FLOAT32: + printf("%f", *(float*)buf); + break; case FLOAT64: printf("%f", *(double*)buf); break; } - if (measurement->datatype != CHAR && i != measurement->length - 1) { + if (i != message->length - 1) { printf(" "); } } } int main() { - if (receive_init(&receive) != 0) { + if (create_userspace_receive_handle(&userspace_receive_handle) != 0) { perror("Failed to create receive module"); return EXIT_FAILURE; } @@ -57,18 +77,18 @@ int main() { sigaction(SIGINT, &signal_action, NULL); 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; } - printf("Received data from %d with length %d: ", daemon_measurement.measurement_id, daemon_measurement.length); - print_measurement_data(&daemon_measurement); + printf("Received data from %d with length %d: ", message.measurement_id, message.length); + print_message_data(&message); printf("\n"); } - receive_destroy(&receive); + destroy_userspace_receive_handle(&userspace_receive_handle); return EXIT_SUCCESS; } diff --git a/daemon/src/receive.c b/daemon/src/receive.c index 839986e9fda4d9ffd1e037e9801db8914600ef92..3047220add900fc784fa2f2fcdca4c18e9163a35 100644 --- a/daemon/src/receive.c +++ b/daemon/src/receive.c @@ -1,4 +1,4 @@ -#include "../../common/include/protocol.h" +#include "../../common/include/message.h" #include "../../common/include/userspace_comm.h" #include "../include/receive.h" #include <stddef.h> @@ -25,7 +25,7 @@ int remove_run_file() { 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) { return -1; } @@ -35,32 +35,29 @@ int receive_init(receive_t* receive) { return -1; } - int msg_queue_id = msgget(key, IPC_CREAT | IPC_EXCL | IPC_NOWAIT); - if (msg_queue_id == -1) { + if ((handle->msg_queue_id = msgget(key, IPC_CREAT | IPC_EXCL | IPC_NOWAIT)) == -1) { return -1; } - receive->msg_queue_id = msg_queue_id; - return 0; } -int receive_read(receive_t* receive, daemon_measurement_t* daemon_measurement) { - message_t message; +int recv_userspace_message(userspace_receive_handle_t* handle, 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) { return -1; } - *daemon_measurement = message.measurement; + *message = message_queue_message.message; return 0; } -int receive_destroy(receive_t* receive) { +int destroy_userspace_receive_handle(userspace_receive_handle_t* handle) { remove_run_file(); - msgctl(receive->msg_queue_id, IPC_RMID, NULL); + msgctl(handle->msg_queue_id, IPC_RMID, NULL); return 0; } diff --git a/daemon/src/send.c b/daemon/src/send.c new file mode 100644 index 0000000000000000000000000000000000000000..d104e82c0b27f188c6de462cbd693ef268334314 --- /dev/null +++ b/daemon/src/send.c @@ -0,0 +1,19 @@ +#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)); +} diff --git a/kernel/Makefile b/kernel/Makefile index 18bff6088a9de36e11827e47085320d390ed5c7c..6998dbcfce9031bfefb8712192c528b3e9cf6f9a 100644 --- a/kernel/Makefile +++ b/kernel/Makefile @@ -1,9 +1,9 @@ -obj-m += kmod.o +obj-m += kmod.o -PWD := $(CURDIR) +PWD := $(CURDIR) -all: - $(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules +all: + $(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules -clean: - $(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean \ No newline at end of file +clean: + $(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean